zod

  • Version 3.23.8
  • Published
  • 667 kB
  • No dependencies
  • MIT license

Install

npm i zod
yarn add zod
pnpm add zod

Overview

TypeScript-first schema declaration and validation library with static type inference

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable BRAND

const BRAND: Symbol;

    variable coerce

    const coerce: {
    string: (
    params?:
    | ({
    errorMap?: ZodErrorMap | undefined;
    invalid_type_error?: string | undefined;
    required_error?: string | undefined;
    message?: string | undefined;
    description?: string | undefined;
    } & { coerce?: true | undefined })
    | undefined
    ) => ZodString;
    number: (
    params?:
    | ({
    errorMap?: ZodErrorMap | undefined;
    invalid_type_error?: string | undefined;
    required_error?: string | undefined;
    message?: string | undefined;
    description?: string | undefined;
    } & { coerce?: boolean | undefined })
    | undefined
    ) => ZodNumber;
    boolean: (
    params?:
    | ({
    errorMap?: ZodErrorMap | undefined;
    invalid_type_error?: string | undefined;
    required_error?: string | undefined;
    message?: string | undefined;
    description?: string | undefined;
    } & { coerce?: boolean | undefined })
    | undefined
    ) => ZodBoolean;
    bigint: (
    params?:
    | ({
    errorMap?: ZodErrorMap | undefined;
    invalid_type_error?: string | undefined;
    required_error?: string | undefined;
    message?: string | undefined;
    description?: string | undefined;
    } & { coerce?: boolean | undefined })
    | undefined
    ) => ZodBigInt;
    date: (
    params?:
    | ({
    errorMap?: ZodErrorMap | undefined;
    invalid_type_error?: string | undefined;
    required_error?: string | undefined;
    message?: string | undefined;
    description?: string | undefined;
    } & { coerce?: boolean | undefined })
    | undefined
    ) => ZodDate;
    };

      variable defaultErrorMap

      const defaultErrorMap: ZodErrorMap;

        variable discriminatedUnion

        const discriminatedUnion: <
        Discriminator extends string,
        Types extends [
        ZodDiscriminatedUnionOption<Discriminator>,
        ...ZodDiscriminatedUnionOption<Discriminator>[]
        ]
        >(
        discriminator: Discriminator,
        options: Types,
        params?: {
        errorMap?: ZodErrorMap;
        invalid_type_error?: string;
        required_error?: string;
        message?: string;
        description?: string;
        }
        ) => ZodDiscriminatedUnion<Discriminator, Types>;

          variable EMPTY_PATH

          const EMPTY_PATH: ParsePath;

            variable enum

            const enum: { <U extends string, T extends readonly [U, ...U[]]>(values: T, params?: { errorMap?: ZodErrorMap; invalid_type_error?: string; required_error?: string; message?: string; description?: string; }): ZodEnum<Writeable<T>>; <U extends string, T extends [U, ...U[]]>(values: T, params?: { errorMap?: ZodErrorMap; invalid_type_error?: string; required_error?: string; message?: string; description?: string; }): ZodEnum<T>; }

              variable function

              const function: { (): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>; <T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>; <T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>; <T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: { errorMap?: ZodErrorMap; invalid_type_error?: string; required_error?: string; message?: string; description?: string; }): ZodFunction<T, U>; }

                variable INVALID

                const INVALID: INVALID;

                  variable late

                  const late: {
                  object: <T extends ZodRawShape>(
                  shape: () => T,
                  params?: RawCreateParams
                  ) => ZodObject<
                  T,
                  'strip',
                  ZodTypeAny,
                  {
                  [k in keyof objectUtil.addQuestionMarks<
                  baseObjectOutputType<T>,
                  any
                  >]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>[k];
                  },
                  { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1] }
                  >;
                  };

                    variable NEVER

                    const NEVER: never;

                      variable pipeline

                      const pipeline: <A extends ZodTypeAny, B extends ZodTypeAny>(
                      a: A,
                      b: B
                      ) => ZodPipeline<A, B>;

                        variable record

                        const record: {
                        <Value extends ZodTypeAny>(
                        valueType: Value,
                        params?: {
                        errorMap?: ZodErrorMap;
                        invalid_type_error?: string;
                        required_error?: string;
                        message?: string;
                        description?: string;
                        }
                        ): ZodRecord<ZodString, Value>;
                        <Keys extends KeySchema, Value extends ZodTypeAny>(
                        keySchema: Keys,
                        valueType: Value,
                        params?: {
                        errorMap?: ZodErrorMap;
                        invalid_type_error?: string;
                        required_error?: string;
                        message?: string;
                        description?: string;
                        }
                        ): ZodRecord<Keys, Value>;
                        };

                          variable ZodIssueCode

                          const ZodIssueCode: {
                          invalid_type: 'invalid_type';
                          invalid_literal: 'invalid_literal';
                          custom: 'custom';
                          invalid_union: 'invalid_union';
                          invalid_union_discriminator: 'invalid_union_discriminator';
                          invalid_enum_value: 'invalid_enum_value';
                          unrecognized_keys: 'unrecognized_keys';
                          invalid_arguments: 'invalid_arguments';
                          invalid_return_type: 'invalid_return_type';
                          invalid_date: 'invalid_date';
                          invalid_string: 'invalid_string';
                          too_small: 'too_small';
                          too_big: 'too_big';
                          invalid_intersection_types: 'invalid_intersection_types';
                          not_multiple_of: 'not_multiple_of';
                          not_finite: 'not_finite';
                          };

                            variable ZodParsedType

                            const ZodParsedType: {
                            function: 'function';
                            number: 'number';
                            string: 'string';
                            nan: 'nan';
                            integer: 'integer';
                            float: 'float';
                            boolean: 'boolean';
                            date: 'date';
                            bigint: 'bigint';
                            symbol: 'symbol';
                            undefined: 'undefined';
                            null: 'null';
                            array: 'array';
                            object: 'object';
                            unknown: 'unknown';
                            promise: 'promise';
                            void: 'void';
                            never: 'never';
                            map: 'map';
                            set: 'set';
                            };

                              Functions

                              function addIssueToContext

                              addIssueToContext: (ctx: ParseContext, issueData: IssueData) => void;

                                function any

                                any: (params?: RawCreateParams) => ZodAny;

                                  function array

                                  array: <T extends ZodTypeAny>(
                                  schema: T,
                                  params?: RawCreateParams
                                  ) => ZodArray<T, 'many'>;

                                    function bigint

                                    bigint: (
                                    params?:
                                    | ({
                                    errorMap?: ZodErrorMap | undefined;
                                    invalid_type_error?: string | undefined;
                                    required_error?: string | undefined;
                                    message?: string | undefined;
                                    description?: string | undefined;
                                    } & { coerce?: boolean | undefined })
                                    | undefined
                                    ) => ZodBigInt;

                                      function boolean

                                      boolean: (
                                      params?:
                                      | ({
                                      errorMap?: ZodErrorMap | undefined;
                                      invalid_type_error?: string | undefined;
                                      required_error?: string | undefined;
                                      message?: string | undefined;
                                      description?: string | undefined;
                                      } & { coerce?: boolean | undefined })
                                      | undefined
                                      ) => ZodBoolean;

                                        function custom

                                        custom: <T>(
                                        check?: (data: any) => any,
                                        params?: string | CustomParams | ((input: any) => CustomParams),
                                        fatal?: boolean
                                        ) => ZodType<T, ZodTypeDef, T>;

                                          function date

                                          date: (
                                          params?:
                                          | ({
                                          errorMap?: ZodErrorMap | undefined;
                                          invalid_type_error?: string | undefined;
                                          required_error?: string | undefined;
                                          message?: string | undefined;
                                          description?: string | undefined;
                                          } & { coerce?: boolean | undefined })
                                          | undefined
                                          ) => ZodDate;

                                            function datetimeRegex

                                            datetimeRegex: (args: {
                                            precision?: number | null;
                                            offset?: boolean;
                                            local?: boolean;
                                            }) => RegExp;

                                              function DIRTY

                                              DIRTY: <T>(value: T) => DIRTY<T>;

                                                function effect

                                                effect: <I extends ZodTypeAny>(
                                                schema: I,
                                                effect: Effect<I['_output']>,
                                                params?: RawCreateParams
                                                ) => ZodEffects<I, I['_output'], input<I>>;

                                                  function getErrorMap

                                                  getErrorMap: () => ZodErrorMap;

                                                    function getParsedType

                                                    getParsedType: (data: any) => ZodParsedType;

                                                      function instanceof

                                                      instanceof: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>

                                                        function intersection

                                                        intersection: <T extends ZodTypeAny, U extends ZodTypeAny>(
                                                        left: T,
                                                        right: U,
                                                        params?: RawCreateParams
                                                        ) => ZodIntersection<T, U>;

                                                          function isAborted

                                                          isAborted: (x: ParseReturnType<any>) => x is INVALID;

                                                            function isAsync

                                                            isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;

                                                              function isDirty

                                                              isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;

                                                                function isValid

                                                                isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;

                                                                  function lazy

                                                                  lazy: <T extends ZodTypeAny>(
                                                                  getter: () => T,
                                                                  params?: RawCreateParams
                                                                  ) => ZodLazy<T>;

                                                                    function literal

                                                                    literal: <T extends Primitive>(
                                                                    value: T,
                                                                    params?: RawCreateParams
                                                                    ) => ZodLiteral<T>;

                                                                      function makeIssue

                                                                      makeIssue: (params: {
                                                                      data: any;
                                                                      path: (string | number)[];
                                                                      errorMaps: ZodErrorMap[];
                                                                      issueData: IssueData;
                                                                      }) => ZodIssue;

                                                                        function map

                                                                        map: <
                                                                        Key extends ZodTypeAny = ZodTypeAny,
                                                                        Value extends ZodTypeAny = ZodTypeAny
                                                                        >(
                                                                        keyType: Key,
                                                                        valueType: Value,
                                                                        params?: RawCreateParams
                                                                        ) => ZodMap<Key, Value>;

                                                                          function nan

                                                                          nan: (params?: RawCreateParams) => ZodNaN;

                                                                            function nativeEnum

                                                                            nativeEnum: <T extends EnumLike>(
                                                                            values: T,
                                                                            params?: RawCreateParams
                                                                            ) => ZodNativeEnum<T>;

                                                                              function never

                                                                              never: (params?: RawCreateParams) => ZodNever;

                                                                                function null

                                                                                null: (params?: RawCreateParams) => ZodNull

                                                                                  function nullable

                                                                                  nullable: <T extends ZodTypeAny>(
                                                                                  type: T,
                                                                                  params?: RawCreateParams
                                                                                  ) => ZodNullable<T>;

                                                                                    function number

                                                                                    number: (
                                                                                    params?:
                                                                                    | ({
                                                                                    errorMap?: ZodErrorMap | undefined;
                                                                                    invalid_type_error?: string | undefined;
                                                                                    required_error?: string | undefined;
                                                                                    message?: string | undefined;
                                                                                    description?: string | undefined;
                                                                                    } & { coerce?: boolean | undefined })
                                                                                    | undefined
                                                                                    ) => ZodNumber;

                                                                                      function object

                                                                                      object: <T extends ZodRawShape>(
                                                                                      shape: T,
                                                                                      params?: RawCreateParams
                                                                                      ) => ZodObject<
                                                                                      T,
                                                                                      'strip',
                                                                                      ZodTypeAny,
                                                                                      {
                                                                                      [k in keyof objectUtil.addQuestionMarks<
                                                                                      baseObjectOutputType<T>,
                                                                                      any
                                                                                      >]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>[k];
                                                                                      },
                                                                                      { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1] }
                                                                                      >;

                                                                                        function oboolean

                                                                                        oboolean: () => ZodOptional<ZodBoolean>;

                                                                                          function OK

                                                                                          OK: <T>(value: T) => OK<T>;

                                                                                            function onumber

                                                                                            onumber: () => ZodOptional<ZodNumber>;

                                                                                              function optional

                                                                                              optional: <T extends ZodTypeAny>(
                                                                                              type: T,
                                                                                              params?: RawCreateParams
                                                                                              ) => ZodOptional<T>;

                                                                                                function ostring

                                                                                                ostring: () => ZodOptional<ZodString>;

                                                                                                  function preprocess

                                                                                                  preprocess: <I extends ZodTypeAny>(
                                                                                                  preprocess: (arg: unknown, ctx: RefinementCtx) => unknown,
                                                                                                  schema: I,
                                                                                                  params?: RawCreateParams
                                                                                                  ) => ZodEffects<I, I['_output'], unknown>;

                                                                                                    function promise

                                                                                                    promise: <T extends ZodTypeAny>(
                                                                                                    schema: T,
                                                                                                    params?: RawCreateParams
                                                                                                    ) => ZodPromise<T>;

                                                                                                      function quotelessJson

                                                                                                      quotelessJson: (obj: any) => string;

                                                                                                        function set

                                                                                                        set: <Value extends ZodTypeAny = ZodTypeAny>(
                                                                                                        valueType: Value,
                                                                                                        params?: RawCreateParams
                                                                                                        ) => ZodSet<Value>;

                                                                                                          function setErrorMap

                                                                                                          setErrorMap: (map: ZodErrorMap) => void;

                                                                                                            function strictObject

                                                                                                            strictObject: <T extends ZodRawShape>(
                                                                                                            shape: T,
                                                                                                            params?: RawCreateParams
                                                                                                            ) => ZodObject<
                                                                                                            T,
                                                                                                            'strict',
                                                                                                            ZodTypeAny,
                                                                                                            {
                                                                                                            [k in keyof objectUtil.addQuestionMarks<
                                                                                                            baseObjectOutputType<T>,
                                                                                                            any
                                                                                                            >]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>[k];
                                                                                                            },
                                                                                                            { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1] }
                                                                                                            >;

                                                                                                              function string

                                                                                                              string: (
                                                                                                              params?:
                                                                                                              | ({
                                                                                                              errorMap?: ZodErrorMap | undefined;
                                                                                                              invalid_type_error?: string | undefined;
                                                                                                              required_error?: string | undefined;
                                                                                                              message?: string | undefined;
                                                                                                              description?: string | undefined;
                                                                                                              } & { coerce?: true | undefined })
                                                                                                              | undefined
                                                                                                              ) => ZodString;

                                                                                                                function symbol

                                                                                                                symbol: (params?: RawCreateParams) => ZodSymbol;

                                                                                                                  function transformer

                                                                                                                  transformer: <I extends ZodTypeAny>(
                                                                                                                  schema: I,
                                                                                                                  effect: Effect<I['_output']>,
                                                                                                                  params?: RawCreateParams
                                                                                                                  ) => ZodEffects<I, I['_output'], input<I>>;

                                                                                                                    function tuple

                                                                                                                    tuple: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(
                                                                                                                    schemas: T,
                                                                                                                    params?: RawCreateParams
                                                                                                                    ) => ZodTuple<T, null>;

                                                                                                                      function undefined

                                                                                                                      undefined: (params?: RawCreateParams) => ZodUndefined;

                                                                                                                        function union

                                                                                                                        union: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(
                                                                                                                        types: T,
                                                                                                                        params?: RawCreateParams
                                                                                                                        ) => ZodUnion<T>;

                                                                                                                          function unknown

                                                                                                                          unknown: (params?: RawCreateParams) => ZodUnknown;

                                                                                                                            function void

                                                                                                                            void: (params?: RawCreateParams) => ZodVoid

                                                                                                                              Classes

                                                                                                                              class ParseStatus

                                                                                                                              class ParseStatus {}

                                                                                                                                property value

                                                                                                                                value: 'aborted' | 'dirty' | 'valid';

                                                                                                                                  method abort

                                                                                                                                  abort: () => void;

                                                                                                                                    method dirty

                                                                                                                                    dirty: () => void;

                                                                                                                                      method mergeArray

                                                                                                                                      static mergeArray: (
                                                                                                                                      status: ParseStatus,
                                                                                                                                      results: SyncParseReturnType<any>[]
                                                                                                                                      ) => SyncParseReturnType;

                                                                                                                                        method mergeObjectAsync

                                                                                                                                        static mergeObjectAsync: (
                                                                                                                                        status: ParseStatus,
                                                                                                                                        pairs: { key: ParseReturnType<any>; value: ParseReturnType<any> }[]
                                                                                                                                        ) => Promise<SyncParseReturnType<any>>;

                                                                                                                                          method mergeObjectSync

                                                                                                                                          static mergeObjectSync: (
                                                                                                                                          status: ParseStatus,
                                                                                                                                          pairs: {
                                                                                                                                          key: SyncParseReturnType<any>;
                                                                                                                                          value: SyncParseReturnType<any>;
                                                                                                                                          alwaysSet?: boolean;
                                                                                                                                          }[]
                                                                                                                                          ) => SyncParseReturnType;

                                                                                                                                            class Schema

                                                                                                                                            abstract class ZodType<
                                                                                                                                            Output = any,
                                                                                                                                            Def extends ZodTypeDef = ZodTypeDef,
                                                                                                                                            Input = Output
                                                                                                                                            > {}

                                                                                                                                              constructor

                                                                                                                                              constructor(def: ZodTypeDef);

                                                                                                                                                property description

                                                                                                                                                readonly description: string;

                                                                                                                                                  property spa

                                                                                                                                                  spa: (
                                                                                                                                                  data: unknown,
                                                                                                                                                  params?: Partial<ParseParams> | undefined
                                                                                                                                                  ) => Promise<SafeParseReturnType<Input, Output>>;
                                                                                                                                                  • Alias of safeParseAsync

                                                                                                                                                  method and

                                                                                                                                                  and: <T extends ZodTypeAny>(incoming: T) => ZodIntersection<this, T>;

                                                                                                                                                    method array

                                                                                                                                                    array: () => ZodArray<this>;

                                                                                                                                                      method brand

                                                                                                                                                      brand: <B extends string | number | symbol>(brand?: B) => ZodBranded<this, B>;

                                                                                                                                                        method catch

                                                                                                                                                        catch: {
                                                                                                                                                        (def: Output): ZodCatch<this>;
                                                                                                                                                        (
                                                                                                                                                        def: (ctx: { error: ZodError<any>; input: Input }) => Output
                                                                                                                                                        ): ZodCatch<this>;
                                                                                                                                                        };

                                                                                                                                                          method default

                                                                                                                                                          default: {
                                                                                                                                                          (def: util.noUndefined<Input>): ZodDefault<this>;
                                                                                                                                                          (def: () => util.noUndefined<Input>): ZodDefault<this>;
                                                                                                                                                          };

                                                                                                                                                            method describe

                                                                                                                                                            describe: (description: string) => this;

                                                                                                                                                              method isNullable

                                                                                                                                                              isNullable: () => boolean;

                                                                                                                                                                method isOptional

                                                                                                                                                                isOptional: () => boolean;

                                                                                                                                                                  method nullable

                                                                                                                                                                  nullable: () => ZodNullable<this>;

                                                                                                                                                                    method nullish

                                                                                                                                                                    nullish: () => ZodOptional<ZodNullable<this>>;

                                                                                                                                                                      method optional

                                                                                                                                                                      optional: () => ZodOptional<this>;

                                                                                                                                                                        method or

                                                                                                                                                                        or: <T extends ZodTypeAny>(option: T) => ZodUnion<[this, T]>;

                                                                                                                                                                          method parse

                                                                                                                                                                          parse: (data: unknown, params?: Partial<ParseParams>) => Output;

                                                                                                                                                                            method parseAsync

                                                                                                                                                                            parseAsync: (data: unknown, params?: Partial<ParseParams>) => Promise<Output>;

                                                                                                                                                                              method pipe

                                                                                                                                                                              pipe: <T extends ZodTypeAny>(target: T) => ZodPipeline<this, T>;

                                                                                                                                                                                method promise

                                                                                                                                                                                promise: () => ZodPromise<this>;

                                                                                                                                                                                  method readonly

                                                                                                                                                                                  readonly: () => ZodReadonly<this>;

                                                                                                                                                                                    method refine

                                                                                                                                                                                    refine: {
                                                                                                                                                                                    <RefinedOutput extends Output>(
                                                                                                                                                                                    check: (arg: Output) => arg is RefinedOutput,
                                                                                                                                                                                    message?:
                                                                                                                                                                                    | string
                                                                                                                                                                                    | Partial<util.Omit<ZodCustomIssue, 'code'>>
                                                                                                                                                                                    | ((arg: Output) => CustomErrorParams)
                                                                                                                                                                                    ): ZodEffects<this, RefinedOutput, Input>;
                                                                                                                                                                                    (
                                                                                                                                                                                    check: (arg: Output) => unknown,
                                                                                                                                                                                    message?:
                                                                                                                                                                                    | string
                                                                                                                                                                                    | Partial<util.Omit<ZodCustomIssue, 'code'>>
                                                                                                                                                                                    | ((arg: Output) => Partial<util.Omit<ZodCustomIssue, 'code'>>)
                                                                                                                                                                                    ): ZodEffects<this, Output, Input>;
                                                                                                                                                                                    };

                                                                                                                                                                                      method refinement

                                                                                                                                                                                      refinement: {
                                                                                                                                                                                      <RefinedOutput extends Output>(
                                                                                                                                                                                      check: (arg: Output) => arg is RefinedOutput,
                                                                                                                                                                                      refinementData:
                                                                                                                                                                                      | IssueData
                                                                                                                                                                                      | ((arg: Output, ctx: RefinementCtx) => IssueData)
                                                                                                                                                                                      ): ZodEffects<this, RefinedOutput, Input>;
                                                                                                                                                                                      (
                                                                                                                                                                                      check: (arg: Output) => boolean,
                                                                                                                                                                                      refinementData:
                                                                                                                                                                                      | IssueData
                                                                                                                                                                                      | ((arg: Output, ctx: RefinementCtx) => IssueData)
                                                                                                                                                                                      ): ZodEffects<this, Output, Input>;
                                                                                                                                                                                      };

                                                                                                                                                                                        method safeParse

                                                                                                                                                                                        safeParse: (
                                                                                                                                                                                        data: unknown,
                                                                                                                                                                                        params?: Partial<ParseParams>
                                                                                                                                                                                        ) => SafeParseReturnType<Input, Output>;

                                                                                                                                                                                          method safeParseAsync

                                                                                                                                                                                          safeParseAsync: (
                                                                                                                                                                                          data: unknown,
                                                                                                                                                                                          params?: Partial<ParseParams>
                                                                                                                                                                                          ) => Promise<SafeParseReturnType<Input, Output>>;

                                                                                                                                                                                            method superRefine

                                                                                                                                                                                            superRefine: {
                                                                                                                                                                                            <RefinedOutput extends Output>(
                                                                                                                                                                                            refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput
                                                                                                                                                                                            ): ZodEffects<this, RefinedOutput, Input>;
                                                                                                                                                                                            (refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<
                                                                                                                                                                                            this,
                                                                                                                                                                                            Output,
                                                                                                                                                                                            Input
                                                                                                                                                                                            >;
                                                                                                                                                                                            (refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<
                                                                                                                                                                                            this,
                                                                                                                                                                                            Output,
                                                                                                                                                                                            Input
                                                                                                                                                                                            >;
                                                                                                                                                                                            };

                                                                                                                                                                                              method transform

                                                                                                                                                                                              transform: <NewOut>(
                                                                                                                                                                                              transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>
                                                                                                                                                                                              ) => ZodEffects<this, NewOut>;

                                                                                                                                                                                                class ZodAny

                                                                                                                                                                                                class ZodAny extends ZodType<any, ZodAnyDef, any> {}

                                                                                                                                                                                                  property create

                                                                                                                                                                                                  static create: (params?: RawCreateParams) => ZodAny;

                                                                                                                                                                                                    class ZodArray

                                                                                                                                                                                                    class ZodArray<
                                                                                                                                                                                                    T extends ZodTypeAny,
                                                                                                                                                                                                    Cardinality extends ArrayCardinality = 'many'
                                                                                                                                                                                                    > extends ZodType<
                                                                                                                                                                                                    arrayOutputType<T, Cardinality>,
                                                                                                                                                                                                    ZodArrayDef<T>,
                                                                                                                                                                                                    Cardinality extends 'atleastone'
                                                                                                                                                                                                    ? [T['_input'], ...T['_input'][]]
                                                                                                                                                                                                    : T['_input'][]
                                                                                                                                                                                                    > {}

                                                                                                                                                                                                      property create

                                                                                                                                                                                                      static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                      schema: T_1,
                                                                                                                                                                                                      params?: RawCreateParams
                                                                                                                                                                                                      ) => ZodArray<T_1, 'many'>;

                                                                                                                                                                                                        property element

                                                                                                                                                                                                        readonly element: ZodType<any, any, any>;

                                                                                                                                                                                                          method length

                                                                                                                                                                                                          length: (len: number, message?: errorUtil.ErrMessage) => this;

                                                                                                                                                                                                            method max

                                                                                                                                                                                                            max: (maxLength: number, message?: errorUtil.ErrMessage) => this;

                                                                                                                                                                                                              method min

                                                                                                                                                                                                              min: (minLength: number, message?: errorUtil.ErrMessage) => this;

                                                                                                                                                                                                                method nonempty

                                                                                                                                                                                                                nonempty: (message?: errorUtil.ErrMessage) => ZodArray<T, 'atleastone'>;

                                                                                                                                                                                                                  class ZodBigInt

                                                                                                                                                                                                                  class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {}

                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                    static create: (
                                                                                                                                                                                                                    params?:
                                                                                                                                                                                                                    | ({
                                                                                                                                                                                                                    errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                    invalid_type_error?: string | undefined;
                                                                                                                                                                                                                    required_error?: string | undefined;
                                                                                                                                                                                                                    message?: string | undefined;
                                                                                                                                                                                                                    description?: string | undefined;
                                                                                                                                                                                                                    } & { coerce?: boolean | undefined })
                                                                                                                                                                                                                    | undefined
                                                                                                                                                                                                                    ) => ZodBigInt;

                                                                                                                                                                                                                      property max

                                                                                                                                                                                                                      max: (value: bigint, message?: errorUtil.ErrMessage | undefined) => ZodBigInt;

                                                                                                                                                                                                                        property maxValue

                                                                                                                                                                                                                        readonly maxValue: BigInt;

                                                                                                                                                                                                                          property min

                                                                                                                                                                                                                          min: (value: bigint, message?: errorUtil.ErrMessage | undefined) => ZodBigInt;

                                                                                                                                                                                                                            property minValue

                                                                                                                                                                                                                            readonly minValue: BigInt;

                                                                                                                                                                                                                              method gt

                                                                                                                                                                                                                              gt: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                method gte

                                                                                                                                                                                                                                gte: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                  method lt

                                                                                                                                                                                                                                  lt: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                    method lte

                                                                                                                                                                                                                                    lte: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                      method multipleOf

                                                                                                                                                                                                                                      multipleOf: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                        method negative

                                                                                                                                                                                                                                        negative: (message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                          method nonnegative

                                                                                                                                                                                                                                          nonnegative: (message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                            method nonpositive

                                                                                                                                                                                                                                            nonpositive: (message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                              method positive

                                                                                                                                                                                                                                              positive: (message?: errorUtil.ErrMessage) => ZodBigInt;

                                                                                                                                                                                                                                                method setLimit

                                                                                                                                                                                                                                                protected setLimit: (
                                                                                                                                                                                                                                                kind: 'min' | 'max',
                                                                                                                                                                                                                                                value: bigint,
                                                                                                                                                                                                                                                inclusive: boolean,
                                                                                                                                                                                                                                                message?: string
                                                                                                                                                                                                                                                ) => ZodBigInt;

                                                                                                                                                                                                                                                  class ZodBoolean

                                                                                                                                                                                                                                                  class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {}

                                                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                                                    static create: (
                                                                                                                                                                                                                                                    params?:
                                                                                                                                                                                                                                                    | ({
                                                                                                                                                                                                                                                    errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                                                    invalid_type_error?: string | undefined;
                                                                                                                                                                                                                                                    required_error?: string | undefined;
                                                                                                                                                                                                                                                    message?: string | undefined;
                                                                                                                                                                                                                                                    description?: string | undefined;
                                                                                                                                                                                                                                                    } & { coerce?: boolean | undefined })
                                                                                                                                                                                                                                                    | undefined
                                                                                                                                                                                                                                                    ) => ZodBoolean;

                                                                                                                                                                                                                                                      class ZodBranded

                                                                                                                                                                                                                                                      class ZodBranded<
                                                                                                                                                                                                                                                      T extends ZodTypeAny,
                                                                                                                                                                                                                                                      B extends string | number | symbol
                                                                                                                                                                                                                                                      > extends ZodType<T['_output'] & BRAND<B>, ZodBrandedDef<T>, T['_input']> {}

                                                                                                                                                                                                                                                        method unwrap

                                                                                                                                                                                                                                                        unwrap: () => T;

                                                                                                                                                                                                                                                          class ZodCatch

                                                                                                                                                                                                                                                          class ZodCatch<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                          T['_output'],
                                                                                                                                                                                                                                                          ZodCatchDef<T>,
                                                                                                                                                                                                                                                          unknown
                                                                                                                                                                                                                                                          > {}

                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                            static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                            type: T_1,
                                                                                                                                                                                                                                                            params: {
                                                                                                                                                                                                                                                            errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                                                            invalid_type_error?: string | undefined;
                                                                                                                                                                                                                                                            required_error?: string | undefined;
                                                                                                                                                                                                                                                            message?: string | undefined;
                                                                                                                                                                                                                                                            description?: string | undefined;
                                                                                                                                                                                                                                                            } & { catch: T_1['_output'] | (() => T_1['_output']) }
                                                                                                                                                                                                                                                            ) => ZodCatch<T_1>;

                                                                                                                                                                                                                                                              method removeCatch

                                                                                                                                                                                                                                                              removeCatch: () => T;

                                                                                                                                                                                                                                                                class ZodDate

                                                                                                                                                                                                                                                                class ZodDate extends ZodType<Date, ZodDateDef, Date> {}

                                                                                                                                                                                                                                                                  property create

                                                                                                                                                                                                                                                                  static create: (
                                                                                                                                                                                                                                                                  params?:
                                                                                                                                                                                                                                                                  | ({
                                                                                                                                                                                                                                                                  errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                                                                  invalid_type_error?: string | undefined;
                                                                                                                                                                                                                                                                  required_error?: string | undefined;
                                                                                                                                                                                                                                                                  message?: string | undefined;
                                                                                                                                                                                                                                                                  description?: string | undefined;
                                                                                                                                                                                                                                                                  } & { coerce?: boolean | undefined })
                                                                                                                                                                                                                                                                  | undefined
                                                                                                                                                                                                                                                                  ) => ZodDate;

                                                                                                                                                                                                                                                                    property maxDate

                                                                                                                                                                                                                                                                    readonly maxDate: Date;

                                                                                                                                                                                                                                                                      property minDate

                                                                                                                                                                                                                                                                      readonly minDate: Date;

                                                                                                                                                                                                                                                                        method max

                                                                                                                                                                                                                                                                        max: (maxDate: Date, message?: errorUtil.ErrMessage) => ZodDate;

                                                                                                                                                                                                                                                                          method min

                                                                                                                                                                                                                                                                          min: (minDate: Date, message?: errorUtil.ErrMessage) => ZodDate;

                                                                                                                                                                                                                                                                            class ZodDefault

                                                                                                                                                                                                                                                                            class ZodDefault<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                            util.noUndefined<T['_output']>,
                                                                                                                                                                                                                                                                            ZodDefaultDef<T>,
                                                                                                                                                                                                                                                                            T['_input'] | undefined
                                                                                                                                                                                                                                                                            > {}

                                                                                                                                                                                                                                                                              property create

                                                                                                                                                                                                                                                                              static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                              type: T_1,
                                                                                                                                                                                                                                                                              params: {
                                                                                                                                                                                                                                                                              errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                                                                              invalid_type_error?: string | undefined;
                                                                                                                                                                                                                                                                              required_error?: string | undefined;
                                                                                                                                                                                                                                                                              message?: string | undefined;
                                                                                                                                                                                                                                                                              description?: string | undefined;
                                                                                                                                                                                                                                                                              } & { default: T_1['_input'] | (() => util.noUndefined<T_1['_input']>) }
                                                                                                                                                                                                                                                                              ) => ZodDefault<T_1>;

                                                                                                                                                                                                                                                                                method removeDefault

                                                                                                                                                                                                                                                                                removeDefault: () => T;

                                                                                                                                                                                                                                                                                  class ZodDiscriminatedUnion

                                                                                                                                                                                                                                                                                  class ZodDiscriminatedUnion<
                                                                                                                                                                                                                                                                                  Discriminator extends string,
                                                                                                                                                                                                                                                                                  Options extends ZodDiscriminatedUnionOption<Discriminator>[]
                                                                                                                                                                                                                                                                                  > extends ZodType<
                                                                                                                                                                                                                                                                                  output<Options[number]>,
                                                                                                                                                                                                                                                                                  ZodDiscriminatedUnionDef<Discriminator, Options>,
                                                                                                                                                                                                                                                                                  input<Options[number]>
                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                    property discriminator

                                                                                                                                                                                                                                                                                    readonly discriminator: string;

                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                      readonly options: ZodDiscriminatedUnionOption<Discriminator>[];

                                                                                                                                                                                                                                                                                        property optionsMap

                                                                                                                                                                                                                                                                                        readonly optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;

                                                                                                                                                                                                                                                                                          method create

                                                                                                                                                                                                                                                                                          static create: <
                                                                                                                                                                                                                                                                                          Discriminator extends string,
                                                                                                                                                                                                                                                                                          Types extends [
                                                                                                                                                                                                                                                                                          ZodDiscriminatedUnionOption<Discriminator>,
                                                                                                                                                                                                                                                                                          ...ZodDiscriminatedUnionOption<Discriminator>[]
                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                          discriminator: Discriminator,
                                                                                                                                                                                                                                                                                          options: Types,
                                                                                                                                                                                                                                                                                          params?: RawCreateParams
                                                                                                                                                                                                                                                                                          ) => ZodDiscriminatedUnion<Discriminator, Types>;
                                                                                                                                                                                                                                                                                          • The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. However, it only allows a union of objects, all of which need to share a discriminator property. This property must have a different value for each object in the union.

                                                                                                                                                                                                                                                                                            Parameter discriminator

                                                                                                                                                                                                                                                                                            the name of the discriminator property

                                                                                                                                                                                                                                                                                            Parameter types

                                                                                                                                                                                                                                                                                            an array of object schemas

                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                          class ZodEffects

                                                                                                                                                                                                                                                                                          class ZodEffects<
                                                                                                                                                                                                                                                                                          T extends ZodTypeAny,
                                                                                                                                                                                                                                                                                          Output = output<T>,
                                                                                                                                                                                                                                                                                          Input = input<T>
                                                                                                                                                                                                                                                                                          > extends ZodType<Output, ZodEffectsDef<T>, Input> {}

                                                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                                                            static create: <I extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                            schema: I,
                                                                                                                                                                                                                                                                                            effect: Effect<I['_output']>,
                                                                                                                                                                                                                                                                                            params?: RawCreateParams
                                                                                                                                                                                                                                                                                            ) => ZodEffects<I, I['_output'], input<I>>;

                                                                                                                                                                                                                                                                                              property createWithPreprocess

                                                                                                                                                                                                                                                                                              static createWithPreprocess: <I extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                              preprocess: (arg: unknown, ctx: RefinementCtx) => unknown,
                                                                                                                                                                                                                                                                                              schema: I,
                                                                                                                                                                                                                                                                                              params?: RawCreateParams
                                                                                                                                                                                                                                                                                              ) => ZodEffects<I, I['_output'], unknown>;

                                                                                                                                                                                                                                                                                                method innerType

                                                                                                                                                                                                                                                                                                innerType: () => T;

                                                                                                                                                                                                                                                                                                  method sourceType

                                                                                                                                                                                                                                                                                                  sourceType: () => T;

                                                                                                                                                                                                                                                                                                    class ZodEnum

                                                                                                                                                                                                                                                                                                    class ZodEnum<T extends [string, ...string[]]> extends ZodType<
                                                                                                                                                                                                                                                                                                    T[number],
                                                                                                                                                                                                                                                                                                    ZodEnumDef<T>,
                                                                                                                                                                                                                                                                                                    T[number]
                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                      property create

                                                                                                                                                                                                                                                                                                      static create: {
                                                                                                                                                                                                                                                                                                      <U extends string, T extends readonly [U, ...U[]]>(
                                                                                                                                                                                                                                                                                                      values: T,
                                                                                                                                                                                                                                                                                                      params?: {
                                                                                                                                                                                                                                                                                                      errorMap?: ZodErrorMap;
                                                                                                                                                                                                                                                                                                      invalid_type_error?: string;
                                                                                                                                                                                                                                                                                                      required_error?: string;
                                                                                                                                                                                                                                                                                                      message?: string;
                                                                                                                                                                                                                                                                                                      description?: string;
                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                      ): ZodEnum<Writeable<T>>;
                                                                                                                                                                                                                                                                                                      <U extends string, T extends [U, ...U[]]>(
                                                                                                                                                                                                                                                                                                      values: T,
                                                                                                                                                                                                                                                                                                      params?: {
                                                                                                                                                                                                                                                                                                      errorMap?: ZodErrorMap;
                                                                                                                                                                                                                                                                                                      invalid_type_error?: string;
                                                                                                                                                                                                                                                                                                      required_error?: string;
                                                                                                                                                                                                                                                                                                      message?: string;
                                                                                                                                                                                                                                                                                                      description?: string;
                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                      ): ZodEnum<T>;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        property enum

                                                                                                                                                                                                                                                                                                        readonly enum: Values<T>;

                                                                                                                                                                                                                                                                                                          property Enum

                                                                                                                                                                                                                                                                                                          readonly Enum: Values<T>;

                                                                                                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                                                                                                            readonly options: [string, ...string[]];

                                                                                                                                                                                                                                                                                                              property Values

                                                                                                                                                                                                                                                                                                              readonly Values: Values<T>;

                                                                                                                                                                                                                                                                                                                method exclude

                                                                                                                                                                                                                                                                                                                exclude: <ToExclude extends readonly [T[number], ...T[number][]]>(
                                                                                                                                                                                                                                                                                                                values: ToExclude,
                                                                                                                                                                                                                                                                                                                newDef?: RawCreateParams
                                                                                                                                                                                                                                                                                                                ) => ZodEnum<
                                                                                                                                                                                                                                                                                                                typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>
                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                  method extract

                                                                                                                                                                                                                                                                                                                  extract: <ToExtract extends readonly [T[number], ...T[number][]]>(
                                                                                                                                                                                                                                                                                                                  values: ToExtract,
                                                                                                                                                                                                                                                                                                                  newDef?: RawCreateParams
                                                                                                                                                                                                                                                                                                                  ) => ZodEnum<Writeable<ToExtract>>;

                                                                                                                                                                                                                                                                                                                    class ZodError

                                                                                                                                                                                                                                                                                                                    class ZodError<T = any> extends Error {}

                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                      constructor(issues: ZodIssue[]);

                                                                                                                                                                                                                                                                                                                        property addIssue

                                                                                                                                                                                                                                                                                                                        addIssue: (sub: ZodIssue) => void;

                                                                                                                                                                                                                                                                                                                          property addIssues

                                                                                                                                                                                                                                                                                                                          addIssues: (subs?: ZodIssue[]) => void;

                                                                                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                                                                                            static create: (issues: ZodIssue[]) => ZodError<any>;

                                                                                                                                                                                                                                                                                                                              property errors

                                                                                                                                                                                                                                                                                                                              readonly errors: ZodIssue[];

                                                                                                                                                                                                                                                                                                                                property formErrors

                                                                                                                                                                                                                                                                                                                                readonly formErrors: typeToFlattenedError<T, string>;

                                                                                                                                                                                                                                                                                                                                  property isEmpty

                                                                                                                                                                                                                                                                                                                                  readonly isEmpty: boolean;

                                                                                                                                                                                                                                                                                                                                    property issues

                                                                                                                                                                                                                                                                                                                                    issues: ZodIssue[];

                                                                                                                                                                                                                                                                                                                                      property message

                                                                                                                                                                                                                                                                                                                                      readonly message: string;

                                                                                                                                                                                                                                                                                                                                        method assert

                                                                                                                                                                                                                                                                                                                                        static assert: (value: unknown) => asserts value is ZodError<any>;

                                                                                                                                                                                                                                                                                                                                          method flatten

                                                                                                                                                                                                                                                                                                                                          flatten: {
                                                                                                                                                                                                                                                                                                                                          (): typeToFlattenedError<T>;
                                                                                                                                                                                                                                                                                                                                          <U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                            method format

                                                                                                                                                                                                                                                                                                                                            format: {
                                                                                                                                                                                                                                                                                                                                            (): ZodFormattedError<T>;
                                                                                                                                                                                                                                                                                                                                            <U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              method toString

                                                                                                                                                                                                                                                                                                                                              toString: () => string;

                                                                                                                                                                                                                                                                                                                                                class ZodFunction

                                                                                                                                                                                                                                                                                                                                                class ZodFunction<
                                                                                                                                                                                                                                                                                                                                                Args extends ZodTuple<any, any>,
                                                                                                                                                                                                                                                                                                                                                Returns extends ZodTypeAny
                                                                                                                                                                                                                                                                                                                                                > extends ZodType<
                                                                                                                                                                                                                                                                                                                                                OuterTypeOfFunction<Args, Returns>,
                                                                                                                                                                                                                                                                                                                                                ZodFunctionDef<Args, Returns>,
                                                                                                                                                                                                                                                                                                                                                InnerTypeOfFunction<Args, Returns>
                                                                                                                                                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                                                                                                                                                  property validate

                                                                                                                                                                                                                                                                                                                                                  validate: <F extends InnerTypeOfFunction<Args, Returns>>(
                                                                                                                                                                                                                                                                                                                                                  func: F
                                                                                                                                                                                                                                                                                                                                                  ) => ReturnType<F> extends Returns['_output']
                                                                                                                                                                                                                                                                                                                                                  ? (...args: Args['_input']) => ReturnType<F>
                                                                                                                                                                                                                                                                                                                                                  : OuterTypeOfFunction<Args, Returns>;

                                                                                                                                                                                                                                                                                                                                                    method args

                                                                                                                                                                                                                                                                                                                                                    args: <Items extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(
                                                                                                                                                                                                                                                                                                                                                    ...items: Items
                                                                                                                                                                                                                                                                                                                                                    ) => ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;

                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                      static create: {
                                                                                                                                                                                                                                                                                                                                                      (): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
                                                                                                                                                                                                                                                                                                                                                      <T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<
                                                                                                                                                                                                                                                                                                                                                      T,
                                                                                                                                                                                                                                                                                                                                                      ZodUnknown
                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                      <T extends AnyZodTuple, U extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                      args: T,
                                                                                                                                                                                                                                                                                                                                                      returns: U
                                                                                                                                                                                                                                                                                                                                                      ): ZodFunction<T, U>;
                                                                                                                                                                                                                                                                                                                                                      <
                                                                                                                                                                                                                                                                                                                                                      T extends AnyZodTuple = ZodTuple<[], ZodUnknown>,
                                                                                                                                                                                                                                                                                                                                                      U extends ZodTypeAny = ZodUnknown
                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                      args: T,
                                                                                                                                                                                                                                                                                                                                                      returns: U,
                                                                                                                                                                                                                                                                                                                                                      params?: {
                                                                                                                                                                                                                                                                                                                                                      errorMap?: ZodErrorMap;
                                                                                                                                                                                                                                                                                                                                                      invalid_type_error?: string;
                                                                                                                                                                                                                                                                                                                                                      required_error?: string;
                                                                                                                                                                                                                                                                                                                                                      message?: string;
                                                                                                                                                                                                                                                                                                                                                      description?: string;
                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                      ): ZodFunction<T, U>;
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        method implement

                                                                                                                                                                                                                                                                                                                                                        implement: <F extends InnerTypeOfFunction<Args, Returns>>(
                                                                                                                                                                                                                                                                                                                                                        func: F
                                                                                                                                                                                                                                                                                                                                                        ) => ReturnType<F> extends Returns['_output']
                                                                                                                                                                                                                                                                                                                                                        ? (...args: Args['_input']) => ReturnType<F>
                                                                                                                                                                                                                                                                                                                                                        : OuterTypeOfFunction<Args, Returns>;

                                                                                                                                                                                                                                                                                                                                                          method parameters

                                                                                                                                                                                                                                                                                                                                                          parameters: () => Args;

                                                                                                                                                                                                                                                                                                                                                            method returns

                                                                                                                                                                                                                                                                                                                                                            returns: <NewReturnType extends ZodType<any, any, any>>(
                                                                                                                                                                                                                                                                                                                                                            returnType: NewReturnType
                                                                                                                                                                                                                                                                                                                                                            ) => ZodFunction<Args, NewReturnType>;

                                                                                                                                                                                                                                                                                                                                                              method returnType

                                                                                                                                                                                                                                                                                                                                                              returnType: () => Returns;

                                                                                                                                                                                                                                                                                                                                                                method strictImplement

                                                                                                                                                                                                                                                                                                                                                                strictImplement: (
                                                                                                                                                                                                                                                                                                                                                                func: InnerTypeOfFunction<Args, Returns>
                                                                                                                                                                                                                                                                                                                                                                ) => InnerTypeOfFunction<Args, Returns>;

                                                                                                                                                                                                                                                                                                                                                                  class ZodIntersection

                                                                                                                                                                                                                                                                                                                                                                  class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                  T['_output'] & U['_output'],
                                                                                                                                                                                                                                                                                                                                                                  ZodIntersectionDef<T, U>,
                                                                                                                                                                                                                                                                                                                                                                  T['_input'] & U['_input']
                                                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                                                                                                                                                                    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                    left: T_1,
                                                                                                                                                                                                                                                                                                                                                                    right: U_1,
                                                                                                                                                                                                                                                                                                                                                                    params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                    ) => ZodIntersection<T_1, U_1>;

                                                                                                                                                                                                                                                                                                                                                                      class ZodLazy

                                                                                                                                                                                                                                                                                                                                                                      class ZodLazy<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                      output<T>,
                                                                                                                                                                                                                                                                                                                                                                      ZodLazyDef<T>,
                                                                                                                                                                                                                                                                                                                                                                      input<T>
                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                        property create

                                                                                                                                                                                                                                                                                                                                                                        static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                        getter: () => T_1,
                                                                                                                                                                                                                                                                                                                                                                        params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                        ) => ZodLazy<T_1>;

                                                                                                                                                                                                                                                                                                                                                                          property schema

                                                                                                                                                                                                                                                                                                                                                                          readonly schema: ZodType<any, any, any>;

                                                                                                                                                                                                                                                                                                                                                                            class ZodLiteral

                                                                                                                                                                                                                                                                                                                                                                            class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {}

                                                                                                                                                                                                                                                                                                                                                                              property create

                                                                                                                                                                                                                                                                                                                                                                              static create: <T_1 extends Primitive>(
                                                                                                                                                                                                                                                                                                                                                                              value: T_1,
                                                                                                                                                                                                                                                                                                                                                                              params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                              ) => ZodLiteral<T_1>;

                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                readonly value: {};

                                                                                                                                                                                                                                                                                                                                                                                  class ZodMap

                                                                                                                                                                                                                                                                                                                                                                                  class ZodMap<
                                                                                                                                                                                                                                                                                                                                                                                  Key extends ZodTypeAny = ZodTypeAny,
                                                                                                                                                                                                                                                                                                                                                                                  Value extends ZodTypeAny = ZodTypeAny
                                                                                                                                                                                                                                                                                                                                                                                  > extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                  Map<Key['_output'], Value['_output']>,
                                                                                                                                                                                                                                                                                                                                                                                  ZodMapDef<Key, Value>,
                                                                                                                                                                                                                                                                                                                                                                                  Map<Key['_input'], Value['_input']>
                                                                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                                                                                                                                                                                    static create: <
                                                                                                                                                                                                                                                                                                                                                                                    Key_1 extends ZodTypeAny = ZodTypeAny,
                                                                                                                                                                                                                                                                                                                                                                                    Value_1 extends ZodTypeAny = ZodTypeAny
                                                                                                                                                                                                                                                                                                                                                                                    >(
                                                                                                                                                                                                                                                                                                                                                                                    keyType: Key_1,
                                                                                                                                                                                                                                                                                                                                                                                    valueType: Value_1,
                                                                                                                                                                                                                                                                                                                                                                                    params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                    ) => ZodMap<Key_1, Value_1>;

                                                                                                                                                                                                                                                                                                                                                                                      property keySchema

                                                                                                                                                                                                                                                                                                                                                                                      readonly keySchema: ZodType<any, any, any>;

                                                                                                                                                                                                                                                                                                                                                                                        property valueSchema

                                                                                                                                                                                                                                                                                                                                                                                        readonly valueSchema: ZodType<any, any, any>;

                                                                                                                                                                                                                                                                                                                                                                                          class ZodNaN

                                                                                                                                                                                                                                                                                                                                                                                          class ZodNaN extends ZodType<number, ZodNaNDef, number> {}

                                                                                                                                                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                                                                                                                                                            static create: (params?: RawCreateParams) => ZodNaN;

                                                                                                                                                                                                                                                                                                                                                                                              class ZodNativeEnum

                                                                                                                                                                                                                                                                                                                                                                                              class ZodNativeEnum<T extends EnumLike> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                              T[keyof T],
                                                                                                                                                                                                                                                                                                                                                                                              ZodNativeEnumDef<T>,
                                                                                                                                                                                                                                                                                                                                                                                              T[keyof T]
                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                                                                                                static create: <T_1 extends EnumLike>(
                                                                                                                                                                                                                                                                                                                                                                                                values: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodNativeEnum<T_1>;

                                                                                                                                                                                                                                                                                                                                                                                                  property enum

                                                                                                                                                                                                                                                                                                                                                                                                  readonly enum: EnumLike;

                                                                                                                                                                                                                                                                                                                                                                                                    class ZodNever

                                                                                                                                                                                                                                                                                                                                                                                                    class ZodNever extends ZodType<never, ZodNeverDef, never> {}

                                                                                                                                                                                                                                                                                                                                                                                                      property create

                                                                                                                                                                                                                                                                                                                                                                                                      static create: (params?: RawCreateParams) => ZodNever;

                                                                                                                                                                                                                                                                                                                                                                                                        class ZodNull

                                                                                                                                                                                                                                                                                                                                                                                                        class ZodNull extends ZodType<null, ZodNullDef, null> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property create

                                                                                                                                                                                                                                                                                                                                                                                                          static create: (params?: RawCreateParams) => ZodNull;

                                                                                                                                                                                                                                                                                                                                                                                                            class ZodNullable

                                                                                                                                                                                                                                                                                                                                                                                                            class ZodNullable<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                            T['_output'] | null,
                                                                                                                                                                                                                                                                                                                                                                                                            ZodNullableDef<T>,
                                                                                                                                                                                                                                                                                                                                                                                                            T['_input'] | null
                                                                                                                                                                                                                                                                                                                                                                                                            > {}

                                                                                                                                                                                                                                                                                                                                                                                                              property create

                                                                                                                                                                                                                                                                                                                                                                                                              static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                              type: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                              params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                              ) => ZodNullable<T_1>;

                                                                                                                                                                                                                                                                                                                                                                                                                method unwrap

                                                                                                                                                                                                                                                                                                                                                                                                                unwrap: () => T;

                                                                                                                                                                                                                                                                                                                                                                                                                  class ZodNumber

                                                                                                                                                                                                                                                                                                                                                                                                                  class ZodNumber extends ZodType<number, ZodNumberDef, number> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                                                                                                                                                                                                                    static create: (
                                                                                                                                                                                                                                                                                                                                                                                                                    params?:
                                                                                                                                                                                                                                                                                                                                                                                                                    | ({
                                                                                                                                                                                                                                                                                                                                                                                                                    errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    invalid_type_error?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    required_error?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    message?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    description?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    } & { coerce?: boolean | undefined })
                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                      property isFinite

                                                                                                                                                                                                                                                                                                                                                                                                                      readonly isFinite: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        property isInt

                                                                                                                                                                                                                                                                                                                                                                                                                        readonly isInt: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                          property max

                                                                                                                                                                                                                                                                                                                                                                                                                          max: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                            property maxValue

                                                                                                                                                                                                                                                                                                                                                                                                                            readonly maxValue: number;

                                                                                                                                                                                                                                                                                                                                                                                                                              property min

                                                                                                                                                                                                                                                                                                                                                                                                                              min: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                property minValue

                                                                                                                                                                                                                                                                                                                                                                                                                                readonly minValue: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property step

                                                                                                                                                                                                                                                                                                                                                                                                                                  step: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method finite

                                                                                                                                                                                                                                                                                                                                                                                                                                    finite: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method gt

                                                                                                                                                                                                                                                                                                                                                                                                                                      gt: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method gte

                                                                                                                                                                                                                                                                                                                                                                                                                                        gte: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method int

                                                                                                                                                                                                                                                                                                                                                                                                                                          int: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method lt

                                                                                                                                                                                                                                                                                                                                                                                                                                            lt: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method lte

                                                                                                                                                                                                                                                                                                                                                                                                                                              lte: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method multipleOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                multipleOf: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method negative

                                                                                                                                                                                                                                                                                                                                                                                                                                                  negative: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method nonnegative

                                                                                                                                                                                                                                                                                                                                                                                                                                                    nonnegative: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method nonpositive

                                                                                                                                                                                                                                                                                                                                                                                                                                                      nonpositive: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method positive

                                                                                                                                                                                                                                                                                                                                                                                                                                                        positive: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method safe

                                                                                                                                                                                                                                                                                                                                                                                                                                                          safe: (message?: errorUtil.ErrMessage) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected setLimit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: 'min' | 'max',
                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            inclusive: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            message?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => ZodNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                              T extends ZodRawShape,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Catchall extends ZodTypeAny = ZodTypeAny,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output = objectOutputType<T, Catchall, UnknownKeys>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Input = objectInputType<T, Catchall, UnknownKeys>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property augment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                augment: <Augmentation extends ZodRawShape>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                augmentation: Augmentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectUtil.extendShape<T, Augmentation>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectOutputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectUtil.extendShape<T, Augmentation>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectInputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectUtil.extendShape<T, Augmentation>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use .extend instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                static create: <T_1 extends ZodRawShape>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                shape: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'strip',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ZodTypeAny,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof objectUtil.addQuestionMarks<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                baseObjectOutputType<T_1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property lazycreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static lazycreate: <T_1 extends ZodRawShape>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shape: () => T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'strip',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ZodTypeAny,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [k in keyof objectUtil.addQuestionMarks<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseObjectOutputType<T_1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nonstrict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nonstrict: () => ZodObject<T, 'passthrough', Catchall>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      In most cases, this is no longer needed - unknown properties are now silently stripped. If you want to pass through unknown properties, use .passthrough() instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property shape

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly shape: ZodRawShape;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property strictCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static strictCreate: <T_1 extends ZodRawShape>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shape: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'strict',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ZodTypeAny,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof objectUtil.addQuestionMarks<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      baseObjectOutputType<T_1>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method catchall

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        catchall: <Index extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ZodObject<T, UnknownKeys, Index>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method deepPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deepPartial: () => partialUtil.DeepPartial<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method extend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extend: <Augmentation extends ZodRawShape>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          augmentation: Augmentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method keyof

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyof: () => ZodEnum<enumUtil.UnionToTupleString<keyof T>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              merge: <Incoming extends AnyZodObject, Augmentation extends Incoming['shape']>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              merging: Incoming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              objectUtil.extendShape<T, Augmentation>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Incoming['_def']['unknownKeys'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Incoming['_def']['catchall']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Prior to zod@1.0.12 there was a bug in the inferred type of merged objects. Please upgrade if you are experiencing issues.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              omit: <Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mask: Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method partial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                partial: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (): ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { [k in keyof T]: ZodOptional<T[k]> },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectOutputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { [k in keyof T]: ZodOptional<T[k]> },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectInputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { [k in keyof T]: ZodOptional<T[k]> },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mask: Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in objectUtil.noNeverKeys<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }>]: k extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? ZodOptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }[k]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectOutputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in objectUtil.noNeverKeys<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? ZodOptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }>]: k extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? ZodOptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }[k]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                objectInputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in objectUtil.noNeverKeys<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? ZodOptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }>]: k extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? ZodOptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }[k]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method passthrough

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  passthrough: () => ZodObject<T, 'passthrough', Catchall>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pick: <Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mask: Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method required

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      required: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (): ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { [k in keyof T]: deoptional<T[k]> },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UnknownKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      objectOutputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { [k in keyof T]: deoptional<T[k]> },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      objectInputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { [k in keyof T]: deoptional<T[k]> },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mask: Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in objectUtil.noNeverKeys<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }>]: k extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? deoptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }[k]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UnknownKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      objectOutputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in objectUtil.noNeverKeys<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? deoptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }>]: k extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? deoptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }[k]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      objectInputType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in objectUtil.noNeverKeys<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? deoptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }>]: k extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [k in keyof T]: k extends keyof Mask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? deoptional<T[k]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T[k];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }[k]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UnknownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setKey: <Key extends string, Schema extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: Key,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        schema: Schema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ZodObject<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        T & { [k in Key]: Schema },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UnknownKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Catchall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        objectOutputType<T & { [k in Key]: Schema }, Catchall, UnknownKeys>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        objectInputType<T & { [k in Key]: Schema }, Catchall, UnknownKeys>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method strict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          strict: (message?: errorUtil.ErrMessage) => ZodObject<T, 'strict', Catchall>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            strip: () => ZodObject<T, 'strip', Catchall>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodOptional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodOptional<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              T['_output'] | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ZodOptionalDef<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              T['_input'] | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodOptional<T_1>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method unwrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unwrap: () => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ZodPipeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B['_output'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ZodPipelineDef<A, B>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A['_input']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static create: <A extends ZodTypeAny, B extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      a: A,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      b: B
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ZodPipeline<A, B>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ZodPromise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ZodPromise<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Promise<T['_output']>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ZodPromiseDef<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Promise<T['_input']>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          schema: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ZodPromise<T_1>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method unwrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unwrap: () => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodReadonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodReadonly<T extends ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MakeReadonly<T['_output']>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ZodReadonlyDef<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MakeReadonly<T['_input']>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static create: <T_1 extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: T_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodReadonly<T_1>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method unwrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unwrap: () => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ZodRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ZodRecord<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key extends KeySchema = ZodString,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value extends ZodTypeAny = ZodTypeAny
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RecordType<Key['_output'], Value['_output']>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ZodRecordDef<Key, Value>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RecordType<Key['_input'], Value['_input']>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly element: ZodType<any, any, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keySchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly keySchema: ZodType<string | number | symbol, any, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property valueSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly valueSchema: ZodType<any, any, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <Value extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            valueType: Value,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): ZodRecord<ZodString, Value>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <Keys extends KeySchema, Value extends ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keySchema: Keys,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            valueType: Value,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            params?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errorMap?: ZodErrorMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            invalid_type_error?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            required_error?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): ZodRecord<Keys, Value>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract class ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Def extends ZodTypeDef = ZodTypeDef,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Input = Output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(def: ZodTypeDef);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property spa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    spa: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    params?: Partial<ParseParams> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<SafeParseReturnType<Input, Output>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Alias of safeParseAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method and

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    and: <T extends ZodTypeAny>(incoming: T) => ZodIntersection<this, T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      array: () => ZodArray<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method brand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        brand: <B extends string | number | symbol>(brand?: B) => ZodBranded<this, B>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method catch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          catch: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (def: Output): ZodCatch<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          def: (ctx: { error: ZodError<any>; input: Input }) => Output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): ZodCatch<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method default

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            default: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (def: util.noUndefined<Input>): ZodDefault<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (def: () => util.noUndefined<Input>): ZodDefault<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method describe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              describe: (description: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isNullable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isNullable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isOptional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isOptional: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method nullable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nullable: () => ZodNullable<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method nullish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nullish: () => ZodOptional<ZodNullable<this>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional: () => ZodOptional<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          or: <T extends ZodTypeAny>(option: T) => ZodUnion<[this, T]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parse: (data: unknown, params?: Partial<ParseParams>) => Output;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method parseAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseAsync: (data: unknown, params?: Partial<ParseParams>) => Promise<Output>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method pipe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pipe: <T extends ZodTypeAny>(target: T) => ZodPipeline<this, T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  promise: () => ZodPromise<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method readonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly: () => ZodReadonly<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method refine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      refine: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <RefinedOutput extends Output>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      check: (arg: Output) => arg is RefinedOutput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      message?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Partial<util.Omit<ZodCustomIssue, 'code'>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((arg: Output) => CustomErrorParams)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): ZodEffects<this, RefinedOutput, Input>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      check: (arg: Output) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      message?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Partial<util.Omit<ZodCustomIssue, 'code'>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((arg: Output) => Partial<util.Omit<ZodCustomIssue, 'code'>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): ZodEffects<this, Output, Input>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method refinement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        refinement: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <RefinedOutput extends Output>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        check: (arg: Output) => arg is RefinedOutput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        refinementData:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | IssueData
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((arg: Output, ctx: RefinementCtx) => IssueData)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): ZodEffects<this, RefinedOutput, Input>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        check: (arg: Output) => boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        refinementData:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | IssueData
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((arg: Output, ctx: RefinementCtx) => IssueData)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): ZodEffects<this, Output, Input>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method safeParse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          safeParse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params?: Partial<ParseParams>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => SafeParseReturnType<Input, Output>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method safeParseAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            safeParseAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            params?: Partial<ParseParams>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<SafeParseReturnType<Input, Output>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method superRefine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              superRefine: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <RefinedOutput extends Output>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): ZodEffects<this, RefinedOutput, Input>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transform: <NewOut>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodEffects<this, NewOut>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ZodSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Set<Value['_output']>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ZodSetDef<Value>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Set<Value['_input']>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static create: <Value_1 extends ZodTypeAny = ZodTypeAny>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    valueType: Value_1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    params?: RawCreateParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ZodSet<Value_1>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: (maxSize: number, message?: errorUtil.ErrMessage) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: (minSize: number, message?: errorUtil.ErrMessage) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method nonempty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nonempty: (message?: errorUtil.ErrMessage) => ZodSet<Value>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size: (size: number, message?: errorUtil.ErrMessage) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ZodString extends ZodType<string, ZodStringDef, string> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                errorMap?: ZodErrorMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                invalid_type_error?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                required_error?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                message?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                description?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } & { coerce?: true | undefined })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isBase64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly isBase64: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isCUID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly isCUID: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isCUID2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly isCUID2: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly isDate: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isDatetime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly isDatetime: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly isDuration: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isEmail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly isEmail: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isEmoji

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly isEmoji: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly isIP: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isNANOID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly isNANOID: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly isTime: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isULID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly isULID: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly isURL: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isUUID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly isUUID: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property maxLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly maxLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property minLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly minLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method base64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  base64: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method cuid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cuid: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method cuid2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cuid2: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        date: (message?: string) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method datetime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          datetime: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          message?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          precision?: number | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          local?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            duration: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              email: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method emoji

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                emoji: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method endsWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endsWith: (value: string, message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: { message?: string; position?: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ip: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: string | { version?: 'v4' | 'v6'; message?: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length: (len: number, message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: (maxLength: number, message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            min: (minLength: number, message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method nanoid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nanoid: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method nonempty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nonempty: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method regex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                regex: (regex: RegExp, message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method startsWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startsWith: (value: string, message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    time: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | { message?: string | undefined; precision?: number | null }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toLowerCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toLowerCase: () => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toUpperCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toUpperCase: () => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method trim

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          trim: () => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method ulid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ulid: (message?: errorUtil.ErrMessage) => ZodString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method