@traversable/schema
    Preparing search index...

    Interface ZodType

    interface ZodType {
        _def: $ZodTypeDef;
        _input: unknown;
        _output: unknown;
        _zod: $ZodTypeInternals;
        "~standard": $ZodStandardSchema<ZodType>;
        def: $ZodTypeDef;
        description?: string;
        spa: (
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ) => Promise<ZodSafeParseResult<unknown>>;
        type:
            | "string"
            | "number"
            | "bigint"
            | "boolean"
            | "symbol"
            | "undefined"
            | "object"
            | "optional"
            | "int"
            | "null"
            | "void"
            | "never"
            | "any"
            | "unknown"
            | "date"
            | "record"
            | "file"
            | "array"
            | "tuple"
            | "union"
            | "intersection"
            | "map"
            | "set"
            | "enum"
            | "literal"
            | "nullable"
            | "nonoptional"
            | "success"
            | "transform"
            | "default"
            | "prefault"
            | "catch"
            | "nan"
            | "pipe"
            | "readonly"
            | "template_literal"
            | "promise"
            | "lazy"
            | "custom";
        and<T extends SomeType>(incoming: T): ZodIntersection<ZodType, T>;
        array(): ZodArray<ZodType>;
        brand<T extends PropertyKey = PropertyKey>(
            value?: T,
        ): PropertyKey extends T ? ZodType : $ZodBranded<ZodType, T>;
        catch(def: unknown): ZodCatch<ZodType>;
        catch(def: (ctx: $ZodCatchCtx) => unknown): ZodCatch<ZodType>;
        check(...checks: (CheckFn<unknown> | $ZodCheck<unknown>)[]): this;
        clone(def?: $ZodTypeDef, params?: { parent: boolean }): this;
        default(def: unknown): ZodDefault<ZodType>;
        default(def: () => unknown): ZodDefault<ZodType>;
        describe(description: string): this;
        isNullable(): boolean;
        isOptional(): boolean;
        meta(): | undefined
        | {
            deprecated?: boolean;
            description?: string;
            id?: string;
            title?: string;
            [key: string]: unknown;
        };
        meta(
            data: {
                deprecated?: boolean;
                description?: string;
                id?: string;
                title?: string;
                [key: string]: unknown;
            },
        ): this;
        nonoptional(
            params?:
                | string
                | {
                    error?: string
                    | $ZodErrorMap<$ZodIssueInvalidType<unknown>>;
                    message?: string;
                },
        ): ZodNonOptional<ZodType>;
        nullable(): ZodNullable<ZodType>;
        nullish(): ZodOptional<ZodNullable<ZodType>>;
        optional(): ZodOptional<ZodType>;
        or<T extends SomeType>(option: T): ZodUnion<[ZodType, T]>;
        overwrite(fn: (x: unknown) => unknown): this;
        parse(data: unknown, params?: ParseContext<$ZodIssue>): unknown;
        parseAsync(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): Promise<unknown>;
        pipe<T extends $ZodType<any, unknown, $ZodTypeInternals<any, unknown>>>(
            target: T | $ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
        ): ZodPipe<ZodType, T>;
        prefault(def: () => unknown): ZodPrefault<ZodType>;
        prefault(def: unknown): ZodPrefault<ZodType>;
        readonly(): ZodReadonly<ZodType>;
        refine(
            check: (arg: unknown) => unknown,
            params?:
                | string
                | {
                    abort?: boolean;
                    error?: string
                    | $ZodErrorMap<NonNullable<$ZodIssue>>;
                    message?: string;
                    params?: Record<string, any>;
                    path?: PropertyKey[];
                    when?: (payload: ParsePayload) => boolean;
                },
        ): this;
        register<
            R extends
                $ZodRegistry<
                    MetadataType,
                    $ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>,
                >,
        >(
            registry: R,
            ...meta: ZodType extends R["_schema"]
                ? undefined extends R["_meta"]
                    ? [$replace<R["_meta"], R["_schema"] & ZodType>?]
                    : [$replace<R["_meta"], R["_schema"] & ZodType>]
                : ["Incompatible schema"],
        ): this;
        safeParse(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): ZodSafeParseResult<unknown>;
        safeParseAsync(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): Promise<ZodSafeParseResult<unknown>>;
        superRefine(
            refinement: (
                arg: unknown,
                ctx: RefinementCtx<unknown>,
            ) => void | Promise<void>,
        ): this;
        transform<NewOut>(
            transform: (
                arg: unknown,
                ctx: RefinementCtx<unknown>,
            ) => NewOut | Promise<NewOut>,
        ): ZodPipe<ZodType, ZodTransform<Awaited<NewOut>, unknown>>;
    }

    Hierarchy

    • ZodType
      • ZodType
    Index

    Properties

    _def _input _output _zod ~standard def description? spa type

    Methods

    and array brand catch check clone default describe isNullable isOptional meta nonoptional nullable nullish optional or overwrite parse parseAsync pipe prefault readonly refine register safeParse safeParseAsync superRefine transform

    Properties

    _def

    _def: $ZodTypeDef

    Use .def instead.

    _input

    _input: unknown

    Use z.input<typeof schema> instead.

    _output

    _output: unknown

    Use z.output<typeof schema> instead.

    _zod

    _zod: $ZodTypeInternals
    "~standard": $ZodStandardSchema<ZodType>
    def: $ZodTypeDef
    description?: string
    spa: (
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ) => Promise<ZodSafeParseResult<unknown>>
    type:
        | "string"
        | "number"
        | "bigint"
        | "boolean"
        | "symbol"
        | "undefined"
        | "object"
        | "optional"
        | "int"
        | "null"
        | "void"
        | "never"
        | "any"
        | "unknown"
        | "date"
        | "record"
        | "file"
        | "array"
        | "tuple"
        | "union"
        | "intersection"
        | "map"
        | "set"
        | "enum"
        | "literal"
        | "nullable"
        | "nonoptional"
        | "success"
        | "transform"
        | "default"
        | "prefault"
        | "catch"
        | "nan"
        | "pipe"
        | "readonly"
        | "template_literal"
        | "promise"
        | "lazy"
        | "custom"

    Methods

    • Type Parameters

      • T extends SomeType

      Parameters

      • incoming: T

      Returns ZodIntersection<ZodType, T>

    • Returns ZodArray<ZodType>

    • Type Parameters

      • T extends PropertyKey = PropertyKey

      Parameters

      • Optionalvalue: T

      Returns PropertyKey extends T ? ZodType : $ZodBranded<ZodType, T>

    • Parameters

      • def: unknown

      Returns ZodCatch<ZodType>

    • Parameters

      • def: (ctx: $ZodCatchCtx) => unknown

      Returns ZodCatch<ZodType>

    • Parameters

      • ...checks: (CheckFn<unknown> | $ZodCheck<unknown>)[]

      Returns this

    • Parameters

      • Optionaldef: $ZodTypeDef
      • Optionalparams: { parent: boolean }

      Returns this

    • Parameters

      • def: unknown

      Returns ZodDefault<ZodType>

    • Parameters

      • def: () => unknown

      Returns ZodDefault<ZodType>

    • Returns a new instance that has been registered in z.globalRegistry with the specified description

      Parameters

      • description: string

      Returns this

    • Returns boolean

      Try safe-parsing null (this is what isNullable does internally):

      const schema = z.string().nullable();
      const isNullable = schema.safeParse(null).success; // true

    • Returns boolean

      Try safe-parsing undefined (this is what isOptional does internally):

      const schema = z.string().optional();
      const isOptional = schema.safeParse(undefined).success; // true

    • Returns the metadata associated with this instance in z.globalRegistry

      Returns
          | undefined
          | {
              deprecated?: boolean;
              description?: string;
              id?: string;
              title?: string;
              [key: string]: unknown;
          }

    • Returns a new instance that has been registered in z.globalRegistry with the specified metadata

      Parameters

      • data: {
            deprecated?: boolean;
            description?: string;
            id?: string;
            title?: string;
            [key: string]: unknown;
        }

      Returns this

    • Parameters

      • Optionalparams:
            | string
            | {
                error?: string
                | $ZodErrorMap<$ZodIssueInvalidType<unknown>>;
                message?: string;
            }
        • string
        • {
              error?: string | $ZodErrorMap<$ZodIssueInvalidType<unknown>>;
              message?: string;
          }
          • Optionalerror?: string | $ZodErrorMap<$ZodIssueInvalidType<unknown>>
          • Optionalmessage?: string

            This parameter is deprecated. Use error instead.

      Returns ZodNonOptional<ZodType>

    • Returns ZodNullable<ZodType>

    • Returns ZodOptional<ZodNullable<ZodType>>

    • Returns ZodOptional<ZodType>

    • Type Parameters

      • T extends SomeType

      Parameters

      • option: T

      Returns ZodUnion<[ZodType, T]>

    • Parameters

      • fn: (x: unknown) => unknown

      Returns this

    • Parameters

      • data: unknown
      • Optionalparams: ParseContext<$ZodIssue>

      Returns unknown

    • Parameters

      • data: unknown
      • Optionalparams: ParseContext<$ZodIssue>

      Returns Promise<unknown>

    • Type Parameters

      • T extends $ZodType<any, unknown, $ZodTypeInternals<any, unknown>>

      Parameters

      • target: T | $ZodType<any, unknown, $ZodTypeInternals<any, unknown>>

      Returns ZodPipe<ZodType, T>

    • Parameters

      • def: () => unknown

      Returns ZodPrefault<ZodType>

    • Parameters

      • def: unknown

      Returns ZodPrefault<ZodType>

    • Returns ZodReadonly<ZodType>

    • Parameters

      • check: (arg: unknown) => unknown
      • Optionalparams:
            | string
            | {
                abort?: boolean;
                error?: string
                | $ZodErrorMap<NonNullable<$ZodIssue>>;
                message?: string;
                params?: Record<string, any>;
                path?: PropertyKey[];
                when?: (payload: ParsePayload) => boolean;
            }
        • string
        • {
              abort?: boolean;
              error?: string | $ZodErrorMap<NonNullable<$ZodIssue>>;
              message?: string;
              params?: Record<string, any>;
              path?: PropertyKey[];
              when?: (payload: ParsePayload) => boolean;
          }
          • Optionalabort?: boolean

            If true, no later checks will be executed if this check fails. Default false.

          • Optionalerror?: string | $ZodErrorMap<NonNullable<$ZodIssue>>
          • Optionalmessage?: string

            This parameter is deprecated. Use error instead.

          • Optionalparams?: Record<string, any>
          • Optionalpath?: PropertyKey[]
          • Optionalwhen?: (payload: ParsePayload) => boolean

            If provided, this check will only be executed if the function returns true. Defaults to payload => z.util.isAborted(payload).

      Returns this

    • Type Parameters

      • R extends $ZodRegistry<
            MetadataType,
            $ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>,
        >

      Parameters

      • registry: R
      • ...meta: ZodType extends R["_schema"]
            ? undefined extends R["_meta"]
                ? [$replace<R["_meta"], R["_schema"] & ZodType>?]
                : [$replace<R["_meta"], R["_schema"] & ZodType>]
            : ["Incompatible schema"]

      Returns this

    • Parameters

      • data: unknown
      • Optionalparams: ParseContext<$ZodIssue>

      Returns ZodSafeParseResult<unknown>

    • Parameters

      • data: unknown
      • Optionalparams: ParseContext<$ZodIssue>

      Returns Promise<ZodSafeParseResult<unknown>>

    • Parameters

      • refinement: (arg: unknown, ctx: RefinementCtx<unknown>) => void | Promise<void>

      Returns this

      Use .check() instead.

    • Type Parameters

      • NewOut

      Parameters

      • transform: (arg: unknown, ctx: RefinementCtx<unknown>) => NewOut | Promise<NewOut>

      Returns ZodPipe<ZodType, ZodTransform<Awaited<NewOut>, unknown>>

    Settings

    Member Visibility

    On This Page

    Properties
    Methods