Interface $RefinementCtx<T>

addIssue

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

  Parameters

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "invalid_type"

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

      • Optional Readonlyinput?: unknown

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "too_big"

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

      • Readonlymaximum: number | bigint

      • Optional Readonlyinclusive?: boolean

      • Optional Readonlyexact?: boolean

      • Optional Readonlyinput?: unknown

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "too_small"

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

      • Readonlyminimum: number | bigint

      • 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 Readonlyinput?: unknown

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "invalid_format"

      • Readonlyformat: string & {} | $ZodStringFormats

      • Optional Readonlypattern?: string

      • Optional Readonlyinput?: string

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "not_multiple_of"

      • Readonlydivisor: number

      • Optional Readonlyinput?: number | bigint

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "unrecognized_keys"

      • Readonlykeys: string[]

      • Optional Readonlyinput?: Record<string, unknown>

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "invalid_union"

      • Readonlyerrors: $ZodIssue[][]

      • Optional Readonlyinput?: unknown

      • Optional Readonlydiscriminator?: string

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "invalid_key"

      • Readonlyorigin: "map" | "record"

      • Readonlyissues: $ZodIssue[]

      • Optional Readonlyinput?: unknown

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "invalid_element"

      • Readonlyorigin: "map" | "set"

      • Readonlykey: unknown

      • Readonlyissues: $ZodIssue[]

      • Optional Readonlyinput?: unknown

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "invalid_value"

      • Readonlyvalues: Primitive[]

      • Optional Readonlyinput?: unknown

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

      • [key: string]: unknown

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

        The schema or check that originated this issue.

      • Optional Readonlycontinue?: boolean

        If true, Zod will execute subsequent checks/refinements instead of immediately aborting

      • Optional Readonlypath?: PropertyKey[]

      • Optional Readonlymessage?: string

      • Readonlycode: "custom"

      • Optional Readonlyparams?: Record<string, any>

      • Optional Readonlyinput?: unknown

  Returns void