Class ZodFunction<Args, Returns>

constructor

• new ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny>(
      def: ZodFunctionDef,
  ): ZodFunction<Args, Returns>

  Type Parameters

  • Args extends ZodTuple<any, any>
  • Returns extends ZodTypeAny

  Parameters

  • def: ZodFunctionDef

  Returns ZodFunction<Args, Returns>

Readonly_def

Readonly_input

Readonly_output

Readonly_type

~standard

spa

validate

description

• get description(): string | undefined

  Returns string | undefined

_getOrReturnCtx

• _getOrReturnCtx(input: ParseInput, ctx?: ParseContext): ParseContext

  Parameters

  • input: ParseInput
  • Optionalctx: ParseContext

  Returns ParseContext

_getType

• _getType(input: ParseInput): string

  Parameters

  • input: ParseInput

  Returns string

_parse

• _parse(input: ParseInput): ParseReturnType<any>

  Parameters

  • input: ParseInput

  Returns ParseReturnType<any>

_parseAsync

• _parseAsync(
      input: ParseInput,
  ): AsyncParseReturnType<OuterTypeOfFunction<Args, Returns>>

  Parameters

  • input: ParseInput

  Returns AsyncParseReturnType<OuterTypeOfFunction<Args, Returns>>

_parseSync

• _parseSync(
      input: ParseInput,
  ): SyncParseReturnType<OuterTypeOfFunction<Args, Returns>>

  Parameters

  • input: ParseInput

  Returns SyncParseReturnType<OuterTypeOfFunction<Args, Returns>>

_processInputParams

• _processInputParams(
      input: ParseInput,
  ): { ctx: ParseContext; status: ParseStatus }

  Parameters

  • input: ParseInput

  Returns { ctx: ParseContext; status: ParseStatus }

_refinement

• _refinement(
      refinement: (arg: OuterTypeOfFunction, ctx: RefinementCtx) => any,
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

  Parameters

  • refinement: (arg: OuterTypeOfFunction, ctx: RefinementCtx) => any

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

~validate

• "~validate"(
      data: unknown,
  ):
      | Result<OuterTypeOfFunction<Args, Returns>>
      | Promise<Result<OuterTypeOfFunction<Args, Returns>>>

  Parameters

  • data: unknown

  Returns
      | Result<OuterTypeOfFunction<Args, Returns>>
      | Promise<Result<OuterTypeOfFunction<Args, Returns>>>

and

• and<T extends ZodTypeAny>(
      incoming: T,
  ): ZodIntersection<ZodFunction<Args, Returns>, T>

  Type Parameters

  • T extends ZodTypeAny

  Parameters

  • incoming: T

  Returns ZodIntersection<ZodFunction<Args, Returns>, T>

args

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

  Type Parameters

  • Items extends [] | [ZodTypeAny, ...ZodTypeAny[]]

  Parameters

  • ...items: Items

  Returns ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>

array

• array(): ZodArray<ZodFunction<Args, Returns>>

  Returns ZodArray<ZodFunction<Args, Returns>>

brand

• brand<B extends string | number | symbol>(
      brand?: B,
  ): ZodBranded<ZodFunction<Args, Returns>, B>

  Type Parameters

  • B extends string | number | symbol

  Parameters

  • Optionalbrand: B

  Returns ZodBranded<ZodFunction<Args, Returns>, B>

catch

• catch(def: OuterTypeOfFunction): ZodCatch<ZodFunction<Args, Returns>>

  Parameters

  • def: OuterTypeOfFunction

  Returns ZodCatch<ZodFunction<Args, Returns>>

• catch(
      def: (
          ctx: { error: ZodError; input: InnerTypeOfFunction },
      ) => OuterTypeOfFunction,
  ): ZodCatch<ZodFunction<Args, Returns>>

  Parameters

  • def: (ctx: { error: ZodError; input: InnerTypeOfFunction }) => OuterTypeOfFunction

  Returns ZodCatch<ZodFunction<Args, Returns>>

default

• default(
      def: noUndefined<InnerTypeOfFunction<Args, Returns>>,
  ): ZodDefault<ZodFunction<Args, Returns>>

  Parameters

  • def: noUndefined<InnerTypeOfFunction<Args, Returns>>

  Returns ZodDefault<ZodFunction<Args, Returns>>

• default(
      def: () => noUndefined<InnerTypeOfFunction<Args, Returns>>,
  ): ZodDefault<ZodFunction<Args, Returns>>

  Parameters

  • def: () => noUndefined<InnerTypeOfFunction<Args, Returns>>

  Returns ZodDefault<ZodFunction<Args, Returns>>

describe

• describe(description: string): this

  Parameters

  • description: string

  Returns this

implement

• implement<F extends (...args: any[any]) => Returns["_input"]>(
      func: F,
  ): ReturnType<F> extends Returns["_output"]
      ? (...args: Args["_input"]) => ReturnType
      : OuterTypeOfFunction<Args, Returns>

  Type Parameters

  • F extends (...args: any[any]) => Returns["_input"]

  Parameters

  • func: F

  Returns ReturnType<F> extends Returns["_output"]
      ? (...args: Args["_input"]) => ReturnType
      : OuterTypeOfFunction<Args, Returns>

isNullable

• isNullable(): boolean

  Returns boolean

isOptional

• isOptional(): boolean

  Returns boolean

nullable

• nullable(): ZodNullable<ZodFunction<Args, Returns>>

  Returns ZodNullable<ZodFunction<Args, Returns>>

nullish

• nullish(): ZodOptional<ZodNullable<ZodFunction<Args, Returns>>>

  Returns ZodOptional<ZodNullable<ZodFunction<Args, Returns>>>

optional

• optional(): ZodOptional<ZodFunction<Args, Returns>>

  Returns ZodOptional<ZodFunction<Args, Returns>>

or

• or<T extends ZodTypeAny>(option: T): ZodUnion<[ZodFunction<Args, Returns>, T]>

  Type Parameters

  • T extends ZodTypeAny

  Parameters

  • option: T

  Returns ZodUnion<[ZodFunction<Args, Returns>, T]>

parameters

• parameters(): Args

  Returns Args

parse

• parse(data: unknown, params?: InexactPartial<ParseParams>): OuterTypeOfFunction

  Parameters

  • data: unknown
  • Optionalparams: InexactPartial<ParseParams>

  Returns OuterTypeOfFunction

parseAsync

• parseAsync(
      data: unknown,
      params?: InexactPartial<ParseParams>,
  ): Promise<OuterTypeOfFunction<Args, Returns>>

  Parameters

  • data: unknown
  • Optionalparams: InexactPartial<ParseParams>

  Returns Promise<OuterTypeOfFunction<Args, Returns>>

pipe

• pipe<T extends ZodTypeAny>(
      target: T,
  ): ZodPipeline<ZodFunction<Args, Returns>, T>

  Type Parameters

  • T extends ZodTypeAny

  Parameters

  • target: T

  Returns ZodPipeline<ZodFunction<Args, Returns>, T>

promise

• promise(): ZodPromise<ZodFunction<Args, Returns>>

  Returns ZodPromise<ZodFunction<Args, Returns>>

readonly

• readonly(): ZodReadonly<ZodFunction<Args, Returns>>

  Returns ZodReadonly<ZodFunction<Args, Returns>>

refine

• refine<RefinedOutput extends (...args: any[any]) => Returns["_output"]>(
      check: (arg: OuterTypeOfFunction) => arg is RefinedOutput,
      message?:
          | string
          | Partial<Omit<ZodCustomIssue, "code">>
          | ((arg: OuterTypeOfFunction) => CustomErrorParams),
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      RefinedOutput,
      InnerTypeOfFunction<Args, Returns>,
  >

  Type Parameters

  • RefinedOutput extends (...args: any[any]) => Returns["_output"]

  Parameters

  • check: (arg: OuterTypeOfFunction) => arg is RefinedOutput
  • Optionalmessage:
        | string
        | Partial<Omit<ZodCustomIssue, "code">>
        | ((arg: OuterTypeOfFunction) => CustomErrorParams)

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      RefinedOutput,
      InnerTypeOfFunction<Args, Returns>,
  >

• refine(
      check: (arg: OuterTypeOfFunction) => unknown,
      message?:
          | string
          | Partial<Omit<ZodCustomIssue, "code">>
          | ((arg: OuterTypeOfFunction) => CustomErrorParams),
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

  Parameters

  • check: (arg: OuterTypeOfFunction) => unknown
  • Optionalmessage:
        | string
        | Partial<Omit<ZodCustomIssue, "code">>
        | ((arg: OuterTypeOfFunction) => CustomErrorParams)

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

refinement

• refinement<RefinedOutput extends (...args: any[any]) => Returns["_output"]>(
      check: (arg: OuterTypeOfFunction) => arg is RefinedOutput,
      refinementData:
          | IssueData
          | ((arg: OuterTypeOfFunction, ctx: RefinementCtx) => IssueData),
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      RefinedOutput,
      InnerTypeOfFunction<Args, Returns>,
  >

  Type Parameters

  • RefinedOutput extends (...args: any[any]) => Returns["_output"]

  Parameters

  • check: (arg: OuterTypeOfFunction) => arg is RefinedOutput
  • refinementData: IssueData | ((arg: OuterTypeOfFunction, ctx: RefinementCtx) => IssueData)

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      RefinedOutput,
      InnerTypeOfFunction<Args, Returns>,
  >

• refinement(
      check: (arg: OuterTypeOfFunction) => boolean,
      refinementData:
          | IssueData
          | ((arg: OuterTypeOfFunction, ctx: RefinementCtx) => IssueData),
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

  Parameters

  • check: (arg: OuterTypeOfFunction) => boolean
  • refinementData: IssueData | ((arg: OuterTypeOfFunction, ctx: RefinementCtx) => IssueData)

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

returns

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

  Type Parameters

  • NewReturnType extends ZodType<any, any, any>

  Parameters

  • returnType: NewReturnType

  Returns ZodFunction<Args, NewReturnType>

returnType

• returnType(): Returns

  Returns Returns

safeParse

• safeParse(
      data: unknown,
      params?: InexactPartial<ParseParams>,
  ): SafeParseReturnType<
      InnerTypeOfFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
  >

  Parameters

  • data: unknown
  • Optionalparams: InexactPartial<ParseParams>

  Returns SafeParseReturnType<
      InnerTypeOfFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
  >

safeParseAsync

• safeParseAsync(
      data: unknown,
      params?: InexactPartial<ParseParams>,
  ): Promise<
      SafeParseReturnType<
          InnerTypeOfFunction<Args, Returns>,
          OuterTypeOfFunction<Args, Returns>,
      >,
  >

  Parameters

  • data: unknown
  • Optionalparams: InexactPartial<ParseParams>

  Returns Promise<
      SafeParseReturnType<
          InnerTypeOfFunction<Args, Returns>,
          OuterTypeOfFunction<Args, Returns>,
      >,
  >

strictImplement

• strictImplement(
      func: InnerTypeOfFunction<Args, Returns>,
  ): InnerTypeOfFunction<Args, Returns>

  Parameters

  • func: InnerTypeOfFunction<Args, Returns>

  Returns InnerTypeOfFunction<Args, Returns>

superRefine

• superRefine<RefinedOutput extends (...args: any[any]) => Returns["_output"]>(
      refinement: (
          arg: OuterTypeOfFunction,
          ctx: RefinementCtx,
      ) => arg is RefinedOutput,
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      RefinedOutput,
      InnerTypeOfFunction<Args, Returns>,
  >

  Type Parameters

  • RefinedOutput extends (...args: any[any]) => Returns["_output"]

  Parameters

  • refinement: (arg: OuterTypeOfFunction, ctx: RefinementCtx) => arg is RefinedOutput

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      RefinedOutput,
      InnerTypeOfFunction<Args, Returns>,
  >

• superRefine(
      refinement: (arg: OuterTypeOfFunction, ctx: RefinementCtx) => void,
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

  Parameters

  • refinement: (arg: OuterTypeOfFunction, ctx: RefinementCtx) => void

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

• superRefine(
      refinement: (
          arg: OuterTypeOfFunction,
          ctx: RefinementCtx,
      ) => Promise<void>,
  ): ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

  Parameters

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

  Returns ZodEffects<
      ZodFunction<Args, Returns>,
      OuterTypeOfFunction<Args, Returns>,
      InnerTypeOfFunction<Args, Returns>,
  >

transform

• transform<NewOut>(
      transform: (
          arg: OuterTypeOfFunction,
          ctx: RefinementCtx,
      ) => NewOut | Promise<NewOut>,
  ): ZodEffects<ZodFunction<Args, Returns>, NewOut>

  Type Parameters

  • NewOut

  Parameters

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

  Returns ZodEffects<ZodFunction<Args, Returns>, NewOut>

Staticcreate

• create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>

  Returns ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>

• create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(
      args: T,
  ): ZodFunction<T, ZodUnknown>

  Type Parameters

  • T extends AnyZodTuple = ZodTuple<[], ZodUnknown>

  Parameters

  • args: T

  Returns ZodFunction<T, ZodUnknown>

• create<T extends AnyZodTuple, U extends ZodTypeAny>(
      args: T,
      returns: U,
  ): ZodFunction<T, U>

  Type Parameters

  • T extends AnyZodTuple
  • U extends ZodTypeAny

  Parameters

  • args: T
  • returns: U

  Returns ZodFunction<T, U>

• create<
      T extends AnyZodTuple = ZodTuple<[], ZodUnknown>,
      U extends ZodTypeAny = ZodUnknown,
  >(
      args: T,
      returns: U,
      params?: RawCreateParams,
  ): ZodFunction<T, U>

  Type Parameters

  • T extends AnyZodTuple = ZodTuple<[], ZodUnknown>
  • U extends ZodTypeAny = ZodUnknown

  Parameters

  • args: T
  • returns: U
  • Optionalparams: RawCreateParams

  Returns ZodFunction<T, U>