import * as core from "../core/index.js"; import { util } from "../core/index.js"; import * as checks from "./checks.js"; import * as iso from "./iso.js"; import * as parse from "./parse.js"; /////////////////////////////////////////// /////////////////////////////////////////// //////////// //////////// //////////// ZodType //////////// //////////// //////////// /////////////////////////////////////////// /////////////////////////////////////////// export interface RefinementCtx extends core.ParsePayload { addIssue(arg: string | core.$ZodRawIssue | Partial): void; } export interface ZodType< out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals, > extends core.$ZodType { def: Internals["def"]; type: Internals["def"]["type"]; /** @deprecated Use `.def` instead. */ _def: Internals["def"]; /** @deprecated Use `z.output` instead. */ _output: Internals["output"]; /** @deprecated Use `z.input` instead. */ _input: Internals["input"]; // base methods check(...checks: (core.CheckFn> | core.$ZodCheck>)[]): this; clone(def?: Internals["def"], params?: { parent: boolean }): this; register( registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace?] : [core.$replace] : ["Incompatible schema"] ): this; brand(value?: T): PropertyKey extends T ? this : core.$ZodBranded; // parsing parse(data: unknown, params?: core.ParseContext): core.output; safeParse(data: unknown, params?: core.ParseContext): parse.ZodSafeParseResult>; parseAsync(data: unknown, params?: core.ParseContext): Promise>; safeParseAsync( data: unknown, params?: core.ParseContext ): Promise>>; spa: ( data: unknown, params?: core.ParseContext ) => Promise>>; // refinements refine(check: (arg: core.output) => unknown | Promise, params?: string | core.$ZodCustomParams): this; /** @deprecated Use `.check()` instead. */ superRefine( refinement: (arg: core.output, ctx: RefinementCtx>) => void | Promise ): this; overwrite(fn: (x: core.output) => core.output): this; // wrappers optional(): ZodOptional; nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional; nullable(): ZodNullable; nullish(): ZodOptional>; default(def: core.output): ZodDefault; default(def: () => util.NoUndefined>): ZodDefault; prefault(def: () => core.input): ZodPrefault; prefault(def: core.input): ZodPrefault; array(): ZodArray; or(option: T): ZodUnion<[this, T]>; and(incoming: T): ZodIntersection; transform( transform: (arg: core.output, ctx: RefinementCtx>) => NewOut | Promise ): ZodPipe, core.output>>; catch(def: core.output): ZodCatch; catch(def: (ctx: core.$ZodCatchCtx) => core.output): ZodCatch; pipe>>( target: T | core.$ZodType> ): ZodPipe; readonly(): ZodReadonly; /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */ describe(description: string): this; description?: string; /** Returns the metadata associated with this instance in `z.globalRegistry` */ meta(): core.$replace | undefined; /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */ meta(data: core.$replace): this; // helpers /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally): * * ```ts * const schema = z.string().optional(); * const isOptional = schema.safeParse(undefined).success; // true * ``` */ isOptional(): boolean; /** * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally): * * ```ts * const schema = z.string().nullable(); * const isNullable = schema.safeParse(null).success; // true * ``` */ isNullable(): boolean; } export interface _ZodType extends ZodType {} export const ZodType: core.$constructor = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => { core.$ZodType.init(inst, def); inst.def = def; Object.defineProperty(inst, "_def", { value: def }); // base methods inst.check = (...checks) => { return inst.clone( { ...def, checks: [ ...(def.checks ?? []), ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch ), ], } // { parent: true } ); }; inst.clone = (def, params) => core.clone(inst, def, params); inst.brand = () => inst as any; inst.register = ((reg: any, meta: any) => { reg.add(inst, meta); return inst; }) as any; // parsing inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse }); inst.safeParse = (data, params) => parse.safeParse(inst, data, params); inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync }); inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params); inst.spa = inst.safeParseAsync; // refinements inst.refine = (check, params) => inst.check(refine(check, params)); inst.superRefine = (refinement) => inst.check(superRefine(refinement)); inst.overwrite = (fn) => inst.check(checks.overwrite(fn)); // wrappers inst.optional = () => optional(inst); inst.nullable = () => nullable(inst); inst.nullish = () => optional(nullable(inst)); inst.nonoptional = (params) => nonoptional(inst, params); inst.array = () => array(inst); inst.or = (arg) => union([inst, arg]); inst.and = (arg) => intersection(inst, arg); inst.transform = (tx) => pipe(inst, transform(tx as any)) as never; inst.default = (def) => _default(inst, def); inst.prefault = (def) => prefault(inst, def); // inst.coalesce = (def, params) => coalesce(inst, def, params); inst.catch = (params) => _catch(inst, params); inst.pipe = (target) => pipe(inst, target); inst.readonly = () => readonly(inst); // meta inst.describe = (description) => { const cl = inst.clone(); core.globalRegistry.add(cl, { description }); return cl; }; Object.defineProperty(inst, "description", { get() { return core.globalRegistry.get(inst)?.description; }, configurable: true, }); inst.meta = (...args: any) => { if (args.length === 0) { return core.globalRegistry.get(inst); } const cl = inst.clone(); core.globalRegistry.add(cl, args[0]); return cl as any; }; // helpers inst.isOptional = () => inst.safeParse(undefined).success; inst.isNullable = () => inst.safeParse(null).success; return inst; }); // ZodString export interface _ZodString = core.$ZodStringInternals> extends _ZodType { format: string | null; minLength: number | null; maxLength: number | null; // miscellaneous checks regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this; includes(value: string, params?: core.$ZodCheckIncludesParams): this; startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this; endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this; min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this; max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this; length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this; nonempty(params?: string | core.$ZodCheckMinLengthParams): this; lowercase(params?: string | core.$ZodCheckLowerCaseParams): this; uppercase(params?: string | core.$ZodCheckUpperCaseParams): this; // transforms trim(): this; normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this; toLowerCase(): this; toUpperCase(): this; } /** @internal */ export const _ZodString: core.$constructor<_ZodString> = /*@__PURE__*/ core.$constructor("_ZodString", (inst, def) => { core.$ZodString.init(inst, def); ZodType.init(inst, def); const bag = inst._zod.bag; inst.format = bag.format ?? null; inst.minLength = bag.minimum ?? null; inst.maxLength = bag.maximum ?? null; // validations inst.regex = (...args) => inst.check(checks.regex(...args)); inst.includes = (...args) => inst.check(checks.includes(...args)); inst.startsWith = (...args) => inst.check(checks.startsWith(...args)); inst.endsWith = (...args) => inst.check(checks.endsWith(...args)); inst.min = (...args) => inst.check(checks.minLength(...args)); inst.max = (...args) => inst.check(checks.maxLength(...args)); inst.length = (...args) => inst.check(checks.length(...args)); inst.nonempty = (...args) => inst.check(checks.minLength(1, ...args)); inst.lowercase = (params) => inst.check(checks.lowercase(params)); inst.uppercase = (params) => inst.check(checks.uppercase(params)); // transforms inst.trim = () => inst.check(checks.trim()); inst.normalize = (...args) => inst.check(checks.normalize(...args)); inst.toLowerCase = () => inst.check(checks.toLowerCase()); inst.toUpperCase = () => inst.check(checks.toUpperCase()); }); export interface ZodString extends _ZodString> { // string format checks /** @deprecated Use `z.email()` instead. */ email(params?: string | core.$ZodCheckEmailParams): this; /** @deprecated Use `z.url()` instead. */ url(params?: string | core.$ZodCheckURLParams): this; /** @deprecated Use `z.jwt()` instead. */ jwt(params?: string | core.$ZodCheckJWTParams): this; /** @deprecated Use `z.emoji()` instead. */ emoji(params?: string | core.$ZodCheckEmojiParams): this; /** @deprecated Use `z.guid()` instead. */ guid(params?: string | core.$ZodCheckGUIDParams): this; /** @deprecated Use `z.uuid()` instead. */ uuid(params?: string | core.$ZodCheckUUIDParams): this; /** @deprecated Use `z.uuid()` instead. */ uuidv4(params?: string | core.$ZodCheckUUIDParams): this; /** @deprecated Use `z.uuid()` instead. */ uuidv6(params?: string | core.$ZodCheckUUIDParams): this; /** @deprecated Use `z.uuid()` instead. */ uuidv7(params?: string | core.$ZodCheckUUIDParams): this; /** @deprecated Use `z.nanoid()` instead. */ nanoid(params?: string | core.$ZodCheckNanoIDParams): this; /** @deprecated Use `z.guid()` instead. */ guid(params?: string | core.$ZodCheckGUIDParams): this; /** @deprecated Use `z.cuid()` instead. */ cuid(params?: string | core.$ZodCheckCUIDParams): this; /** @deprecated Use `z.cuid2()` instead. */ cuid2(params?: string | core.$ZodCheckCUID2Params): this; /** @deprecated Use `z.ulid()` instead. */ ulid(params?: string | core.$ZodCheckULIDParams): this; /** @deprecated Use `z.base64()` instead. */ base64(params?: string | core.$ZodCheckBase64Params): this; /** @deprecated Use `z.base64url()` instead. */ base64url(params?: string | core.$ZodCheckBase64URLParams): this; // /** @deprecated Use `z.jsonString()` instead. */ // jsonString(params?: string | core.$ZodCheckJSONStringParams): this; /** @deprecated Use `z.xid()` instead. */ xid(params?: string | core.$ZodCheckXIDParams): this; /** @deprecated Use `z.ksuid()` instead. */ ksuid(params?: string | core.$ZodCheckKSUIDParams): this; // /** @deprecated Use `z.ipv4()` or `z.ipv6()` instead. */ // ip(params?: string | (core.$ZodCheckIPv4Params & { version?: "v4" | "v6" })): ZodUnion<[this, this]>; /** @deprecated Use `z.ipv4()` instead. */ ipv4(params?: string | core.$ZodCheckIPv4Params): this; /** @deprecated Use `z.ipv6()` instead. */ ipv6(params?: string | core.$ZodCheckIPv6Params): this; /** @deprecated Use `z.cidrv4()` instead. */ cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this; /** @deprecated Use `z.cidrv6()` instead. */ cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this; /** @deprecated Use `z.e164()` instead. */ e164(params?: string | core.$ZodCheckE164Params): this; // ISO 8601 checks /** @deprecated Use `z.iso.datetime()` instead. */ datetime(params?: string | core.$ZodCheckISODateTimeParams): this; /** @deprecated Use `z.iso.date()` instead. */ date(params?: string | core.$ZodCheckISODateParams): this; /** @deprecated Use `z.iso.time()` instead. */ time( params?: | string // | { // message?: string | undefined; // precision?: number | null; // } | core.$ZodCheckISOTimeParams ): this; /** @deprecated Use `z.iso.duration()` instead. */ duration(params?: string | core.$ZodCheckISODurationParams): this; } export const ZodString: core.$constructor = /*@__PURE__*/ core.$constructor("ZodString", (inst, def) => { core.$ZodString.init(inst, def); _ZodString.init(inst, def); inst.email = (params) => inst.check(core._email(ZodEmail, params)); inst.url = (params) => inst.check(core._url(ZodURL, params)); inst.jwt = (params) => inst.check(core._jwt(ZodJWT, params)); inst.emoji = (params) => inst.check(core._emoji(ZodEmoji, params)); inst.guid = (params) => inst.check(core._guid(ZodGUID, params)); inst.uuid = (params) => inst.check(core._uuid(ZodUUID, params)); inst.uuidv4 = (params) => inst.check(core._uuidv4(ZodUUID, params)); inst.uuidv6 = (params) => inst.check(core._uuidv6(ZodUUID, params)); inst.uuidv7 = (params) => inst.check(core._uuidv7(ZodUUID, params)); inst.nanoid = (params) => inst.check(core._nanoid(ZodNanoID, params)); inst.guid = (params) => inst.check(core._guid(ZodGUID, params)); inst.cuid = (params) => inst.check(core._cuid(ZodCUID, params)); inst.cuid2 = (params) => inst.check(core._cuid2(ZodCUID2, params)); inst.ulid = (params) => inst.check(core._ulid(ZodULID, params)); inst.base64 = (params) => inst.check(core._base64(ZodBase64, params)); inst.base64url = (params) => inst.check(core._base64url(ZodBase64URL, params)); inst.xid = (params) => inst.check(core._xid(ZodXID, params)); inst.ksuid = (params) => inst.check(core._ksuid(ZodKSUID, params)); inst.ipv4 = (params) => inst.check(core._ipv4(ZodIPv4, params)); inst.ipv6 = (params) => inst.check(core._ipv6(ZodIPv6, params)); inst.cidrv4 = (params) => inst.check(core._cidrv4(ZodCIDRv4, params)); inst.cidrv6 = (params) => inst.check(core._cidrv6(ZodCIDRv6, params)); inst.e164 = (params) => inst.check(core._e164(ZodE164, params)); // iso inst.datetime = (params) => inst.check(iso.datetime(params as any)); inst.date = (params) => inst.check(iso.date(params as any)); inst.time = (params) => inst.check(iso.time(params as any)); inst.duration = (params) => inst.check(iso.duration(params as any)); }); export function string(params?: string | core.$ZodStringParams): ZodString; export function string(params?: string | core.$ZodStringParams): core.$ZodType; export function string(params?: string | core.$ZodStringParams): ZodString { return core._string(ZodString, params) as any; } // ZodStringFormat export interface ZodStringFormat extends _ZodString> {} export const ZodStringFormat: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodStringFormat", (inst, def) => { core.$ZodStringFormat.init(inst, def); _ZodString.init(inst, def); } ); // ZodEmail export interface ZodEmail extends ZodStringFormat<"email"> { _zod: core.$ZodEmailInternals; } export const ZodEmail: core.$constructor = /*@__PURE__*/ core.$constructor("ZodEmail", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodEmail.init(inst, def); ZodStringFormat.init(inst, def); }); export function email(params?: string | core.$ZodEmailParams): ZodEmail { return core._email(ZodEmail, params); } // ZodGUID export interface ZodGUID extends ZodStringFormat<"guid"> { _zod: core.$ZodGUIDInternals; } export const ZodGUID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodGUID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodGUID.init(inst, def); ZodStringFormat.init(inst, def); }); export function guid(params?: string | core.$ZodGUIDParams): ZodGUID { return core._guid(ZodGUID, params); } // ZodUUID export interface ZodUUID extends ZodStringFormat<"uuid"> { _zod: core.$ZodUUIDInternals; } export const ZodUUID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodUUID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodUUID.init(inst, def); ZodStringFormat.init(inst, def); }); export function uuid(params?: string | core.$ZodUUIDParams): ZodUUID { return core._uuid(ZodUUID, params); } export function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodUUID { return core._uuidv4(ZodUUID, params); } // ZodUUIDv6 export function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodUUID { return core._uuidv6(ZodUUID, params); } // ZodUUIDv7 export function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodUUID { return core._uuidv7(ZodUUID, params); } // ZodURL export interface ZodURL extends ZodStringFormat<"url"> { _zod: core.$ZodURLInternals; } export const ZodURL: core.$constructor = /*@__PURE__*/ core.$constructor("ZodURL", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodURL.init(inst, def); ZodStringFormat.init(inst, def); }); export function url(params?: string | core.$ZodURLParams): ZodURL { return core._url(ZodURL, params); } // ZodEmoji export interface ZodEmoji extends ZodStringFormat<"emoji"> { _zod: core.$ZodEmojiInternals; } export const ZodEmoji: core.$constructor = /*@__PURE__*/ core.$constructor("ZodEmoji", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodEmoji.init(inst, def); ZodStringFormat.init(inst, def); }); export function emoji(params?: string | core.$ZodEmojiParams): ZodEmoji { return core._emoji(ZodEmoji, params); } // ZodNanoID export interface ZodNanoID extends ZodStringFormat<"nanoid"> { _zod: core.$ZodNanoIDInternals; } export const ZodNanoID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodNanoID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodNanoID.init(inst, def); ZodStringFormat.init(inst, def); }); export function nanoid(params?: string | core.$ZodNanoIDParams): ZodNanoID { return core._nanoid(ZodNanoID, params); } // ZodCUID export interface ZodCUID extends ZodStringFormat<"cuid"> { _zod: core.$ZodCUIDInternals; } export const ZodCUID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodCUID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodCUID.init(inst, def); ZodStringFormat.init(inst, def); }); export function cuid(params?: string | core.$ZodCUIDParams): ZodCUID { return core._cuid(ZodCUID, params); } // ZodCUID2 export interface ZodCUID2 extends ZodStringFormat<"cuid2"> { _zod: core.$ZodCUID2Internals; } export const ZodCUID2: core.$constructor = /*@__PURE__*/ core.$constructor("ZodCUID2", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodCUID2.init(inst, def); ZodStringFormat.init(inst, def); }); export function cuid2(params?: string | core.$ZodCUID2Params): ZodCUID2 { return core._cuid2(ZodCUID2, params); } // ZodULID export interface ZodULID extends ZodStringFormat<"ulid"> { _zod: core.$ZodULIDInternals; } export const ZodULID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodULID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodULID.init(inst, def); ZodStringFormat.init(inst, def); }); export function ulid(params?: string | core.$ZodULIDParams): ZodULID { return core._ulid(ZodULID, params); } // ZodXID export interface ZodXID extends ZodStringFormat<"xid"> { _zod: core.$ZodXIDInternals; } export const ZodXID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodXID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodXID.init(inst, def); ZodStringFormat.init(inst, def); }); export function xid(params?: string | core.$ZodXIDParams): ZodXID { return core._xid(ZodXID, params); } // ZodKSUID export interface ZodKSUID extends ZodStringFormat<"ksuid"> { _zod: core.$ZodKSUIDInternals; } export const ZodKSUID: core.$constructor = /*@__PURE__*/ core.$constructor("ZodKSUID", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodKSUID.init(inst, def); ZodStringFormat.init(inst, def); }); export function ksuid(params?: string | core.$ZodKSUIDParams): ZodKSUID { return core._ksuid(ZodKSUID, params); } // ZodIP // export interface ZodIP extends ZodStringFormat<"ip"> { // _zod: core.$ZodIPInternals; // } // export const ZodIP: core.$constructor = /*@__PURE__*/ core.$constructor("ZodIP", (inst, def) => { // // ZodStringFormat.init(inst, def); // core.$ZodIP.init(inst, def); // ZodStringFormat.init(inst, def); // }); // export function ip(params?: string | core.$ZodIPParams): ZodIP { // return core._ip(ZodIP, params); // } // ZodIPv4 export interface ZodIPv4 extends ZodStringFormat<"ipv4"> { _zod: core.$ZodIPv4Internals; } export const ZodIPv4: core.$constructor = /*@__PURE__*/ core.$constructor("ZodIPv4", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodIPv4.init(inst, def); ZodStringFormat.init(inst, def); }); export function ipv4(params?: string | core.$ZodIPv4Params): ZodIPv4 { return core._ipv4(ZodIPv4, params); } // ZodIPv6 export interface ZodIPv6 extends ZodStringFormat<"ipv6"> { _zod: core.$ZodIPv6Internals; } export const ZodIPv6: core.$constructor = /*@__PURE__*/ core.$constructor("ZodIPv6", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodIPv6.init(inst, def); ZodStringFormat.init(inst, def); }); export function ipv6(params?: string | core.$ZodIPv6Params): ZodIPv6 { return core._ipv6(ZodIPv6, params); } // ZodCIDRv4 export interface ZodCIDRv4 extends ZodStringFormat<"cidrv4"> { _zod: core.$ZodCIDRv4Internals; } export const ZodCIDRv4: core.$constructor = /*@__PURE__*/ core.$constructor("ZodCIDRv4", (inst, def) => { core.$ZodCIDRv4.init(inst, def); ZodStringFormat.init(inst, def); }); export function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodCIDRv4 { return core._cidrv4(ZodCIDRv4, params); } // ZodCIDRv6 export interface ZodCIDRv6 extends ZodStringFormat<"cidrv6"> { _zod: core.$ZodCIDRv6Internals; } export const ZodCIDRv6: core.$constructor = /*@__PURE__*/ core.$constructor("ZodCIDRv6", (inst, def) => { core.$ZodCIDRv6.init(inst, def); ZodStringFormat.init(inst, def); }); export function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodCIDRv6 { return core._cidrv6(ZodCIDRv6, params); } // ZodBase64 export interface ZodBase64 extends ZodStringFormat<"base64"> { _zod: core.$ZodBase64Internals; } export const ZodBase64: core.$constructor = /*@__PURE__*/ core.$constructor("ZodBase64", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodBase64.init(inst, def); ZodStringFormat.init(inst, def); }); export function base64(params?: string | core.$ZodBase64Params): ZodBase64 { return core._base64(ZodBase64, params); } // ZodBase64URL export interface ZodBase64URL extends ZodStringFormat<"base64url"> { _zod: core.$ZodBase64URLInternals; } export const ZodBase64URL: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodBase64URL", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodBase64URL.init(inst, def); ZodStringFormat.init(inst, def); } ); export function base64url(params?: string | core.$ZodBase64URLParams): ZodBase64URL { return core._base64url(ZodBase64URL, params); } // ZodE164 export interface ZodE164 extends ZodStringFormat<"e164"> { _zod: core.$ZodE164Internals; } export const ZodE164: core.$constructor = /*@__PURE__*/ core.$constructor("ZodE164", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodE164.init(inst, def); ZodStringFormat.init(inst, def); }); export function e164(params?: string | core.$ZodE164Params): ZodE164 { return core._e164(ZodE164, params); } // ZodJWT export interface ZodJWT extends ZodStringFormat<"jwt"> { _zod: core.$ZodJWTInternals; } export const ZodJWT: core.$constructor = /*@__PURE__*/ core.$constructor("ZodJWT", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodJWT.init(inst, def); ZodStringFormat.init(inst, def); }); export function jwt(params?: string | core.$ZodJWTParams): ZodJWT { return core._jwt(ZodJWT, params); } // ZodCustomStringFormat export interface ZodCustomStringFormat extends ZodStringFormat, core.$ZodCustomStringFormat { _zod: core.$ZodCustomStringFormatInternals; } export const ZodCustomStringFormat: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodCustomStringFormat", (inst, def) => { // ZodStringFormat.init(inst, def); core.$ZodCustomStringFormat.init(inst, def); ZodStringFormat.init(inst, def); } ); export function stringFormat( format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync) | RegExp, _params: string | core.$ZodStringFormatParams = {} ): ZodCustomStringFormat { return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params) as any; } // ZodNumber export interface _ZodNumber extends _ZodType { gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this; /** Identical to .min() */ gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this; min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this; lt(value: number, params?: string | core.$ZodCheckLessThanParams): this; /** Identical to .max() */ lte(value: number, params?: string | core.$ZodCheckLessThanParams): this; max(value: number, params?: string | core.$ZodCheckLessThanParams): this; /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */ int(params?: string | core.$ZodCheckNumberFormatParams): this; /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */ safe(params?: string | core.$ZodCheckNumberFormatParams): this; positive(params?: string | core.$ZodCheckGreaterThanParams): this; nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this; negative(params?: string | core.$ZodCheckLessThanParams): this; nonpositive(params?: string | core.$ZodCheckLessThanParams): this; multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this; /** @deprecated Use `.multipleOf()` instead. */ step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this; /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */ finite(params?: unknown): this; minValue: number | null; maxValue: number | null; /** @deprecated Check the `format` property instead. */ isInt: boolean; /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */ isFinite: boolean; format: string | null; } export interface ZodNumber extends _ZodNumber> {} export const ZodNumber: core.$constructor = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def) => { core.$ZodNumber.init(inst, def); ZodType.init(inst, def); inst.gt = (value, params) => inst.check(checks.gt(value, params)); inst.gte = (value, params) => inst.check(checks.gte(value, params)); inst.min = (value, params) => inst.check(checks.gte(value, params)); inst.lt = (value, params) => inst.check(checks.lt(value, params)); inst.lte = (value, params) => inst.check(checks.lte(value, params)); inst.max = (value, params) => inst.check(checks.lte(value, params)); inst.int = (params) => inst.check(int(params)); inst.safe = (params) => inst.check(int(params)); inst.positive = (params) => inst.check(checks.gt(0, params)); inst.nonnegative = (params) => inst.check(checks.gte(0, params)); inst.negative = (params) => inst.check(checks.lt(0, params)); inst.nonpositive = (params) => inst.check(checks.lte(0, params)); inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params)); inst.step = (value, params) => inst.check(checks.multipleOf(value, params)); // inst.finite = (params) => inst.check(core.finite(params)); inst.finite = () => inst; const bag = inst._zod.bag; inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null; inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null; inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5); inst.isFinite = true; inst.format = bag.format ?? null; }); export function number(params?: string | core.$ZodNumberParams): ZodNumber { return core._number(ZodNumber, params) as any; } // ZodNumberFormat export interface ZodNumberFormat extends ZodNumber { _zod: core.$ZodNumberFormatInternals; } export const ZodNumberFormat: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodNumberFormat", (inst, def) => { core.$ZodNumberFormat.init(inst, def); ZodNumber.init(inst, def); } ); // int export interface ZodInt extends ZodNumberFormat {} export function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt { return core._int(ZodNumberFormat, params); } // float32 export interface ZodFloat32 extends ZodNumberFormat {} export function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32 { return core._float32(ZodNumberFormat, params); } // float64 export interface ZodFloat64 extends ZodNumberFormat {} export function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64 { return core._float64(ZodNumberFormat, params); } // int32 export interface ZodInt32 extends ZodNumberFormat {} export function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32 { return core._int32(ZodNumberFormat, params); } // uint32 export interface ZodUInt32 extends ZodNumberFormat {} export function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32 { return core._uint32(ZodNumberFormat, params); } // boolean export interface _ZodBoolean extends _ZodType {} export interface ZodBoolean extends _ZodBoolean> {} export const ZodBoolean: core.$constructor = /*@__PURE__*/ core.$constructor("ZodBoolean", (inst, def) => { core.$ZodBoolean.init(inst, def); ZodType.init(inst, def); }); export function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean { return core._boolean(ZodBoolean, params) as any; } // bigint export interface _ZodBigInt extends _ZodType { gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this; /** Alias of `.gte()` */ min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this; gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this; /** Alias of `.lte()` */ lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this; max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this; lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this; positive(params?: string | core.$ZodCheckGreaterThanParams): this; negative(params?: string | core.$ZodCheckLessThanParams): this; nonpositive(params?: string | core.$ZodCheckLessThanParams): this; nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this; multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this; minValue: bigint | null; maxValue: bigint | null; format: string | null; } export interface ZodBigInt extends _ZodBigInt> {} export const ZodBigInt: core.$constructor = /*@__PURE__*/ core.$constructor("ZodBigInt", (inst, def) => { core.$ZodBigInt.init(inst, def); ZodType.init(inst, def); inst.gte = (value, params) => inst.check(checks.gte(value, params)); inst.min = (value, params) => inst.check(checks.gte(value, params)); inst.gt = (value, params) => inst.check(checks.gt(value, params)); inst.gte = (value, params) => inst.check(checks.gte(value, params)); inst.min = (value, params) => inst.check(checks.gte(value, params)); inst.lt = (value, params) => inst.check(checks.lt(value, params)); inst.lte = (value, params) => inst.check(checks.lte(value, params)); inst.max = (value, params) => inst.check(checks.lte(value, params)); inst.positive = (params) => inst.check(checks.gt(BigInt(0), params)); inst.negative = (params) => inst.check(checks.lt(BigInt(0), params)); inst.nonpositive = (params) => inst.check(checks.lte(BigInt(0), params)); inst.nonnegative = (params) => inst.check(checks.gte(BigInt(0), params)); inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params)); const bag = inst._zod.bag; inst.minValue = bag.minimum ?? null; inst.maxValue = bag.maximum ?? null; inst.format = bag.format ?? null; }); export function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt { return core._bigint(ZodBigInt, params) as any; } // bigint formats // ZodBigIntFormat export interface ZodBigIntFormat extends ZodBigInt { _zod: core.$ZodBigIntFormatInternals; } export const ZodBigIntFormat: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodBigIntFormat", (inst, def) => { core.$ZodBigIntFormat.init(inst, def); ZodBigInt.init(inst, def); } ); // int64 export function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat { return core._int64(ZodBigIntFormat, params); } // uint64 export function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat { return core._uint64(ZodBigIntFormat, params); } // symbol export interface ZodSymbol extends _ZodType {} export const ZodSymbol: core.$constructor = /*@__PURE__*/ core.$constructor("ZodSymbol", (inst, def) => { core.$ZodSymbol.init(inst, def); ZodType.init(inst, def); }); export function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol { return core._symbol(ZodSymbol, params); } // ZodUndefined export interface ZodUndefined extends _ZodType {} export const ZodUndefined: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodUndefined", (inst, def) => { core.$ZodUndefined.init(inst, def); ZodType.init(inst, def); } ); function _undefined(params?: string | core.$ZodUndefinedParams): ZodUndefined { return core._undefined(ZodUndefined, params); } export { _undefined as undefined }; // ZodNull export interface ZodNull extends _ZodType {} export const ZodNull: core.$constructor = /*@__PURE__*/ core.$constructor("ZodNull", (inst, def) => { core.$ZodNull.init(inst, def); ZodType.init(inst, def); }); function _null(params?: string | core.$ZodNullParams): ZodNull { return core._null(ZodNull, params); } export { _null as null }; // ZodAny export interface ZodAny extends _ZodType {} export const ZodAny: core.$constructor = /*@__PURE__*/ core.$constructor("ZodAny", (inst, def) => { core.$ZodAny.init(inst, def); ZodType.init(inst, def); }); export function any(): ZodAny { return core._any(ZodAny); } // ZodUnknown export interface ZodUnknown extends _ZodType {} export const ZodUnknown: core.$constructor = /*@__PURE__*/ core.$constructor("ZodUnknown", (inst, def) => { core.$ZodUnknown.init(inst, def); ZodType.init(inst, def); }); export function unknown(): ZodUnknown { return core._unknown(ZodUnknown); } // ZodNever export interface ZodNever extends _ZodType {} export const ZodNever: core.$constructor = /*@__PURE__*/ core.$constructor("ZodNever", (inst, def) => { core.$ZodNever.init(inst, def); ZodType.init(inst, def); }); export function never(params?: string | core.$ZodNeverParams): ZodNever { return core._never(ZodNever, params); } // ZodVoid export interface ZodVoid extends _ZodType {} export const ZodVoid: core.$constructor = /*@__PURE__*/ core.$constructor("ZodVoid", (inst, def) => { core.$ZodVoid.init(inst, def); ZodType.init(inst, def); }); function _void(params?: string | core.$ZodVoidParams): ZodVoid { return core._void(ZodVoid, params); } export { _void as void }; // ZodDate export interface _ZodDate extends _ZodType { min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this; max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this; /** @deprecated Not recommended. */ minDate: Date | null; /** @deprecated Not recommended. */ maxDate: Date | null; } export interface ZodDate extends _ZodDate> {} export const ZodDate: core.$constructor = /*@__PURE__*/ core.$constructor("ZodDate", (inst, def) => { core.$ZodDate.init(inst, def); ZodType.init(inst, def); inst.min = (value, params) => inst.check(checks.gte(value, params)); inst.max = (value, params) => inst.check(checks.lte(value, params)); const c = inst._zod.bag; inst.minDate = c.minimum ? new Date(c.minimum) : null; inst.maxDate = c.maximum ? new Date(c.maximum) : null; }); export function date(params?: string | core.$ZodDateParams): ZodDate { return core._date(ZodDate, params); } // ZodArray export interface ZodArray extends _ZodType>, core.$ZodArray { element: T; min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this; nonempty(params?: string | core.$ZodCheckMinLengthParams): this; max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this; length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this; unwrap(): T; } export const ZodArray: core.$constructor = /*@__PURE__*/ core.$constructor("ZodArray", (inst, def) => { core.$ZodArray.init(inst, def); ZodType.init(inst, def); inst.element = def.element as any; inst.min = (minLength, params) => inst.check(checks.minLength(minLength, params)); inst.nonempty = (params) => inst.check(checks.minLength(1, params)); inst.max = (maxLength, params) => inst.check(checks.maxLength(maxLength, params)); inst.length = (len, params) => inst.check(checks.length(len, params)); inst.unwrap = () => inst.element; }); export function array(element: T, params?: string | core.$ZodArrayParams): ZodArray { return core._array(ZodArray, element as any, params) as any; } // .keyof export function keyof(schema: T): ZodLiteral> { const shape = schema._zod.def.shape; return literal(Object.keys(shape)) as any; } // ZodObject export interface ZodObject< /** @ts-ignore Cast variance */ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip, > extends _ZodType>, core.$ZodObject { shape: Shape; keyof(): ZodEnum>; /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */ catchall(schema: T): ZodObject>; /** @deprecated Use `z.looseObject()` or `.loose()` instead. */ passthrough(): ZodObject; /** Consider `z.looseObject(A.shape)` instead */ loose(): ZodObject; /** Consider `z.strictObject(A.shape)` instead */ strict(): ZodObject; /** This is the default behavior. This method call is likely unnecessary. */ strip(): ZodObject; extend>>( shape: U ): ZodObject, Config>; /** * @deprecated Use spread syntax and the `.shape` property to combine two object schemas: * * ```ts * const A = z.object({ a: z.string() }); * const B = z.object({ b: z.number() }); * * const C = z.object({ * ...A.shape, * ...B.shape * }); * ``` */ merge(other: U): ZodObject, U["_zod"]["config"]>; pick>( mask: M ): ZodObject>>, Config>; omit>( mask: M ): ZodObject>>, Config>; partial(): ZodObject< { [k in keyof Shape]: ZodOptional; }, Config >; partial>( mask: M ): ZodObject< { [k in keyof Shape]: k extends keyof M ? // Shape[k] extends OptionalInSchema // ? Shape[k] // : ZodOptional : Shape[k]; }, Config >; // required required(): ZodObject< { [k in keyof Shape]: ZodNonOptional; }, Config >; required>( mask: M ): ZodObject< { [k in keyof Shape]: k extends keyof M ? ZodNonOptional : Shape[k]; }, Config >; } export const ZodObject: core.$constructor = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def) => { core.$ZodObject.init(inst, def); ZodType.init(inst, def); util.defineLazy(inst, "shape", () => def.shape); inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)) as any; inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall as any as core.$ZodType }) as any; inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); // inst.nonstrict = () => inst.clone({ ...inst._zod.def, catchall: api.unknown() }); inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() }); inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined }); inst.extend = (incoming: any) => { return util.extend(inst, incoming); }; inst.merge = (other) => util.merge(inst, other); inst.pick = (mask) => util.pick(inst, mask); inst.omit = (mask) => util.omit(inst, mask); inst.partial = (...args: any[]) => util.partial(ZodOptional, inst, args[0] as object); inst.required = (...args: any[]) => util.required(ZodNonOptional, inst, args[0] as object); }); export function object>>( shape?: T, params?: string | core.$ZodObjectParams ): ZodObject, core.$strip> { const def: core.$ZodObjectDef = { type: "object", get shape() { util.assignProp(this, "shape", { ...shape }); return this.shape; }, ...util.normalizeParams(params), }; return new ZodObject(def) as any; } // strictObject export function strictObject( shape: T, params?: string | core.$ZodObjectParams ): ZodObject { return new ZodObject({ type: "object", get shape() { util.assignProp(this, "shape", { ...shape }); return this.shape; }, catchall: never(), ...util.normalizeParams(params), }) as any; } // looseObject export function looseObject( shape: T, params?: string | core.$ZodObjectParams ): ZodObject { return new ZodObject({ type: "object", get shape() { util.assignProp(this, "shape", { ...shape }); return this.shape; }, catchall: unknown(), ...util.normalizeParams(params), }) as any; } // ZodUnion export interface ZodUnion extends _ZodType>, core.$ZodUnion { options: T; } export const ZodUnion: core.$constructor = /*@__PURE__*/ core.$constructor("ZodUnion", (inst, def) => { core.$ZodUnion.init(inst, def); ZodType.init(inst, def); inst.options = def.options; }); export function union( options: T, params?: string | core.$ZodUnionParams ): ZodUnion { return new ZodUnion({ type: "union", options: options as any as core.$ZodType[], ...util.normalizeParams(params), }) as any; } // ZodDiscriminatedUnion export interface ZodDiscriminatedUnion extends ZodUnion, core.$ZodDiscriminatedUnion { _zod: core.$ZodDiscriminatedUnionInternals; } export const ZodDiscriminatedUnion: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodDiscriminatedUnion", (inst, def) => { ZodUnion.init(inst, def); core.$ZodDiscriminatedUnion.init(inst, def); } ); export function discriminatedUnion< Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], >( discriminator: string, options: Types, params?: string | core.$ZodDiscriminatedUnionParams ): ZodDiscriminatedUnion { // const [options, params] = args; return new ZodDiscriminatedUnion({ type: "union", options, discriminator, ...util.normalizeParams(params), }) as any; } // ZodIntersection export interface ZodIntersection extends _ZodType>, core.$ZodIntersection {} export const ZodIntersection: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodIntersection", (inst, def) => { core.$ZodIntersection.init(inst, def); ZodType.init(inst, def); } ); export function intersection( left: T, right: U ): ZodIntersection { return new ZodIntersection({ type: "intersection", left: left as any as core.$ZodType, right: right as any as core.$ZodType, }) as any; } // ZodTuple export interface ZodTuple< T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null, > extends _ZodType>, core.$ZodTuple { rest(rest: Rest): ZodTuple; } export const ZodTuple: core.$constructor = /*@__PURE__*/ core.$constructor("ZodTuple", (inst, def) => { core.$ZodTuple.init(inst, def); ZodType.init(inst, def); inst.rest = (rest) => inst.clone({ ...inst._zod.def, rest: rest as any as core.$ZodType, }) as any; }); export function tuple( items: T, params?: string | core.$ZodTupleParams ): ZodTuple; export function tuple( items: T, rest: Rest, params?: string | core.$ZodTupleParams ): ZodTuple; export function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null>; export function tuple( items: core.SomeType[], _paramsOrRest?: string | core.$ZodTupleParams | core.SomeType, _params?: string | core.$ZodTupleParams ) { const hasRest = _paramsOrRest instanceof core.$ZodType; const params = hasRest ? _params : _paramsOrRest; const rest = hasRest ? _paramsOrRest : null; return new ZodTuple({ type: "tuple", items: items as any as core.$ZodType[], rest, ...util.normalizeParams(params), }); } // ZodRecord export interface ZodRecord< Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends core.SomeType = core.$ZodType, > extends _ZodType>, core.$ZodRecord { keyType: Key; valueType: Value; } export const ZodRecord: core.$constructor = /*@__PURE__*/ core.$constructor("ZodRecord", (inst, def) => { core.$ZodRecord.init(inst, def); ZodType.init(inst, def); inst.keyType = def.keyType; inst.valueType = def.valueType; }); export function record( keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams ): ZodRecord { return new ZodRecord({ type: "record", keyType, valueType: valueType as any as core.$ZodType, ...util.normalizeParams(params), }) as any; } // type alksjf = core.output; export function partialRecord( keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams ): ZodRecord { return new ZodRecord({ type: "record", keyType: union([keyType, never()]), valueType: valueType as any, ...util.normalizeParams(params), }) as any; } // ZodMap export interface ZodMap extends _ZodType>, core.$ZodMap { keyType: Key; valueType: Value; } export const ZodMap: core.$constructor = /*@__PURE__*/ core.$constructor("ZodMap", (inst, def) => { core.$ZodMap.init(inst, def); ZodType.init(inst, def); inst.keyType = def.keyType; inst.valueType = def.valueType; }); export function map( keyType: Key, valueType: Value, params?: string | core.$ZodMapParams ): ZodMap { return new ZodMap({ type: "map", keyType: keyType as any as core.$ZodType, valueType: valueType as any as core.$ZodType, ...util.normalizeParams(params), }) as any; } // ZodSet export interface ZodSet extends _ZodType>, core.$ZodSet { min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this; /** */ nonempty(params?: string | core.$ZodCheckMinSizeParams): this; max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this; size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this; } export const ZodSet: core.$constructor = /*@__PURE__*/ core.$constructor("ZodSet", (inst, def) => { core.$ZodSet.init(inst, def); ZodType.init(inst, def); inst.min = (...args) => inst.check(core._minSize(...args)); inst.nonempty = (params) => inst.check(core._minSize(1, params)); inst.max = (...args) => inst.check(core._maxSize(...args)); inst.size = (...args) => inst.check(core._size(...args)); }); export function set( valueType: Value, params?: string | core.$ZodSetParams ): ZodSet { return new ZodSet({ type: "set", valueType: valueType as any as core.$ZodType, ...util.normalizeParams(params), }) as any; } // ZodEnum export interface ZodEnum< /** @ts-ignore Cast variance */ out T extends util.EnumLike = util.EnumLike, > extends _ZodType>, core.$ZodEnum { enum: T; options: Array; extract( values: U, params?: string | core.$ZodEnumParams ): ZodEnum>>; exclude( values: U, params?: string | core.$ZodEnumParams ): ZodEnum>>; } export const ZodEnum: core.$constructor = /*@__PURE__*/ core.$constructor("ZodEnum", (inst, def) => { core.$ZodEnum.init(inst, def); ZodType.init(inst, def); inst.enum = def.entries; inst.options = Object.values(def.entries); const keys = new Set(Object.keys(def.entries)); inst.extract = (values, params) => { const newEntries: Record = {}; for (const value of values) { if (keys.has(value)) { newEntries[value] = def.entries[value]; } else throw new Error(`Key ${value} not found in enum`); } return new ZodEnum({ ...def, checks: [], ...util.normalizeParams(params), entries: newEntries, }) as any; }; inst.exclude = (values, params) => { const newEntries: Record = { ...def.entries }; for (const value of values) { if (keys.has(value)) { delete newEntries[value]; } else throw new Error(`Key ${value} not found in enum`); } return new ZodEnum({ ...def, checks: [], ...util.normalizeParams(params), entries: newEntries, }) as any; }; }); function _enum( values: T, params?: string | core.$ZodEnumParams ): ZodEnum>; function _enum(entries: T, params?: string | core.$ZodEnumParams): ZodEnum; function _enum(values: any, params?: string | core.$ZodEnumParams) { const entries: any = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values; return new ZodEnum({ type: "enum", entries, ...util.normalizeParams(params), }) as any; } export { _enum as enum }; /** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead. * * ```ts * enum Colors { red, green, blue } * z.enum(Colors); * ``` */ export function nativeEnum(entries: T, params?: string | core.$ZodEnumParams): ZodEnum { return new ZodEnum({ type: "enum", entries, ...util.normalizeParams(params), }) as any as ZodEnum; } // ZodLiteral export interface ZodLiteral extends _ZodType>, core.$ZodLiteral { values: Set; /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */ value: T; } export const ZodLiteral: core.$constructor = /*@__PURE__*/ core.$constructor("ZodLiteral", (inst, def) => { core.$ZodLiteral.init(inst, def); ZodType.init(inst, def); inst.values = new Set(def.values); Object.defineProperty(inst, "value", { get() { if (def.values.length > 1) { throw new Error("This schema contains multiple valid literal values. Use `.values` instead."); } return def.values[0]; }, }); }); export function literal>( value: T, params?: string | core.$ZodLiteralParams ): ZodLiteral; export function literal( value: T, params?: string | core.$ZodLiteralParams ): ZodLiteral; export function literal(value: any, params: any) { return new ZodLiteral({ type: "literal", values: Array.isArray(value) ? value : [value], ...util.normalizeParams(params), }); } // ZodFile export interface ZodFile extends _ZodType, core.$ZodFile { min(size: number, params?: string | core.$ZodCheckMinSizeParams): this; max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this; mime(types: util.MimeTypes | Array, params?: string | core.$ZodCheckMimeTypeParams): this; } export const ZodFile: core.$constructor = /*@__PURE__*/ core.$constructor("ZodFile", (inst, def) => { core.$ZodFile.init(inst, def); ZodType.init(inst, def); inst.min = (size, params) => inst.check(core._minSize(size, params)); inst.max = (size, params) => inst.check(core._maxSize(size, params)); inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params)); }); export function file(params?: string | core.$ZodFileParams): ZodFile { return core._file(ZodFile, params) as any; } // ZodTransform export interface ZodTransform extends _ZodType>, core.$ZodTransform {} export const ZodTransform: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodTransform", (inst, def) => { core.$ZodTransform.init(inst, def); ZodType.init(inst, def); inst._zod.parse = (payload, _ctx) => { (payload as RefinementCtx).addIssue = (issue) => { if (typeof issue === "string") { payload.issues.push(util.issue(issue, payload.value, def)); } else { // for Zod 3 backwards compatibility const _issue = issue as any; if (_issue.fatal) _issue.continue = false; _issue.code ??= "custom"; _issue.input ??= payload.value; _issue.inst ??= inst; _issue.continue ??= true; payload.issues.push(util.issue(_issue)); } }; const output = def.transform(payload.value, payload); if (output instanceof Promise) { return output.then((output) => { payload.value = output; return payload; }); } payload.value = output; return payload; }; } ); export function transform( fn: (input: I, ctx: core.ParsePayload) => O ): ZodTransform, I> { return new ZodTransform({ type: "transform", transform: fn as any, }) as any; } // ZodOptional export interface ZodOptional extends _ZodType>, core.$ZodOptional { unwrap(): T; } export const ZodOptional: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodOptional", (inst, def) => { core.$ZodOptional.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; } ); export function optional(innerType: T): ZodOptional { return new ZodOptional({ type: "optional", innerType: innerType as any as core.$ZodType, }) as any; } // ZodNullable export interface ZodNullable extends _ZodType>, core.$ZodNullable { unwrap(): T; } export const ZodNullable: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodNullable", (inst, def) => { core.$ZodNullable.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; } ); export function nullable(innerType: T): ZodNullable { return new ZodNullable({ type: "nullable", innerType: innerType as any as core.$ZodType, }) as any; } // nullish export function nullish(innerType: T): ZodOptional> { return optional(nullable(innerType)); } // ZodDefault export interface ZodDefault extends _ZodType>, core.$ZodDefault { unwrap(): T; /** @deprecated Use `.unwrap()` instead. */ removeDefault(): T; } export const ZodDefault: core.$constructor = /*@__PURE__*/ core.$constructor("ZodDefault", (inst, def) => { core.$ZodDefault.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; inst.removeDefault = inst.unwrap; }); export function _default( innerType: T, defaultValue: util.NoUndefined> | (() => util.NoUndefined>) ): ZodDefault { return new ZodDefault({ type: "default", innerType: innerType as any as core.$ZodType, get defaultValue() { return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue; }, }) as any; } // ZodPrefault export interface ZodPrefault extends _ZodType>, core.$ZodPrefault { unwrap(): T; } export const ZodPrefault: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodPrefault", (inst, def) => { core.$ZodPrefault.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; } ); export function prefault( innerType: T, defaultValue: core.input | (() => core.input) ): ZodPrefault { return new ZodPrefault({ type: "prefault", innerType: innerType as any as core.$ZodType, get defaultValue() { return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue; }, }) as any; } // ZodNonOptional export interface ZodNonOptional extends _ZodType>, core.$ZodNonOptional { unwrap(): T; } export const ZodNonOptional: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodNonOptional", (inst, def) => { core.$ZodNonOptional.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; } ); export function nonoptional( innerType: T, params?: string | core.$ZodNonOptionalParams ): ZodNonOptional { return new ZodNonOptional({ type: "nonoptional", innerType: innerType as any as core.$ZodType, ...util.normalizeParams(params), }) as any; } // ZodSuccess export interface ZodSuccess extends _ZodType>, core.$ZodSuccess { unwrap(): T; } export const ZodSuccess: core.$constructor = /*@__PURE__*/ core.$constructor("ZodSuccess", (inst, def) => { core.$ZodSuccess.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; }); export function success(innerType: T): ZodSuccess { return new ZodSuccess({ type: "success", innerType: innerType as any as core.$ZodType, }) as any; } // ZodCatch export interface ZodCatch extends _ZodType>, core.$ZodCatch { unwrap(): T; /** @deprecated Use `.unwrap()` instead. */ removeCatch(): T; } export const ZodCatch: core.$constructor = /*@__PURE__*/ core.$constructor("ZodCatch", (inst, def) => { core.$ZodCatch.init(inst, def); ZodType.init(inst, def); inst.unwrap = () => inst._zod.def.innerType; inst.removeCatch = inst.unwrap; }); function _catch( innerType: T, catchValue: core.output | ((ctx: core.$ZodCatchCtx) => core.output) ): ZodCatch { return new ZodCatch({ type: "catch", innerType: innerType as any as core.$ZodType, catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as ( ctx: core.$ZodCatchCtx ) => core.output, }) as any; } export { _catch as catch }; // ZodNaN export interface ZodNaN extends _ZodType, core.$ZodNaN {} export const ZodNaN: core.$constructor = /*@__PURE__*/ core.$constructor("ZodNaN", (inst, def) => { core.$ZodNaN.init(inst, def); ZodType.init(inst, def); }); export function nan(params?: string | core.$ZodNaNParams): ZodNaN { return core._nan(ZodNaN, params); } // ZodPipe export interface ZodPipe extends _ZodType>, core.$ZodPipe { in: A; out: B; } export const ZodPipe: core.$constructor = /*@__PURE__*/ core.$constructor("ZodPipe", (inst, def) => { core.$ZodPipe.init(inst, def); ZodType.init(inst, def); inst.in = def.in; inst.out = def.out; }); export function pipe< const A extends core.SomeType, B extends core.$ZodType> = core.$ZodType>, >(in_: A, out: B | core.$ZodType>): ZodPipe; export function pipe(in_: core.SomeType, out: core.SomeType) { return new ZodPipe({ type: "pipe", in: in_ as unknown as core.$ZodType, out: out as unknown as core.$ZodType, // ...util.normalizeParams(params), }); } // ZodReadonly export interface ZodReadonly extends _ZodType>, core.$ZodReadonly {} export const ZodReadonly: core.$constructor = /*@__PURE__*/ core.$constructor( "ZodReadonly", (inst, def) => { core.$ZodReadonly.init(inst, def); ZodType.init(inst, def); } ); export function readonly(innerType: T): ZodReadonly { return new ZodReadonly({ type: "readonly", innerType: innerType as any as core.$ZodType, }) as any; } // ZodTemplateLiteral export interface ZodTemplateLiteral