Function issue

Returns
    | {
        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.