Function finalizeIssue

Parameters

• iss:
      | {
          code: "invalid_type";
          continue?: boolean;
          expected: | "string"
          | "number"
          | "bigint"
          | "boolean"
          | "symbol"
          | "undefined"
          | "object"
          | "function"
          | "map"
          | "default"
          | "int"
          | "null"
          | "void"
          | "never"
          | "any"
          | "unknown"
          | "date"
          | "record"
          | "file"
          | "array"
          | "tuple"
          | "union"
          | "intersection"
          | "set"
          | "enum"
          | "literal"
          | "nullable"
          | "optional"
          | "nonoptional"
          | "success"
          | "transform"
          | "prefault"
          | "catch"
          | "nan"
          | "pipe"
          | "readonly"
          | "template_literal"
          | "promise"
          | "lazy"
          | "custom";
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          message?: string;
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "too_big";
          continue?: boolean;
          exact?: boolean;
          inclusive?: boolean;
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          maximum: number | bigint;
          message?: string;
          origin:
              | "string"
              | "number"
              | "bigint"
              | "int"
              | "date"
              | "file"
              | "array"
              | "set"
              | string & {};
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "too_small";
          continue?: boolean;
          exact?: boolean;
          inclusive?: boolean;
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          message?: string;
          minimum: number | bigint;
          origin:
              | "string"
              | "number"
              | "bigint"
              | "int"
              | "date"
              | "file"
              | "array"
              | "set"
              | string & {};
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "invalid_format";
          continue?: boolean;
          format: string & {}
          | $ZodStringFormats;
          input: string | undefined;
          inst?:
              | z.core.$ZodType<
                  unknown,
                  unknown,
                  $ZodTypeInternals<unknown, unknown>,
              >
              | z.core.$ZodCheck<never>;
          message?: string;
          path?: PropertyKey[];
          pattern?: string;
          [key: string]: unknown;
      }
      | {
          code: "not_multiple_of";
          continue?: boolean;
          divisor: number;
          input: number
          | bigint
          | undefined;
          inst?:
              | z.core.$ZodType<
                  unknown,
                  unknown,
                  $ZodTypeInternals<unknown, unknown>,
              >
              | z.core.$ZodCheck<never>;
          message?: string;
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "unrecognized_keys";
          continue?: boolean;
          input: Record<string, unknown>
          | undefined;
          inst?:
              | z.core.$ZodType<
                  unknown,
                  unknown,
                  $ZodTypeInternals<unknown, unknown>,
              >
              | z.core.$ZodCheck<never>;
          keys: string[];
          message?: string;
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "invalid_union";
          continue?: boolean;
          discriminator?: string;
          errors: $ZodIssue[][];
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          message?: string;
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "invalid_key";
          continue?: boolean;
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          issues: $ZodIssue[];
          message?: string;
          origin: "map" | "record";
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "invalid_element";
          continue?: boolean;
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          issues: $ZodIssue[];
          key: unknown;
          message?: string;
          origin: "map" | "set";
          path?: PropertyKey[];
          [key: string]: unknown;
      }
      | {
          code: "invalid_value";
          continue?: boolean;
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          message?: string;
          path?: PropertyKey[];
          values: Primitive[];
          [key: string]: unknown;
      }
      | {
          code: "custom";
          continue?: boolean;
          input: unknown;
          inst?: | z.core.$ZodType<
              unknown,
              unknown,
              $ZodTypeInternals<unknown, unknown>,
          >
          | z.core.$ZodCheck<never>;
          message?: string;
          params?: Record<string, any>;
          path?: PropertyKey[];
          [key: string]: unknown;
      }
  • {
        code: "invalid_type";
        continue?: boolean;
        expected:
            | "string"
            | "number"
            | "bigint"
            | "boolean"
            | "symbol"
            | "undefined"
            | "object"
            | "function"
            | "map"
            | "default"
            | "int"
            | "null"
            | "void"
            | "never"
            | "any"
            | "unknown"
            | "date"
            | "record"
            | "file"
            | "array"
            | "tuple"
            | "union"
            | "intersection"
            | "set"
            | "enum"
            | "literal"
            | "nullable"
            | "optional"
            | "nonoptional"
            | "success"
            | "transform"
            | "prefault"
            | "catch"
            | "nan"
            | "pipe"
            | "readonly"
            | "template_literal"
            | "promise"
            | "lazy"
            | "custom";
        input: unknown;
        inst?: | z.core.$ZodType<
            unknown,
            unknown,
            $ZodTypeInternals<unknown, unknown>,
        >
        | z.core.$ZodCheck<never>;
        message?: string;
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "invalid_type"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyexpected:
          | "string"
          | "number"
          | "bigint"
          | "boolean"
          | "symbol"
          | "undefined"
          | "object"
          | "function"
          | "map"
          | "default"
          | "int"
          | "null"
          | "void"
          | "never"
          | "any"
          | "unknown"
          | "date"
          | "record"
          | "file"
          | "array"
          | "tuple"
          | "union"
          | "intersection"
          | "set"
          | "enum"
          | "literal"
          | "nullable"
          | "optional"
          | "nonoptional"
          | "success"
          | "transform"
          | "prefault"
          | "catch"
          | "nan"
          | "pipe"
          | "readonly"
          | "template_literal"
          | "promise"
          | "lazy"
          | "custom"

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "too_big";
        continue?: boolean;
        exact?: boolean;
        inclusive?: boolean;
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        maximum: number | bigint;
        message?: string;
        origin:
            | "string"
            | "number"
            | "bigint"
            | "int"
            | "date"
            | "file"
            | "array"
            | "set"
            | string & {};
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "too_big"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Optional Readonlyexact?: boolean

    • Optional Readonlyinclusive?: boolean

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Readonlymaximum: number | bigint

    • Optional Readonlymessage?: string

    • Readonlyorigin:
          | "string"
          | "number"
          | "bigint"
          | "int"
          | "date"
          | "file"
          | "array"
          | "set"
          | string & {}

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "too_small";
        continue?: boolean;
        exact?: boolean;
        inclusive?: boolean;
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        message?: string;
        minimum: number | bigint;
        origin:
            | "string"
            | "number"
            | "bigint"
            | "int"
            | "date"
            | "file"
            | "array"
            | "set"
            | string & {};
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "too_small"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Optional Readonlyexact?: boolean

      True if the allowed value is fixed (e.g. z.length(5)), not a range (z.minLength(5))

    • Optional Readonlyinclusive?: boolean

      True if the allowable range includes the minimum

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Readonlyminimum: number | bigint

    • Readonlyorigin:
          | "string"
          | "number"
          | "bigint"
          | "int"
          | "date"
          | "file"
          | "array"
          | "set"
          | string & {}

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "invalid_format";
        continue?: boolean;
        format: string & {} | $ZodStringFormats;
        input: string | undefined;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        message?: string;
        path?: PropertyKey[];
        pattern?: string;
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "invalid_format"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyformat: string & {} | $ZodStringFormats

    • Readonlyinput: string | undefined

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlypattern?: string

  • {
        code: "not_multiple_of";
        continue?: boolean;
        divisor: number;
        input: number | bigint | undefined;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        message?: string;
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "not_multiple_of"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlydivisor: number

    • Readonlyinput: number | bigint | undefined

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "unrecognized_keys";
        continue?: boolean;
        input: Record<string, unknown> | undefined;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        keys: string[];
        message?: string;
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "unrecognized_keys"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyinput: Record<string, unknown> | undefined

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Readonlykeys: string[]

    • Optional Readonlymessage?: string

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "invalid_union";
        continue?: boolean;
        discriminator?: string;
        errors: $ZodIssue[][];
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        message?: string;
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "invalid_union"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Optional Readonlydiscriminator?: string

    • Readonlyerrors: $ZodIssue[][]

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "invalid_key";
        continue?: boolean;
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        issues: $ZodIssue[];
        message?: string;
        origin: "map" | "record";
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "invalid_key"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Readonlyissues: $ZodIssue[]

    • Optional Readonlymessage?: string

    • Readonlyorigin: "map" | "record"

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "invalid_element";
        continue?: boolean;
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        issues: $ZodIssue[];
        key: unknown;
        message?: string;
        origin: "map" | "set";
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "invalid_element"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Readonlyissues: $ZodIssue[]

    • Readonlykey: unknown

    • Optional Readonlymessage?: string

    • Readonlyorigin: "map" | "set"

    • Optional Readonlypath?: PropertyKey[]

  • {
        code: "invalid_value";
        continue?: boolean;
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        message?: string;
        path?: PropertyKey[];
        values: Primitive[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "invalid_value"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Optional Readonlypath?: PropertyKey[]

    • Readonlyvalues: Primitive[]

  • {
        code: "custom";
        continue?: boolean;
        input: unknown;
        inst?:
            | z.core.$ZodType<
                unknown,
                unknown,
                $ZodTypeInternals<unknown, unknown>,
            >
            | z.core.$ZodCheck<never>;
        message?: string;
        params?: Record<string, any>;
        path?: PropertyKey[];
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlycode: "custom"

    • Optional Readonlycontinue?: boolean

      If true, Zod will continue executing checks/refinements after this issue.

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyinst?:
          | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>
          | z.core.$ZodCheck<never>

      The schema or check that originated this issue.

    • Optional Readonlymessage?: string

    • Optional Readonlyparams?: Record<string, any>

    • Optional Readonlypath?: PropertyKey[]

• ctx: ParseContextInternal<never> | undefined
• config: $ZodConfig