import * as checks from "./checks.js"; import type * as core from "./core.js"; import type * as errors from "./errors.js"; import * as schemas from "./schemas.js"; import * as util from "./util.js"; export type Params< T extends schemas.$ZodType | checks.$ZodCheck, IssueTypes extends errors.$ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never, > = util.Flatten< Partial< util.EmptyToNever< Omit & ([IssueTypes] extends [never] ? {} // unknown : { error?: string | errors.$ZodErrorMap | undefined; /** @deprecated This parameter is deprecated. Use `error` instead. */ message?: string | undefined; // supported in Zod 3 }) > > >; export type TypeParams< T extends schemas.$ZodType = schemas.$ZodType & { _isst: never }, AlsoOmit extends Exclude = never, > = Params, "type" | "checks" | "error" | AlsoOmit>; // strips types that are not exposed in the public factory // incl. `error`, `check` export type CheckParams< T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never }, AlsoOmit extends Exclude = never, > = Params, "check" | "error" | AlsoOmit>; // strips types that are not exposed in the public factory // incl. `type`, `checks`, `error`, `check`, `format` export type StringFormatParams< T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude = never, > = Params< T, NonNullable, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit >; export type CheckStringFormatParams< T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude = never, > = Params, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>; export type CheckTypeParams< T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude = never, > = Params, "type" | "checks" | "error" | "check" | AlsoOmit>; // String export type $ZodStringParams = TypeParams, "coerce">; export function _string( Class: util.SchemaClass, params?: string | $ZodStringParams ): T { return new Class({ type: "string", ...util.normalizeParams(params), }); } export function _coercedString( Class: util.SchemaClass, params?: string | $ZodStringParams ): T { return new Class({ type: "string", coerce: true, ...util.normalizeParams(params), }); } export type $ZodStringFormatParams = CheckTypeParams; export type $ZodCheckStringFormatParams = CheckParams; // custom format // Email export type $ZodEmailParams = StringFormatParams; export type $ZodCheckEmailParams = CheckStringFormatParams; export function _email( Class: util.SchemaClass, params?: string | $ZodEmailParams | $ZodCheckEmailParams ): T { return new Class({ type: "string", format: "email", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // GUID export type $ZodGUIDParams = StringFormatParams; export type $ZodCheckGUIDParams = CheckStringFormatParams; export function _guid( Class: util.SchemaClass, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams ): T { return new Class({ type: "string", format: "guid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // UUID export type $ZodUUIDParams = StringFormatParams; export type $ZodCheckUUIDParams = CheckStringFormatParams; export function _uuid( Class: util.SchemaClass, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams ): T { return new Class({ type: "string", format: "uuid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // UUIDv4 export type $ZodUUIDv4Params = StringFormatParams; export type $ZodCheckUUIDv4Params = CheckStringFormatParams; export function _uuidv4( Class: util.SchemaClass, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params ): T { return new Class({ type: "string", format: "uuid", check: "string_format", abort: false, version: "v4", ...util.normalizeParams(params), }); } // UUIDv6 export type $ZodUUIDv6Params = StringFormatParams; export type $ZodCheckUUIDv6Params = CheckStringFormatParams; export function _uuidv6( Class: util.SchemaClass, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params ): T { return new Class({ type: "string", format: "uuid", check: "string_format", abort: false, version: "v6", ...util.normalizeParams(params), }); } // UUIDv7 export type $ZodUUIDv7Params = StringFormatParams; export type $ZodCheckUUIDv7Params = CheckStringFormatParams; export function _uuidv7( Class: util.SchemaClass, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params ): T { return new Class({ type: "string", format: "uuid", check: "string_format", abort: false, version: "v7", ...util.normalizeParams(params), }); } // URL export type $ZodURLParams = StringFormatParams; export type $ZodCheckURLParams = CheckStringFormatParams; export function _url( Class: util.SchemaClass, params?: string | $ZodURLParams | $ZodCheckURLParams ): T { return new Class({ type: "string", format: "url", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // Emoji export type $ZodEmojiParams = StringFormatParams; export type $ZodCheckEmojiParams = CheckStringFormatParams; export function _emoji( Class: util.SchemaClass, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams ): T { return new Class({ type: "string", format: "emoji", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // NanoID export type $ZodNanoIDParams = StringFormatParams; export type $ZodCheckNanoIDParams = CheckStringFormatParams; export function _nanoid( Class: util.SchemaClass, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams ): T { return new Class({ type: "string", format: "nanoid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // CUID export type $ZodCUIDParams = StringFormatParams; export type $ZodCheckCUIDParams = CheckStringFormatParams; export function _cuid( Class: util.SchemaClass, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams ): T { return new Class({ type: "string", format: "cuid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // CUID2 export type $ZodCUID2Params = StringFormatParams; export type $ZodCheckCUID2Params = CheckStringFormatParams; export function _cuid2( Class: util.SchemaClass, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params ): T { return new Class({ type: "string", format: "cuid2", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // ULID export type $ZodULIDParams = StringFormatParams; export type $ZodCheckULIDParams = CheckStringFormatParams; export function _ulid( Class: util.SchemaClass, params?: string | $ZodULIDParams | $ZodCheckULIDParams ): T { return new Class({ type: "string", format: "ulid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // XID export type $ZodXIDParams = StringFormatParams; export type $ZodCheckXIDParams = CheckStringFormatParams; export function _xid( Class: util.SchemaClass, params?: string | $ZodXIDParams | $ZodCheckXIDParams ): T { return new Class({ type: "string", format: "xid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // KSUID export type $ZodKSUIDParams = StringFormatParams; export type $ZodCheckKSUIDParams = CheckStringFormatParams; export function _ksuid( Class: util.SchemaClass, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams ): T { return new Class({ type: "string", format: "ksuid", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // IP // export type $ZodIPParams = StringFormatParams; // export type $ZodCheckIPParams = CheckStringFormatParams; // export function _ip( // Class: util.SchemaClass, // params?: string | $ZodIPParams | $ZodCheckIPParams // ): T { // return new Class({ // type: "string", // format: "ip", // check: "string_format", // abort: false, // ...util.normalizeParams(params), // }); // } // IPv4 export type $ZodIPv4Params = StringFormatParams; export type $ZodCheckIPv4Params = CheckStringFormatParams; export function _ipv4( Class: util.SchemaClass, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params ): T { return new Class({ type: "string", format: "ipv4", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // IPv6 export type $ZodIPv6Params = StringFormatParams; export type $ZodCheckIPv6Params = CheckStringFormatParams; export function _ipv6( Class: util.SchemaClass, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params ): T { return new Class({ type: "string", format: "ipv6", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // CIDRv4 export type $ZodCIDRv4Params = StringFormatParams; export type $ZodCheckCIDRv4Params = CheckStringFormatParams; export function _cidrv4( Class: util.SchemaClass, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params ): T { return new Class({ type: "string", format: "cidrv4", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // CIDRv6 export type $ZodCIDRv6Params = StringFormatParams; export type $ZodCheckCIDRv6Params = CheckStringFormatParams; export function _cidrv6( Class: util.SchemaClass, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params ): T { return new Class({ type: "string", format: "cidrv6", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // Base64 export type $ZodBase64Params = StringFormatParams; export type $ZodCheckBase64Params = CheckStringFormatParams; export function _base64( Class: util.SchemaClass, params?: string | $ZodBase64Params | $ZodCheckBase64Params ): T { return new Class({ type: "string", format: "base64", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // base64url export type $ZodBase64URLParams = StringFormatParams; export type $ZodCheckBase64URLParams = CheckStringFormatParams; export function _base64url( Class: util.SchemaClass, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams ): T { return new Class({ type: "string", format: "base64url", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // E164 export type $ZodE164Params = StringFormatParams; export type $ZodCheckE164Params = CheckStringFormatParams; export function _e164( Class: util.SchemaClass, params?: string | $ZodE164Params | $ZodCheckE164Params ): T { return new Class({ type: "string", format: "e164", check: "string_format", abort: false, ...util.normalizeParams(params), }); } // JWT export type $ZodJWTParams = StringFormatParams; export type $ZodCheckJWTParams = CheckStringFormatParams; export function _jwt( Class: util.SchemaClass, params?: string | $ZodJWTParams | $ZodCheckJWTParams ): T { return new Class({ type: "string", format: "jwt", check: "string_format", abort: false, ...util.normalizeParams(params), }); } export const TimePrecision = { Any: null, Minute: -1, Second: 0, Millisecond: 3, Microsecond: 6, } as const; // ISODateTime export type $ZodISODateTimeParams = StringFormatParams; export type $ZodCheckISODateTimeParams = CheckStringFormatParams; export function _isoDateTime( Class: util.SchemaClass, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams ): T { return new Class({ type: "string", format: "datetime", check: "string_format", offset: false, local: false, precision: null, ...util.normalizeParams(params), }); } // ISODate export type $ZodISODateParams = StringFormatParams; export type $ZodCheckISODateParams = CheckStringFormatParams; export function _isoDate( Class: util.SchemaClass, params?: string | $ZodISODateParams | $ZodCheckISODateParams ): T { return new Class({ type: "string", format: "date", check: "string_format", ...util.normalizeParams(params), }); } // ISOTime export type $ZodISOTimeParams = StringFormatParams; export type $ZodCheckISOTimeParams = CheckStringFormatParams; export function _isoTime( Class: util.SchemaClass, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams ): T { return new Class({ type: "string", format: "time", check: "string_format", precision: null, ...util.normalizeParams(params), }); } // ISODuration export type $ZodISODurationParams = StringFormatParams; export type $ZodCheckISODurationParams = CheckStringFormatParams; export function _isoDuration( Class: util.SchemaClass, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams ): T { return new Class({ type: "string", format: "duration", check: "string_format", ...util.normalizeParams(params), }); } // Number export type $ZodNumberParams = TypeParams, "coerce">; export type $ZodNumberFormatParams = CheckTypeParams; export type $ZodCheckNumberFormatParams = CheckParams; export function _number( Class: util.SchemaClass, params?: string | $ZodNumberParams ): T { return new Class({ type: "number", checks: [], ...util.normalizeParams(params), }); } export function _coercedNumber( Class: util.SchemaClass, params?: string | $ZodNumberParams ): T { return new Class({ type: "number", coerce: true, checks: [], ...util.normalizeParams(params), }); } export function _int( Class: util.SchemaClass, params?: string | $ZodCheckNumberFormatParams ): T { return new Class({ type: "number", check: "number_format", abort: false, format: "safeint", ...util.normalizeParams(params), }); } export function _float32( Class: util.SchemaClass, params?: string | $ZodCheckNumberFormatParams ): T { return new Class({ type: "number", check: "number_format", abort: false, format: "float32", ...util.normalizeParams(params), }); } export function _float64( Class: util.SchemaClass, params?: string | $ZodCheckNumberFormatParams ): T { return new Class({ type: "number", check: "number_format", abort: false, format: "float64", ...util.normalizeParams(params), }); } export function _int32( Class: util.SchemaClass, params?: string | $ZodCheckNumberFormatParams ): T { return new Class({ type: "number", check: "number_format", abort: false, format: "int32", ...util.normalizeParams(params), }); } export function _uint32( Class: util.SchemaClass, params?: string | $ZodCheckNumberFormatParams ): T { return new Class({ type: "number", check: "number_format", abort: false, format: "uint32", ...util.normalizeParams(params), }); } // Boolean export type $ZodBooleanParams = TypeParams, "coerce">; export function _boolean( Class: util.SchemaClass, params?: string | $ZodBooleanParams ): T { return new Class({ type: "boolean", ...util.normalizeParams(params), }); } export function _coercedBoolean( Class: util.SchemaClass, params?: string | $ZodBooleanParams ): T { return new Class({ type: "boolean", coerce: true, ...util.normalizeParams(params), }); } // BigInt export type $ZodBigIntParams = TypeParams>; export type $ZodBigIntFormatParams = CheckTypeParams; export type $ZodCheckBigIntFormatParams = CheckParams; export function _bigint( Class: util.SchemaClass, params?: string | $ZodBigIntParams ): T { return new Class({ type: "bigint", ...util.normalizeParams(params), }); } export function _coercedBigint( Class: util.SchemaClass, params?: string | $ZodBigIntParams ): T { return new Class({ type: "bigint", coerce: true, ...util.normalizeParams(params), }); } export function _int64( Class: util.SchemaClass, params?: string | $ZodBigIntFormatParams ): T { return new Class({ type: "bigint", check: "bigint_format", abort: false, format: "int64", ...util.normalizeParams(params), }); } export function _uint64( Class: util.SchemaClass, params?: string | $ZodBigIntFormatParams ): T { return new Class({ type: "bigint", check: "bigint_format", abort: false, format: "uint64", ...util.normalizeParams(params), }); } // Symbol export type $ZodSymbolParams = TypeParams; export function _symbol( Class: util.SchemaClass, params?: string | $ZodSymbolParams ): T { return new Class({ type: "symbol", ...util.normalizeParams(params), }); } // Undefined export type $ZodUndefinedParams = TypeParams; export function _undefined( Class: util.SchemaClass, params?: string | $ZodUndefinedParams ): T { return new Class({ type: "undefined", ...util.normalizeParams(params), }); } // Null export type $ZodNullParams = TypeParams; export function _null(Class: util.SchemaClass, params?: string | $ZodNullParams): T { return new Class({ type: "null", ...util.normalizeParams(params), }); } // Any export type $ZodAnyParams = TypeParams; export function _any(Class: util.SchemaClass): T { return new Class({ type: "any", }); } // Unknown export type $ZodUnknownParams = TypeParams; export function _unknown(Class: util.SchemaClass): T { return new Class({ type: "unknown", }); } // Never export type $ZodNeverParams = TypeParams; export function _never(Class: util.SchemaClass, params?: string | $ZodNeverParams): T { return new Class({ type: "never", ...util.normalizeParams(params), }); } // Void export type $ZodVoidParams = TypeParams; export function _void(Class: util.SchemaClass, params?: string | $ZodVoidParams): T { return new Class({ type: "void", ...util.normalizeParams(params), }); } // Date export type $ZodDateParams = TypeParams; export function _date(Class: util.SchemaClass, params?: string | $ZodDateParams): T { return new Class({ type: "date", ...util.normalizeParams(params), }); } export function _coercedDate( Class: util.SchemaClass, params?: string | $ZodDateParams ): T { return new Class({ type: "date", coerce: true, ...util.normalizeParams(params), }); } // NaN export type $ZodNaNParams = TypeParams; export function _nan(Class: util.SchemaClass, params?: string | $ZodNaNParams): T { return new Class({ type: "nan", ...util.normalizeParams(params), }); } // export type $ZodCheckParams = CheckParams; export type $ZodCheckLessThanParams = CheckParams; export function _lt( value: util.Numeric, params?: string | $ZodCheckLessThanParams ): checks.$ZodCheckLessThan { return new checks.$ZodCheckLessThan({ check: "less_than", ...util.normalizeParams(params), value, inclusive: false, }); } export function _lte( value: util.Numeric, params?: string | $ZodCheckLessThanParams ): checks.$ZodCheckLessThan { return new checks.$ZodCheckLessThan({ check: "less_than", ...util.normalizeParams(params), value, inclusive: true, }); } export { /** @deprecated Use `z.lte()` instead. */ _lte as _max, }; // ZodCheckGreaterThan export type $ZodCheckGreaterThanParams = CheckParams; export function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan { return new checks.$ZodCheckGreaterThan({ check: "greater_than", ...util.normalizeParams(params), value, inclusive: false, }); } export function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan { return new checks.$ZodCheckGreaterThan({ check: "greater_than", ...util.normalizeParams(params), value, inclusive: true, }); } export { /** @deprecated Use `z.gte()` instead. */ _gte as _min, }; export function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan { return _gt(0, params); } // negative export function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan { return _lt(0, params); } // nonpositive export function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan { return _lte(0, params); } // nonnegative export function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan { return _gte(0, params); } export type $ZodCheckMultipleOfParams = CheckParams; export function _multipleOf( value: number | bigint, params?: string | $ZodCheckMultipleOfParams ): checks.$ZodCheckMultipleOf { return new checks.$ZodCheckMultipleOf({ check: "multiple_of", ...util.normalizeParams(params), value, }); } export type $ZodCheckMaxSizeParams = CheckParams; export function _maxSize( maximum: number, params?: string | $ZodCheckMaxSizeParams ): checks.$ZodCheckMaxSize { return new checks.$ZodCheckMaxSize({ check: "max_size", ...util.normalizeParams(params), maximum, }); } export type $ZodCheckMinSizeParams = CheckParams; export function _minSize( minimum: number, params?: string | $ZodCheckMinSizeParams ): checks.$ZodCheckMinSize { return new checks.$ZodCheckMinSize({ check: "min_size", ...util.normalizeParams(params), minimum, }); } export type $ZodCheckSizeEqualsParams = CheckParams; export function _size( size: number, params?: string | $ZodCheckSizeEqualsParams ): checks.$ZodCheckSizeEquals { return new checks.$ZodCheckSizeEquals({ check: "size_equals", ...util.normalizeParams(params), size, }); } export type $ZodCheckMaxLengthParams = CheckParams; export function _maxLength( maximum: number, params?: string | $ZodCheckMaxLengthParams ): checks.$ZodCheckMaxLength { const ch = new checks.$ZodCheckMaxLength({ check: "max_length", ...util.normalizeParams(params), maximum, }); return ch; } export type $ZodCheckMinLengthParams = CheckParams; export function _minLength( minimum: number, params?: string | $ZodCheckMinLengthParams ): checks.$ZodCheckMinLength { return new checks.$ZodCheckMinLength({ check: "min_length", ...util.normalizeParams(params), minimum, }); } export type $ZodCheckLengthEqualsParams = CheckParams; export function _length( length: number, params?: string | $ZodCheckLengthEqualsParams ): checks.$ZodCheckLengthEquals { return new checks.$ZodCheckLengthEquals({ check: "length_equals", ...util.normalizeParams(params), length, }); } export type $ZodCheckRegexParams = CheckParams; export function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex { return new checks.$ZodCheckRegex({ check: "string_format", format: "regex", ...util.normalizeParams(params), pattern, }); } export type $ZodCheckLowerCaseParams = CheckParams; export function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase { return new checks.$ZodCheckLowerCase({ check: "string_format", format: "lowercase", ...util.normalizeParams(params), }); } export type $ZodCheckUpperCaseParams = CheckParams; export function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase { return new checks.$ZodCheckUpperCase({ check: "string_format", format: "uppercase", ...util.normalizeParams(params), }); } export type $ZodCheckIncludesParams = CheckParams; export function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes { return new checks.$ZodCheckIncludes({ check: "string_format", format: "includes", ...util.normalizeParams(params), includes, }); } export type $ZodCheckStartsWithParams = CheckParams; export function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith { return new checks.$ZodCheckStartsWith({ check: "string_format", format: "starts_with", ...util.normalizeParams(params), prefix, }); } export type $ZodCheckEndsWithParams = CheckParams; export function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith { return new checks.$ZodCheckEndsWith({ check: "string_format", format: "ends_with", ...util.normalizeParams(params), suffix, }); } export type $ZodCheckPropertyParams = CheckParams; export function _property( property: K, schema: T, params?: string | $ZodCheckPropertyParams ): checks.$ZodCheckProperty<{ [k in K]: core.output }> { return new checks.$ZodCheckProperty({ check: "property", property, schema, ...util.normalizeParams(params), }); } export type $ZodCheckMimeTypeParams = CheckParams; export function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType { return new checks.$ZodCheckMimeType({ check: "mime_type", mime: types, ...util.normalizeParams(params), }); } export function _overwrite(tx: (input: T) => T): checks.$ZodCheckOverwrite { return new checks.$ZodCheckOverwrite({ check: "overwrite", tx, }) as checks.$ZodCheckOverwrite; } // normalize export function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite { return _overwrite((input) => input.normalize(form)); } // trim export function _trim(): checks.$ZodCheckOverwrite { return _overwrite((input) => input.trim()); } // toLowerCase export function _toLowerCase(): checks.$ZodCheckOverwrite { return _overwrite((input) => input.toLowerCase()); } // toUpperCase export function _toUpperCase(): checks.$ZodCheckOverwrite { return _overwrite((input) => input.toUpperCase()); } /////// collections /////// // Array export type $ZodArrayParams = TypeParams; export function _array( Class: util.SchemaClass, element: T, params?: string | $ZodArrayParams ): schemas.$ZodArray { return new Class({ type: "array", element, // get element() { // return element; // }, ...util.normalizeParams(params), }) as any; } export type $ZodObjectParams = TypeParams; // ZodUnion export type $ZodUnionParams = TypeParams; export function _union( Class: util.SchemaClass, options: T, params?: string | $ZodUnionParams ): schemas.$ZodUnion { return new Class({ type: "union", options, ...util.normalizeParams(params), }) as any; } // ZodDiscriminatedUnion export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals { propValues: util.PropValues; } export interface $ZodTypeDiscriminable extends schemas.$ZodType { _zod: $ZodTypeDiscriminableInternals; } export type $ZodDiscriminatedUnionParams = TypeParams; export function _discriminatedUnion( Class: util.SchemaClass, discriminator: string, options: Types, params?: string | $ZodDiscriminatedUnionParams ): schemas.$ZodDiscriminatedUnion { return new Class({ type: "union", options, discriminator, ...util.normalizeParams(params), }) as any; } // ZodIntersection export type $ZodIntersectionParams = TypeParams; export function _intersection( Class: util.SchemaClass, left: T, right: U ): schemas.$ZodIntersection { return new Class({ type: "intersection", left, right, }) as any; } // ZodTuple export type $ZodTupleParams = TypeParams; export function _tuple( Class: util.SchemaClass, items: T, params?: string | $ZodTupleParams ): schemas.$ZodTuple; export function _tuple( Class: util.SchemaClass, items: T, rest: Rest, params?: string | $ZodTupleParams ): schemas.$ZodTuple; // export function _tuple( // Class: util.SchemaClass, // items: [], // params?: string | $ZodTupleParams // ): schemas.$ZodTuple<[], null>; export function _tuple( Class: util.SchemaClass, items: schemas.$ZodType[], _paramsOrRest?: string | $ZodTupleParams | schemas.$ZodType, _params?: string | $ZodTupleParams ) { const hasRest = _paramsOrRest instanceof schemas.$ZodType; const params = hasRest ? _params : _paramsOrRest; const rest = hasRest ? _paramsOrRest : null; return new Class({ type: "tuple", items, rest, ...util.normalizeParams(params), }); } // ZodRecord export type $ZodRecordParams = TypeParams; export function _record( Class: util.SchemaClass, keyType: Key, valueType: Value, params?: string | $ZodRecordParams ): schemas.$ZodRecord { return new Class({ type: "record", keyType, valueType, ...util.normalizeParams(params), }) as any; } // ZodMap export type $ZodMapParams = TypeParams; export function _map( Class: util.SchemaClass, keyType: Key, valueType: Value, params?: string | $ZodMapParams ): schemas.$ZodMap { return new Class({ type: "map", keyType, valueType, ...util.normalizeParams(params), }) as any; } // ZodSet export type $ZodSetParams = TypeParams; export function _set( Class: util.SchemaClass, valueType: Value, params?: string | $ZodSetParams ): schemas.$ZodSet { return new Class({ type: "set", valueType, ...util.normalizeParams(params), }) as any; } // ZodEnum export type $ZodEnumParams = TypeParams; export function _enum( Class: util.SchemaClass, values: T, params?: string | $ZodEnumParams ): schemas.$ZodEnum>; export function _enum( Class: util.SchemaClass, entries: T, params?: string | $ZodEnumParams ): schemas.$ZodEnum; export function _enum(Class: util.SchemaClass, values: any, params?: string | $ZodEnumParams) { const entries: any = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values; // if (Array.isArray(values)) { // for (const value of values) { // entries[value] = value; // } // } else { // Object.assign(entries, values); // } // const entries: util.EnumLike = {}; // for (const val of values) { // entries[val] = val; // } return new Class({ type: "enum", entries, ...util.normalizeParams(params), }) as any; } /** @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( Class: util.SchemaClass, entries: T, params?: string | $ZodEnumParams ): schemas.$ZodEnum { return new Class({ type: "enum", entries, ...util.normalizeParams(params), }) as any; } // ZodLiteral export type $ZodLiteralParams = TypeParams; export function _literal>( Class: util.SchemaClass, value: T, params?: string | $ZodLiteralParams ): schemas.$ZodLiteral; export function _literal( Class: util.SchemaClass, value: T, params?: string | $ZodLiteralParams ): schemas.$ZodLiteral; export function _literal(Class: util.SchemaClass, value: any, params: any) { return new Class({ type: "literal", values: Array.isArray(value) ? value : [value], ...util.normalizeParams(params), }); } // ZodFile export type $ZodFileParams = TypeParams; export function _file(Class: util.SchemaClass, params?: string | $ZodFileParams): schemas.$ZodFile { return new Class({ type: "file", ...util.normalizeParams(params), }); } // ZodTransform export type $ZodTransformParams = TypeParams; export function _transform( Class: util.SchemaClass, fn: (input: I, ctx?: schemas.ParsePayload) => O ): schemas.$ZodTransform, I> { return new Class({ type: "transform", transform: fn as any, }) as any; } // ZodOptional export type $ZodOptionalParams = TypeParams; export function _optional( Class: util.SchemaClass, innerType: T ): schemas.$ZodOptional { return new Class({ type: "optional", innerType, }) as any; } // ZodNullable export type $ZodNullableParams = TypeParams; export function _nullable( Class: util.SchemaClass, innerType: T ): schemas.$ZodNullable { return new Class({ type: "nullable", innerType, }) as any; } // ZodDefault export type $ZodDefaultParams = TypeParams; export function _default( Class: util.SchemaClass, innerType: T, defaultValue: util.NoUndefined> | (() => util.NoUndefined>) ): schemas.$ZodDefault { return new Class({ type: "default", innerType, get defaultValue() { return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue; }, }) as any; } // ZodNonOptional export type $ZodNonOptionalParams = TypeParams; export function _nonoptional( Class: util.SchemaClass, innerType: T, params?: string | $ZodNonOptionalParams ): schemas.$ZodNonOptional { return new Class({ type: "nonoptional", innerType, ...util.normalizeParams(params), }) as any; } // ZodSuccess export type $ZodSuccessParams = TypeParams; export function _success( Class: util.SchemaClass, innerType: T ): schemas.$ZodSuccess { return new Class({ type: "success", innerType, }) as any; } // ZodCatch export type $ZodCatchParams = TypeParams; export function _catch( Class: util.SchemaClass, innerType: T, catchValue: core.output | ((ctx: schemas.$ZodCatchCtx) => core.output) ): schemas.$ZodCatch { return new Class({ type: "catch", innerType, catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as any, }) as any; } // ZodPipe export type $ZodPipeParams = TypeParams; export function _pipe< const A extends schemas.$ZodType, B extends schemas.$ZodType> = schemas.$ZodType>, >( Class: util.SchemaClass, in_: A, out: B | schemas.$ZodType> ): schemas.$ZodPipe { return new Class({ type: "pipe", in: in_, out, }) as any; } // ZodReadonly export type $ZodReadonlyParams = TypeParams; export function _readonly( Class: util.SchemaClass, innerType: T ): schemas.$ZodReadonly { return new Class({ type: "readonly", innerType, }) as any; } // ZodTemplateLiteral export type $ZodTemplateLiteralParams = TypeParams; export function _templateLiteral( Class: util.SchemaClass, parts: Parts, params?: string | $ZodTemplateLiteralParams ): schemas.$ZodTemplateLiteral> { return new Class({ type: "template_literal", parts, ...util.normalizeParams(params), }) as any; } // ZodLazy export type $ZodLazyParams = TypeParams; export function _lazy( Class: util.SchemaClass, getter: () => T ): schemas.$ZodLazy { return new Class({ type: "lazy", getter, }) as any; } // ZodPromise export type $ZodPromiseParams = TypeParams; export function _promise( Class: util.SchemaClass, innerType: T ): schemas.$ZodPromise { return new Class({ type: "promise", innerType, }) as any; } // ZodCustom export type $ZodCustomParams = CheckTypeParams; export function _custom( Class: util.SchemaClass, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined ): schemas.$ZodCustom { const norm = util.normalizeParams(_params); norm.abort ??= true; // default to abort:false const schema = new Class({ type: "custom", check: "custom", fn: fn as any, ...norm, }); return schema as any; } // export function _refine( // Class: util.SchemaClass, // fn: (arg: NoInfer) => util.MaybeAsync, // _params: string | $ZodCustomParams = {} // ): checks.$ZodCheck { // return _custom(Class, fn, _params); // } // same as _custom but defaults to abort:false export function _refine( Class: util.SchemaClass, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined ): schemas.$ZodCustom { const schema = new Class({ type: "custom", check: "custom", fn: fn as any, ...util.normalizeParams(_params), }); return schema as any; } // export type $ZodCustomParams = CheckTypeParams ///////// STRINGBOOL ///////// // stringbool export interface $ZodStringBoolParams extends TypeParams { truthy?: string[]; falsy?: string[]; /** * Options: `"sensitive"`, `"insensitive"` * * @default `"insensitive"` */ case?: "sensitive" | "insensitive" | undefined; } export function _stringbool( Classes: { Pipe?: typeof schemas.$ZodPipe; Boolean?: typeof schemas.$ZodBoolean; Transform?: typeof schemas.$ZodTransform; String?: typeof schemas.$ZodString; }, _params?: string | $ZodStringBoolParams ): schemas.$ZodPipe< schemas.$ZodPipe>, schemas.$ZodBoolean > { const params = util.normalizeParams(_params); let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"]; let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"]; if (params.case !== "sensitive") { truthyArray = truthyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v)); falsyArray = falsyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v)); } const truthySet = new Set(truthyArray); const falsySet = new Set(falsyArray); const _Pipe = Classes.Pipe ?? schemas.$ZodPipe; const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean; const _String = Classes.String ?? schemas.$ZodString; const _Transform = Classes.Transform ?? schemas.$ZodTransform; const tx = new _Transform({ type: "transform", transform: (input, payload: schemas.ParsePayload) => { let data: string = input as string; if (params.case !== "sensitive") data = data.toLowerCase(); if (truthySet.has(data)) { return true; } else if (falsySet.has(data)) { return false; } else { payload.issues.push({ code: "invalid_value", expected: "stringbool", values: [...truthySet, ...falsySet], input: payload.value, inst: tx, }); return {} as never; } }, error: params.error, }); // params.error; const innerPipe = new _Pipe({ type: "pipe", in: new _String({ type: "string", error: params.error }), out: tx, error: params.error, }); const outerPipe = new _Pipe({ type: "pipe", in: innerPipe, out: new _Boolean({ type: "boolean", error: params.error, }), error: params.error, }); return outerPipe as any; } export function _stringFormat( Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync) | RegExp, _params: string | $ZodStringFormatParams = {} ): schemas.$ZodCustomStringFormat { const params = util.normalizeParams(_params); const def: schemas.$ZodCustomStringFormatDef = { ...util.normalizeParams(_params), check: "string_format", type: "string", format, fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val), ...params, }; if (fnOrRegex instanceof RegExp) { def.pattern = fnOrRegex; } const inst = new Class(def); return inst as any; }