Function finalizeIssue

Parameters

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

    • [key: string]: unknown

    • Readonlyinput: undefined | Record<string, unknown>

      The input data

    • Readonlykeys: string[]

    • Readonlycode: "unrecognized_keys"

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

  • {
        input: unknown;
        code: "invalid_type";
        expected:
            | "string"
            | "number"
            | "bigint"
            | "boolean"
            | "symbol"
            | "undefined"
            | "object"
            | "function"
            | "int"
            | "null"
            | "void"
            | "never"
            | "any"
            | "unknown"
            | "date"
            | "record"
            | "file"
            | "array"
            | "tuple"
            | "union"
            | "intersection"
            | "map"
            | "set"
            | "enum"
            | "literal"
            | "nullable"
            | "optional"
            | "nonoptional"
            | "success"
            | "transform"
            | "default"
            | "prefault"
            | "catch"
            | "nan"
            | "pipe"
            | "readonly"
            | "template_literal"
            | "promise"
            | "lazy"
            | "custom";
        path?: PropertyKey[];
        message?: string;
        inst?: | z.core.$ZodCheck<never>
        | z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
        continue?: boolean;
        [key: string]: unknown;
    }

    • [key: string]: unknown

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "invalid_type"

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

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlymaximum: number | bigint

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "too_big"

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

    • Optional Readonlyinclusive?: boolean

    • Optional Readonlyexact?: boolean

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyminimum: number | bigint

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "too_small"

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

    • Optional Readonlyinclusive?: boolean

      True if the allowable range includes the minimum

    • Optional Readonlyexact?: boolean

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

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyformat: string & {} | $ZodStringFormats

    • Readonlyinput: undefined | string

      The input data

    • Readonlycode: "invalid_format"

    • Optional Readonlypattern?: string

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyinput: undefined | number | bigint

      The input data

    • Readonlycode: "not_multiple_of"

    • Readonlydivisor: number

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "invalid_union"

    • Readonlyerrors: $ZodIssue[][]

    • Optional Readonlydiscriminator?: string

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "invalid_key"

    • Readonlyorigin: "record" | "map"

    • Readonlyissues: $ZodIssue[]

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "invalid_element"

    • Readonlyorigin: "map" | "set"

    • Readonlyissues: $ZodIssue[]

    • Readonlykey: unknown

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyvalues: Primitive[]

    • Readonlyinput: unknown

      The input data

    • Readonlycode: "invalid_value"

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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

    • [key: string]: unknown

    • Readonlyinput: unknown

      The input data

    • Optional Readonlyparams?: Record<string, any>

    • Readonlycode: "custom"

    • Optional Readonlypath?: PropertyKey[]

    • Optional Readonlymessage?: string

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

      The schema or check that originated this issue.

    • Optional Readonlycontinue?: boolean

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

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