Interface ParsePayload<T>

Type Declaration

• {
      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[]