title: Core.z

A2A Node SDK - v0.1.0 / Modules / Core / z

Namespace: z

Core.z

Re-export Zod for schema validation

Remarks

Exported explicitly to avoid conflicts

Table of contents

References

Namespaces

Enumerations

Classes

Interfaces

Type Aliases

Variables

Functions

References

Schema

Renames and re-exports ZodType


ZodSchema

Renames and re-exports ZodType


ZodTransformer

Renames and re-exports ZodEffects


infer

Renames and re-exports TypeOf


transformer

Renames and re-exports effect

Type Aliases

AnyZodObject

Ƭ AnyZodObject: ZodObject<any, any, any>


AnyZodTuple

Ƭ AnyZodTuple: ZodTuple<[ZodTypeAny, …ZodTypeAny[]] | [], ZodTypeAny | null>


ArrayCardinality

Ƭ ArrayCardinality: "many" | "atleastone"


ArrayKeys

Ƭ ArrayKeys: keyof any[]


AssertArray

Ƭ AssertArray<T>: T extends any[] ? T : never

Type parameters

Name
T

AsyncParseReturnType

Ƭ AsyncParseReturnType<T>: Promise<SyncParseReturnType<T>>

Type parameters

Name
T

BRAND

Ƭ BRAND<T>: Object

Type parameters

NameType
Textends string | number | symbol

Type declaration

NameType
[BRAND]{ [k in T]: true }

CatchallInput

Ƭ CatchallInput<T>: ZodType extends T ? unknown : { [k: string]: T["_input"]; }

Type parameters

NameType
Textends ZodType

CatchallOutput

Ƭ CatchallOutput<T>: ZodType extends T ? unknown : { [k: string]: T["_output"]; }

Type parameters

NameType
Textends ZodType

CustomErrorParams

Ƭ CustomErrorParams: Partial<Omit<ZodCustomIssue, "code">>


DIRTY

Ƭ DIRTY<T>: Object

Type parameters

Name
T

Type declaration

NameType
status"dirty"
valueT

DenormalizedError

Ƭ DenormalizedError: Object

Index signature

▪ [k: string]: DenormalizedError | string[]


Effect

Ƭ Effect<T>: RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>

Type parameters

Name
T

EnumLike

Ƭ EnumLike: Object

Index signature

▪ [k: string]: string | number


EnumValues

Ƭ EnumValues<T>: readonly [T, …T[]]

Type parameters

NameType
Textends string = string

ErrorMapCtx

Ƭ ErrorMapCtx: Object

Type declaration

NameType
dataany
defaultErrorstring

FilterEnum

Ƭ FilterEnum<Values, ToExclude>: Values extends [] ? [] : Values extends [infer Head, …(infer Rest)] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, …FilterEnum<Rest, ToExclude>] : never

Type parameters

Name
Values
ToExclude

INVALID

Ƭ INVALID: Object

Type declaration

NameType
status"aborted"

Indices

Ƭ Indices<T>: Exclude<keyof T, ArrayKeys>

Type parameters

Name
T

InnerTypeOfFunction

Ƭ InnerTypeOfFunction<Args, Returns>: Args["_output"] extends any[] ? (…args: Args["_output"]) => Returns["_input"] : never

Type parameters

NameType
Argsextends ZodTuple<any, any>
Returnsextends ZodTypeAny

InputTypeOfTuple

Ƭ InputTypeOfTuple<T>: AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k][“_input”] : never }>

Type parameters

NameType
Textends ZodTupleItems | []

InputTypeOfTupleWithRest

Ƭ InputTypeOfTupleWithRest<T, Rest>: Rest extends ZodTypeAny ? […InputTypeOfTuple<T>, …Rest[“_input”][]] : InputTypeOfTuple<T>

Type parameters

NameType
Textends ZodTupleItems | []
Restextends ZodTypeAny | null = null

IpVersion

Ƭ IpVersion: "v4" | "v6"


IssueData

Ƭ IssueData: stripPath<ZodIssueOptionalMessage> & { fatal?: boolean ; path?: (string | number)[] }


KeySchema

Ƭ KeySchema: ZodType<string | number | symbol, any, any>


OK

Ƭ OK<T>: Object

Type parameters

Name
T

Type declaration

NameType
status"valid"
valueT

ObjectPair

Ƭ ObjectPair: Object

Type declaration

NameType
keySyncParseReturnType<any>
valueSyncParseReturnType<any>

OuterTypeOfFunction

Ƭ OuterTypeOfFunction<Args, Returns>: Args["_input"] extends any[] ? (…args: Args["_input"]) => Returns["_output"] : never

Type parameters

NameType
Argsextends ZodTuple<any, any>
Returnsextends ZodTypeAny

OutputTypeOfTuple

Ƭ OutputTypeOfTuple<T>: AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k][“_output”] : never }>

Type parameters

NameType
Textends ZodTupleItems | []

OutputTypeOfTupleWithRest

Ƭ OutputTypeOfTupleWithRest<T, Rest>: Rest extends ZodTypeAny ? […OutputTypeOfTuple<T>, …Rest[“_output”][]] : OutputTypeOfTuple<T>

Type parameters

NameType
Textends ZodTupleItems | []
Restextends ZodTypeAny | null = null

ParseInput

Ƭ ParseInput: Object

Type declaration

NameType
dataany
parentParseContext
path(string | number)[]

ParseParams

Ƭ ParseParams: Object

Type declaration

NameType
asyncboolean
errorMapZodErrorMap
path(string | number)[]

ParsePath

Ƭ ParsePath: ParsePathComponent[]


ParsePathComponent

Ƭ ParsePathComponent: string | number


ParseReturnType

Ƭ ParseReturnType<T>: SyncParseReturnType<T> | AsyncParseReturnType<T>

Type parameters

Name
T

PassthroughType

Ƭ PassthroughType<T>: T extends "passthrough" ? { [k: string]: unknown; } : unknown

Type parameters

NameType
Textends UnknownKeysParam

PreprocessEffect

Ƭ PreprocessEffect<T>: Object

Type parameters

Name
T

Type declaration

NameType
transform(arg: T, ctx: RefinementCtx) => any
type"preprocess"

Primitive

Ƭ Primitive: string | number | symbol | bigint | boolean | null | undefined


ProcessedCreateParams

Ƭ ProcessedCreateParams: Object

Type declaration

NameType
description?string
errorMap?ZodErrorMap

RawCreateParams

Ƭ RawCreateParams: { description?: string ; errorMap?: ZodErrorMap ; invalid_type_error?: string ; message?: string ; required_error?: string } | undefined


RecordType

Ƭ RecordType<K, V>: [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>

Type parameters

NameType
Kextends string | number | symbol
VV

Refinement

Ƭ Refinement<T>: (arg: T, ctx: RefinementCtx) => any

Type parameters

Name
T

Type declaration

▸ (arg, ctx): any

Parameters
NameType
argT
ctxRefinementCtx
Returns

any


RefinementEffect

Ƭ RefinementEffect<T>: Object

Type parameters

Name
T

Type declaration

NameType
refinement(arg: T, ctx: RefinementCtx) => any
type"refinement"

SafeParseError

Ƭ SafeParseError<Input>: Object

Type parameters

Name
Input

Type declaration

NameType
data?never
errorZodError<Input>
successfalse

SafeParseReturnType

Ƭ SafeParseReturnType<Input, Output>: SafeParseSuccess<Output> | SafeParseError<Input>

Type parameters

Name
Input
Output

SafeParseSuccess

Ƭ SafeParseSuccess<Output>: Object

Type parameters

Name
Output

Type declaration

NameType
dataOutput
error?never
successtrue

Scalars

Ƭ Scalars: Primitive | Primitive[]


SomeZodObject

Ƭ SomeZodObject: ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>


StringValidation

Ƭ StringValidation: "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | { includes: string ; position?: number } | { startsWith: string } | { endsWith: string }


SuperRefinement

Ƭ SuperRefinement<T>: (arg: T, ctx: RefinementCtx) => void | Promise<void>

Type parameters

Name
T

Type declaration

▸ (arg, ctx): void | Promise<void>

Parameters
NameType
argT
ctxRefinementCtx
Returns

void | Promise<void>


SyncParseReturnType

Ƭ SyncParseReturnType<T>: OK<T> | DIRTY<T> | INVALID

Type parameters

NameType
Tany

TransformEffect

Ƭ TransformEffect<T>: Object

Type parameters

Name
T

Type declaration

NameType
transform(arg: T, ctx: RefinementCtx) => any
type"transform"

TypeOf

Ƭ TypeOf<T>: T["_output"]

Type parameters

NameType
Textends ZodType<any, any, any>

UnknownKeysParam

Ƭ UnknownKeysParam: "passthrough" | "strict" | "strip"


Values

Ƭ Values<T>: { [k in T[number]]: k }

Type parameters

NameType
Textends EnumValues

Writeable

Ƭ Writeable<T>: { -readonly [P in keyof T]: T[P] }

Type parameters

Name
T

ZodBigIntCheck

Ƭ ZodBigIntCheck: { inclusive: boolean ; kind: "min" ; message?: string ; value: bigint } | { inclusive: boolean ; kind: "max" ; message?: string ; value: bigint } | { kind: "multipleOf" ; message?: string ; value: bigint }


ZodDateCheck

Ƭ ZodDateCheck: { kind: "min" ; message?: string ; value: number } | { kind: "max" ; message?: string ; value: number }


ZodDiscriminatedUnionOption

Ƭ ZodDiscriminatedUnionOption<Discriminator>: ZodObject<{ [key in Discriminator]: ZodTypeAny } & ZodRawShape, UnknownKeysParam, ZodTypeAny>

Type parameters

NameType
Discriminatorextends string

ZodErrorMap

Ƭ ZodErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => { message: string }

Type declaration

▸ (issue, _ctx): Object

Parameters
NameType
issueZodIssueOptionalMessage
_ctxErrorMapCtx
Returns

Object

NameType
messagestring

ZodFirstPartySchemaTypes

Ƭ ZodFirstPartySchemaTypes: ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol


ZodFormattedError

Ƭ ZodFormattedError<T, U>: { _errors: U[] } & recursiveZodFormattedError<NonNullable<T>>

Type parameters

NameType
TT
Ustring

ZodIssue

Ƭ ZodIssue: ZodIssueOptionalMessage & { fatal?: boolean ; message: string }


ZodIssueBase

Ƭ ZodIssueBase: Object

Type declaration

NameType
message?string
path(string | number)[]

ZodIssueCode

Ƭ ZodIssueCode: keyof typeof ZodIssueCode


ZodIssueOptionalMessage

Ƭ ZodIssueOptionalMessage: ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue


ZodNonEmptyArray

Ƭ ZodNonEmptyArray<T>: ZodArray<T, "atleastone">

Type parameters

NameType
Textends ZodTypeAny

ZodNullableType

Ƭ ZodNullableType<T>: ZodNullable<T>

Type parameters

NameType
Textends ZodTypeAny

ZodNumberCheck

Ƭ ZodNumberCheck: { inclusive: boolean ; kind: "min" ; message?: string ; value: number } | { inclusive: boolean ; kind: "max" ; message?: string ; value: number } | { kind: "int" ; message?: string } | { kind: "multipleOf" ; message?: string ; value: number } | { kind: "finite" ; message?: string }


ZodOptionalType

Ƭ ZodOptionalType<T>: ZodOptional<T>

Type parameters

NameType
Textends ZodTypeAny

ZodParsedType

Ƭ ZodParsedType: keyof typeof ZodParsedType


ZodRawShape

Ƭ ZodRawShape: Object

Index signature

▪ [k: string]: ZodTypeAny


ZodStringCheck

Ƭ ZodStringCheck: { kind: "min" ; message?: string ; value: number } | { kind: "max" ; message?: string ; value: number } | { kind: "length" ; message?: string ; value: number } | { kind: "email" ; message?: string } | { kind: "url" ; message?: string } | { kind: "emoji" ; message?: string } | { kind: "uuid" ; message?: string } | { kind: "nanoid" ; message?: string } | { kind: "cuid" ; message?: string } | { kind: "includes" ; message?: string ; position?: number ; value: string } | { kind: "cuid2" ; message?: string } | { kind: "ulid" ; message?: string } | { kind: "startsWith" ; message?: string ; value: string } | { kind: "endsWith" ; message?: string ; value: string } | { kind: "regex" ; message?: string ; regex: RegExp } | { kind: "trim" ; message?: string } | { kind: "toLowerCase" ; message?: string } | { kind: "toUpperCase" ; message?: string } | { alg?: string ; kind: "jwt" ; message?: string } | { kind: "datetime" ; local: boolean ; message?: string ; offset: boolean ; precision: number | null } | { kind: "date" ; message?: string } | { kind: "time" ; message?: string ; precision: number | null } | { kind: "duration" ; message?: string } | { kind: "ip" ; message?: string ; version?: IpVersion } | { kind: "cidr" ; message?: string ; version?: IpVersion } | { kind: "base64" ; message?: string } | { kind: "base64url" ; message?: string }


ZodTupleItems

Ƭ ZodTupleItems: [ZodTypeAny, …ZodTypeAny[]]


ZodTypeAny

Ƭ ZodTypeAny: ZodType<any, any, any>


ZodUnionOptions

Ƭ ZodUnionOptions: Readonly<[ZodTypeAny, …ZodTypeAny[]]>


arrayOutputType

Ƭ arrayOutputType<T, Cardinality>: Cardinality extends "atleastone" ? [T["_output"], …T[“_output”][]] : T["_output"][]

Type parameters

NameType
Textends ZodTypeAny
Cardinalityextends ArrayCardinality = "many"

baseObjectInputType

Ƭ baseObjectInputType<Shape>: addQuestionMarks<{ [k in keyof Shape]: Shape[k][“_input”] }>

Type parameters

NameType
Shapeextends ZodRawShape

baseObjectOutputType

Ƭ baseObjectOutputType<Shape>: { [k in keyof Shape]: Shape[k][“_output”] }

Type parameters

NameType
Shapeextends ZodRawShape

deoptional

Ƭ deoptional<T>: T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T

Type parameters

NameType
Textends ZodTypeAny

inferFlattenedErrors

Ƭ inferFlattenedErrors<T, U>: typeToFlattenedError<TypeOf<T>, U>

Type parameters

NameType
Textends ZodType<any, any, any>
Ustring

inferFormattedError

Ƭ inferFormattedError<T, U>: ZodFormattedError<TypeOf<T>, U>

Type parameters

NameType
Textends ZodType<any, any, any>
Ustring

input

Ƭ input<T>: T["_input"]

Type parameters

NameType
Textends ZodType<any, any, any>

mergeTypes

Ƭ mergeTypes<A, B>: { [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never }

Type parameters

Name
A
B

noUnrecognized

Ƭ noUnrecognized<Obj, Shape>: { [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never }

Type parameters

NameType
Objextends object
Shapeextends object

objectInputType

Ƭ objectInputType<Shape, Catchall, UnknownKeys>: flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>

Type parameters

NameType
Shapeextends ZodRawShape
Catchallextends ZodTypeAny
UnknownKeysextends UnknownKeysParam = UnknownKeysParam

objectOutputType

Ƭ objectOutputType<Shape, Catchall, UnknownKeys>: flatten<addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>

Type parameters

NameType
Shapeextends ZodRawShape
Catchallextends ZodTypeAny
UnknownKeysextends UnknownKeysParam = UnknownKeysParam

output

Ƭ output<T>: T["_output"]

Type parameters

NameType
Textends ZodType<any, any, any>

typeToFlattenedError

Ƭ typeToFlattenedError<T, U>: Object

Type parameters

NameType
TT
Ustring

Type declaration

NameType
fieldErrors{ [P in allKeys<T>]?: U[] }
formErrorsU[]

typecast

Ƭ typecast<A, T>: A extends T ? A : never

Type parameters

Name
A
T

Variables

BRAND

Const BRAND: unique symbol


EMPTY_PATH

Const EMPTY_PATH: ParsePath


INVALID

INVALID: INVALID


NEVER

Const NEVER: never


ZodIssueCode

Const ZodIssueCode: Object

Type declaration

NameType
custom"custom"
invalid_arguments"invalid_arguments"
invalid_date"invalid_date"
invalid_enum_value"invalid_enum_value"
invalid_intersection_types"invalid_intersection_types"
invalid_literal"invalid_literal"
invalid_return_type"invalid_return_type"
invalid_string"invalid_string"
invalid_type"invalid_type"
invalid_union"invalid_union"
invalid_union_discriminator"invalid_union_discriminator"
not_finite"not_finite"
not_multiple_of"not_multiple_of"
too_big"too_big"
too_small"too_small"
unrecognized_keys"unrecognized_keys"

ZodParsedType

Const ZodParsedType: Object

Type declaration

NameType
array"array"
bigint"bigint"
boolean"boolean"
date"date"
float"float"
function"function"
integer"integer"
map"map"
nan"nan"
never"never"
null"null"
number"number"
object"object"
promise"promise"
set"set"
string"string"
symbol"symbol"
undefined"undefined"
unknown"unknown"
void"void"

coerce

Const coerce: Object

Type declaration

NameType
biginttypeof ZodBigInt["create"]
booleantypeof ZodBoolean["create"]
datetypeof ZodDate["create"]
numbertypeof ZodNumber["create"]
stringtypeof ZodString["create"]

late

Const late: Object

Type declaration

NameType
object<Shape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">

Functions

DIRTY

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

Type parameters

Name
T

Parameters

NameType
valueT

Returns

DIRTY<T>


OK

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

Type parameters

Name
T

Parameters

NameType
valueT

Returns

OK<T>


addIssueToContext

addIssueToContext(ctx, issueData): void

Parameters

NameType
ctxParseContext
issueDataIssueData

Returns

void


any

any(params?): ZodAny

Parameters

NameType
params?RawCreateParams

Returns

ZodAny


array

array<El>(schema, params?): ZodArray<El, "many">

Type parameters

NameType
Elextends ZodTypeAny

Parameters

NameType
schemaEl
params?RawCreateParams

Returns

ZodArray<El, "many">


bigint

bigint(params?): ZodBigInt

Parameters

NameType
params?{ description?: string ; errorMap?: ZodErrorMap ; invalid_type_error?: string ; message?: string ; required_error?: string } & { coerce?: boolean }

Returns

ZodBigInt


boolean

boolean(params?): ZodBoolean

Parameters

NameType
params?{ description?: string ; errorMap?: ZodErrorMap ; invalid_type_error?: string ; message?: string ; required_error?: string } & { coerce?: boolean }

Returns

ZodBoolean


custom

custom<T>(check?, _params?, fatal?): ZodType<T, ZodTypeDef, T>

Type parameters

Name
T

Parameters

NameTypeDescription
check?(data: any) => any-
_params?string | CustomParams | (input: any) => CustomParams-
fatal?booleanDeprecated Pass fatal into the params object instead: ts z.string().custom((val) => val.length > 5, { fatal: false })

Returns

ZodType<T, ZodTypeDef, T>


date

date(params?): ZodDate

Parameters

NameType
params?{ description?: string ; errorMap?: ZodErrorMap ; invalid_type_error?: string ; message?: string ; required_error?: string } & { coerce?: boolean }

Returns

ZodDate


datetimeRegex

datetimeRegex(args): RegExp

Parameters

NameType
argsObject
args.local?boolean
args.offset?boolean
args.precision?null | number

Returns

RegExp


defaultErrorMap

defaultErrorMap(issue, _ctx): Object

Parameters

NameType
issueZodIssueOptionalMessage
_ctxErrorMapCtx

Returns

Object

NameType
messagestring

discriminatedUnion

discriminatedUnion<Discriminator, Types>(discriminator, options, params?): 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.

Type parameters

NameType
Discriminatorextends string
Typesextends readonly [ZodDiscriminatedUnionOption<Discriminator>, ZodDiscriminatedUnionOption<Discriminator>]

Parameters

NameTypeDescription
discriminatorDiscriminatorthe name of the discriminator property
optionsTypes-
params?RawCreateParams

Returns

ZodDiscriminatedUnion<Discriminator, Types>


effect

effect<I>(schema, effect, params?): ZodEffects<I, I["_output"], input<I>>

Type parameters

NameType
Iextends ZodTypeAny

Parameters

NameType
schemaI
effectEffect<I["_output"]>
params?RawCreateParams

Returns

ZodEffects<I, I["_output"], input<I>>


enum

enum<U, T>(values, params?): ZodEnum<Writeable<T>>

Type parameters

NameType
Uextends string
Textends readonly [U, U]

Parameters

NameType
valuesT
params?RawCreateParams

Returns

ZodEnum<Writeable<T>>

enum<U, T>(values, params?): ZodEnum<T>

Type parameters

NameType
Uextends string
Textends [U, …U[]]

Parameters

NameType
valuesT
params?RawCreateParams

Returns

ZodEnum<T>


function

function(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>

Returns

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

function<T>(args): ZodFunction<T, ZodUnknown>

Type parameters

NameType
Textends AnyZodTuple = ZodTuple<[], ZodUnknown>

Parameters

NameType
argsT

Returns

ZodFunction<T, ZodUnknown>

function<T, U>(args, returns): ZodFunction<T, U>

Type parameters

NameType
Textends AnyZodTuple
Uextends ZodTypeAny

Parameters

NameType
argsT
returnsU

Returns

ZodFunction<T, U>

function<T, U>(args, returns, params?): ZodFunction<T, U>

Type parameters

NameType
Textends AnyZodTuple = ZodTuple<[], ZodUnknown>
Uextends ZodTypeAny = ZodUnknown

Parameters

NameType
argsT
returnsU
params?RawCreateParams

Returns

ZodFunction<T, U>


getErrorMap

getErrorMap(): ZodErrorMap

Returns

ZodErrorMap


getParsedType

getParsedType(data): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "nan" | "integer" | "float" | "date" | "null" | "array" | "unknown" | "promise" | "void" | "never" | "map" | "set"

Parameters

NameType
dataany

Returns

"string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "nan" | "integer" | "float" | "date" | "null" | "array" | "unknown" | "promise" | "void" | "never" | "map" | "set"


instanceof

instanceof<T>(cls, params?): ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>

Type parameters

NameType
Textends typeof Class

Parameters

NameType
clsT
params?CustomParams

Returns

ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>


intersection

intersection<TSchema, USchema>(left, right, params?): ZodIntersection<TSchema, USchema>

Type parameters

NameType
TSchemaextends ZodTypeAny
USchemaextends ZodTypeAny

Parameters

NameType
leftTSchema
rightUSchema
params?RawCreateParams

Returns

ZodIntersection<TSchema, USchema>


isAborted

isAborted(x): x is INVALID

Parameters

NameType
xParseReturnType<any>

Returns

x is INVALID


isAsync

isAsync<T>(x): x is AsyncParseReturnType<T>

Type parameters

Name
T

Parameters

NameType
xParseReturnType<T>

Returns

x is AsyncParseReturnType<T>


isDirty

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

Type parameters

Name
T

Parameters

NameType
xParseReturnType<T>

Returns

x is OK<T> | DIRTY<T>


isValid

isValid<T>(x): x is OK<T>

Type parameters

Name
T

Parameters

NameType
xParseReturnType<T>

Returns

x is OK<T>


lazy

lazy<Inner>(getter, params?): ZodLazy<Inner>

Type parameters

NameType
Innerextends ZodTypeAny

Parameters

NameType
getter() => Inner
params?RawCreateParams

Returns

ZodLazy<Inner>


literal

literal<Value>(value, params?): ZodLiteral<Value>

Type parameters

NameType
Valueextends Primitive

Parameters

NameType
valueValue
params?RawCreateParams

Returns

ZodLiteral<Value>


makeIssue

makeIssue(params): ZodIssue

Parameters

NameType
paramsObject
params.dataany
params.errorMapsZodErrorMap[]
params.issueDataIssueData
params.path(string | number)[]

Returns

ZodIssue


map

map<KeySchema, ValueSchema>(keyType, valueType, params?): ZodMap<KeySchema, ValueSchema>

Type parameters

NameType
KeySchemaextends ZodTypeAny = ZodTypeAny
ValueSchemaextends ZodTypeAny = ZodTypeAny

Parameters

NameType
keyTypeKeySchema
valueTypeValueSchema
params?RawCreateParams

Returns

ZodMap<KeySchema, ValueSchema>


nan

nan(params?): ZodNaN

Parameters

NameType
params?RawCreateParams

Returns

ZodNaN


nativeEnum

nativeEnum<Elements>(values, params?): ZodNativeEnum<Elements>

Type parameters

NameType
Elementsextends EnumLike

Parameters

NameType
valuesElements
params?RawCreateParams

Returns

ZodNativeEnum<Elements>


never

never(params?): ZodNever

Parameters

NameType
params?RawCreateParams

Returns

ZodNever


null

null(params?): ZodNull

Parameters

NameType
params?RawCreateParams

Returns

ZodNull


nullable

nullable<Inner>(type, params?): ZodNullable<Inner>

Type parameters

NameType
Innerextends ZodTypeAny

Parameters

NameType
typeInner
params?RawCreateParams

Returns

ZodNullable<Inner>


number

number(params?): ZodNumber

Parameters

NameType
params?{ description?: string ; errorMap?: ZodErrorMap ; invalid_type_error?: string ; message?: string ; required_error?: string } & { coerce?: boolean }

Returns

ZodNumber


object

object<Shape>(shape, params?): ZodObject<Shape, "strip", ZodTypeAny, { [k in string | number | symbol]: addQuestionMarks<baseObjectOutputType<Shape>, any>[k] }, { [k in string | number | symbol]: baseObjectInputType<Shape>[k] }>

Type parameters

NameType
Shapeextends ZodRawShape

Parameters

NameType
shapeShape
params?RawCreateParams

Returns

ZodObject<Shape, "strip", ZodTypeAny, { [k in string | number | symbol]: addQuestionMarks<baseObjectOutputType<Shape>, any>[k] }, { [k in string | number | symbol]: baseObjectInputType<Shape>[k] }>


oboolean

oboolean(): ZodOptional<ZodBoolean>

Returns

ZodOptional<ZodBoolean>


onumber

onumber(): ZodOptional<ZodNumber>

Returns

ZodOptional<ZodNumber>


optional

optional<Inner>(type, params?): ZodOptional<Inner>

Type parameters

NameType
Innerextends ZodTypeAny

Parameters

NameType
typeInner
params?RawCreateParams

Returns

ZodOptional<Inner>


ostring

ostring(): ZodOptional<ZodString>

Returns

ZodOptional<ZodString>


pipeline

pipeline<ASchema, BSchema>(a, b): ZodPipeline<ASchema, BSchema>

Type parameters

NameType
ASchemaextends ZodTypeAny
BSchemaextends ZodTypeAny

Parameters

NameType
aASchema
bBSchema

Returns

ZodPipeline<ASchema, BSchema>


preprocess

preprocess<I>(preprocess, schema, params?): ZodEffects<I, I["_output"], unknown>

Type parameters

NameType
Iextends ZodTypeAny

Parameters

NameType
preprocess(arg: unknown, ctx: RefinementCtx) => unknown
schemaI
params?RawCreateParams

Returns

ZodEffects<I, I["_output"], unknown>


promise

promise<Inner>(schema, params?): ZodPromise<Inner>

Type parameters

NameType
Innerextends ZodTypeAny

Parameters

NameType
schemaInner
params?RawCreateParams

Returns

ZodPromise<Inner>


quotelessJson

quotelessJson(obj): string

Parameters

NameType
objany

Returns

string


record

record<Value>(valueType, params?): ZodRecord<ZodString, Value>

Type parameters

NameType
Valueextends ZodTypeAny

Parameters

NameType
valueTypeValue
params?RawCreateParams

Returns

ZodRecord<ZodString, Value>

record<Keys, Value>(keySchema, valueType, params?): ZodRecord<Keys, Value>

Type parameters

NameType
Keysextends KeySchema
Valueextends ZodTypeAny

Parameters

NameType
keySchemaKeys
valueTypeValue
params?RawCreateParams

Returns

ZodRecord<Keys, Value>


set

set<ValueSchema>(valueType, params?): ZodSet<ValueSchema>

Type parameters

NameType
ValueSchemaextends ZodTypeAny = ZodTypeAny

Parameters

NameType
valueTypeValueSchema
params?RawCreateParams

Returns

ZodSet<ValueSchema>


setErrorMap

setErrorMap(map): void

Parameters

NameType
mapZodErrorMap

Returns

void


strictObject

strictObject<Shape>(shape, params?): ZodObject<Shape, "strict", ZodTypeAny, { [k in string | number | symbol]: addQuestionMarks<baseObjectOutputType<Shape>, any>[k] }, { [k in string | number | symbol]: baseObjectInputType<Shape>[k] }>

Type parameters

NameType
Shapeextends ZodRawShape

Parameters

NameType
shapeShape
params?RawCreateParams

Returns

ZodObject<Shape, "strict", ZodTypeAny, { [k in string | number | symbol]: addQuestionMarks<baseObjectOutputType<Shape>, any>[k] }, { [k in string | number | symbol]: baseObjectInputType<Shape>[k] }>


string

string(params?): ZodString

Parameters

NameType
params?{ description?: string ; errorMap?: ZodErrorMap ; invalid_type_error?: string ; message?: string ; required_error?: string } & { coerce?: true }

Returns

ZodString


symbol

symbol(params?): ZodSymbol

Parameters

NameType
params?RawCreateParams

Returns

ZodSymbol


tuple

tuple<Items>(schemas, params?): ZodTuple<Items, null>

Type parameters

NameType
Itemsextends [] | [ZodTypeAny, …ZodTypeAny[]]

Parameters

NameType
schemasItems
params?RawCreateParams

Returns

ZodTuple<Items, null>


undefined

undefined(params?): ZodUndefined

Parameters

NameType
params?RawCreateParams

Returns

ZodUndefined


union

union<Options>(types, params?): ZodUnion<Options>

Type parameters

NameType
Optionsextends readonly [ZodTypeAny, ZodTypeAny, ZodTypeAny]

Parameters

NameType
typesOptions
params?RawCreateParams

Returns

ZodUnion<Options>


unknown

unknown(params?): ZodUnknown

Parameters

NameType
params?RawCreateParams

Returns

ZodUnknown


void

void(params?): ZodVoid

Parameters

NameType
params?RawCreateParams

Returns

ZodVoid