Interface $RefinementCtx<T>

addIssue

• addIssue(
      arg:
          | string
          | {
              input?: 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?: 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?: 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;
          },
  ): void

  Parameters

  • arg:
        | string
        | {
            input?: 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?: 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?: 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;
        }
    • string
    • {
          input?: 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

      • Optional Readonlyinput?: Record<string, unknown>

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

    • {
          format: string & {} | $ZodStringFormats;
          input?: 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

      • Optional Readonlyinput?: string

      • 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 execute subsequent checks/refinements instead of immediately aborting

    • {
          input?: 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

      • Optional Readonlyinput?: number | bigint

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

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

      • Optional Readonlyinput?: unknown

      • 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 execute subsequent checks/refinements instead of immediately aborting

  Returns void