mirror of
https://github.com/hex248/ob248.com.git
synced 2026-02-08 02:33:02 +00:00
merge new into master
This commit is contained in:
1222
node_modules/zod/v4/core/api.cjs
generated
vendored
Normal file
1222
node_modules/zod/v4/core/api.cjs
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
304
node_modules/zod/v4/core/api.d.cts
generated
vendored
Normal file
304
node_modules/zod/v4/core/api.d.cts
generated
vendored
Normal file
@@ -0,0 +1,304 @@
|
||||
import * as checks from "./checks.cjs";
|
||||
import type * as core from "./core.cjs";
|
||||
import type * as errors from "./errors.cjs";
|
||||
import * as registries from "./registries.cjs";
|
||||
import * as schemas from "./schemas.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
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<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
|
||||
error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;
|
||||
/** @deprecated This parameter is deprecated. Use `error` instead. */
|
||||
message?: string | undefined;
|
||||
})>>>;
|
||||
export type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {
|
||||
_isst: never;
|
||||
}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
|
||||
export type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },
|
||||
AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
|
||||
export type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
|
||||
export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
|
||||
export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
|
||||
export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
|
||||
export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
|
||||
export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
|
||||
export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
|
||||
export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
|
||||
export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
|
||||
export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
|
||||
export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
|
||||
export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
|
||||
export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
|
||||
export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
|
||||
export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
|
||||
export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
|
||||
export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
|
||||
export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
|
||||
export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
|
||||
export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
|
||||
export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
|
||||
export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
|
||||
export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
|
||||
export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
|
||||
export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
|
||||
export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
|
||||
export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
|
||||
export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
|
||||
export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
|
||||
export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
|
||||
export type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
|
||||
export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
|
||||
export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
|
||||
export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
|
||||
export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
|
||||
export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
|
||||
export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
|
||||
export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
|
||||
export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
|
||||
export declare const TimePrecision: {
|
||||
readonly Any: null;
|
||||
readonly Minute: -1;
|
||||
readonly Second: 0;
|
||||
readonly Millisecond: 3;
|
||||
readonly Microsecond: 6;
|
||||
};
|
||||
export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
|
||||
export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
|
||||
export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
|
||||
export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
|
||||
export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
|
||||
export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
|
||||
export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
|
||||
export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
|
||||
export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
|
||||
export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
|
||||
export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
|
||||
export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
|
||||
export declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;
|
||||
export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
|
||||
export declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
|
||||
export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
|
||||
export declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;
|
||||
export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
|
||||
export declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
|
||||
export declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
|
||||
export declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;
|
||||
export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
|
||||
export declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;
|
||||
export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
|
||||
export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
|
||||
export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
|
||||
export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
|
||||
export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export {
|
||||
/** @deprecated Use `z.lte()` instead. */
|
||||
_lte as _max, };
|
||||
export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
|
||||
export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export {
|
||||
/** @deprecated Use `z.gte()` instead. */
|
||||
_gte as _min, };
|
||||
export declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
|
||||
export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
|
||||
export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
|
||||
export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
|
||||
export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
|
||||
export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
|
||||
export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
|
||||
export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
|
||||
export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
|
||||
export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
|
||||
export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
|
||||
export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
|
||||
export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
|
||||
export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
|
||||
export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
|
||||
export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
|
||||
export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
|
||||
export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
|
||||
export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
|
||||
export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
|
||||
export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
|
||||
export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
|
||||
export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
|
||||
export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
|
||||
export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
|
||||
export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
|
||||
export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
|
||||
export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
|
||||
[k in K]: core.output<T>;
|
||||
}>;
|
||||
export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
|
||||
export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
|
||||
export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
|
||||
export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _trim(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _slugify(): checks.$ZodCheckOverwrite<string>;
|
||||
export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
|
||||
export declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;
|
||||
export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
|
||||
export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
|
||||
export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
|
||||
export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
|
||||
export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
|
||||
export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
|
||||
propValues: util.PropValues;
|
||||
}
|
||||
export interface $ZodTypeDiscriminable extends schemas.$ZodType {
|
||||
_zod: $ZodTypeDiscriminableInternals;
|
||||
}
|
||||
export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
|
||||
export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
|
||||
export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
|
||||
export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
|
||||
export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;
|
||||
export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
|
||||
export declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;
|
||||
export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
|
||||
export declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;
|
||||
export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
|
||||
export declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;
|
||||
export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
|
||||
export declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;
|
||||
export declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
|
||||
*
|
||||
* ```ts
|
||||
* enum Colors { red, green, blue }
|
||||
* z.enum(Colors);
|
||||
* ```
|
||||
*/
|
||||
export declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
export type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, "values">;
|
||||
export declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;
|
||||
export declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;
|
||||
export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
|
||||
export declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;
|
||||
export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
|
||||
export declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;
|
||||
export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
|
||||
export declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;
|
||||
export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
|
||||
export declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;
|
||||
export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
|
||||
export declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;
|
||||
export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
|
||||
export declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;
|
||||
export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
|
||||
export declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;
|
||||
export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
|
||||
export declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;
|
||||
export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
|
||||
export declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;
|
||||
export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
|
||||
export declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;
|
||||
export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
|
||||
export declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;
|
||||
export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
|
||||
export declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;
|
||||
export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
|
||||
export declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;
|
||||
export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
|
||||
export declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: schemas.$ZodType | checks.$ZodCheck;
|
||||
/** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
|
||||
addIssue(arg: string | $ZodSuperRefineIssue): void;
|
||||
}
|
||||
export declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;
|
||||
export declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;
|
||||
export declare function describe<T>(description: string): checks.$ZodCheck<T>;
|
||||
export declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;
|
||||
export interface $ZodStringBoolParams extends TypeParams {
|
||||
truthy?: string[];
|
||||
falsy?: string[];
|
||||
/**
|
||||
* Options: `"sensitive"`, `"insensitive"`
|
||||
*
|
||||
* @default `"insensitive"`
|
||||
*/
|
||||
case?: "sensitive" | "insensitive" | undefined;
|
||||
}
|
||||
export declare function _stringbool(Classes: {
|
||||
Codec?: typeof schemas.$ZodCodec;
|
||||
Boolean?: typeof schemas.$ZodBoolean;
|
||||
String?: typeof schemas.$ZodString;
|
||||
}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;
|
||||
export declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;
|
||||
304
node_modules/zod/v4/core/api.d.ts
generated
vendored
Normal file
304
node_modules/zod/v4/core/api.d.ts
generated
vendored
Normal file
@@ -0,0 +1,304 @@
|
||||
import * as checks from "./checks.js";
|
||||
import type * as core from "./core.js";
|
||||
import type * as errors from "./errors.js";
|
||||
import * as registries from "./registries.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<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
|
||||
error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;
|
||||
/** @deprecated This parameter is deprecated. Use `error` instead. */
|
||||
message?: string | undefined;
|
||||
})>>>;
|
||||
export type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {
|
||||
_isst: never;
|
||||
}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
|
||||
export type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },
|
||||
AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
|
||||
export type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
|
||||
export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
|
||||
export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
|
||||
export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
|
||||
export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
|
||||
export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
|
||||
export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
|
||||
export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
|
||||
export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
|
||||
export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
|
||||
export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
|
||||
export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
|
||||
export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
|
||||
export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
|
||||
export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
|
||||
export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
|
||||
export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
|
||||
export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
|
||||
export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
|
||||
export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
|
||||
export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
|
||||
export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
|
||||
export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
|
||||
export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
|
||||
export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
|
||||
export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
|
||||
export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
|
||||
export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
|
||||
export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
|
||||
export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
|
||||
export type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
|
||||
export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
|
||||
export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
|
||||
export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
|
||||
export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
|
||||
export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
|
||||
export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
|
||||
export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
|
||||
export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
|
||||
export declare const TimePrecision: {
|
||||
readonly Any: null;
|
||||
readonly Minute: -1;
|
||||
readonly Second: 0;
|
||||
readonly Millisecond: 3;
|
||||
readonly Microsecond: 6;
|
||||
};
|
||||
export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
|
||||
export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
|
||||
export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
|
||||
export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
|
||||
export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
|
||||
export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
|
||||
export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
|
||||
export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
|
||||
export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
|
||||
export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
|
||||
export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
|
||||
export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
|
||||
export declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;
|
||||
export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
|
||||
export declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
|
||||
export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
|
||||
export declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;
|
||||
export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
|
||||
export declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
|
||||
export declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
|
||||
export declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;
|
||||
export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
|
||||
export declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;
|
||||
export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
|
||||
export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
|
||||
export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
|
||||
export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
|
||||
export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export {
|
||||
/** @deprecated Use `z.lte()` instead. */
|
||||
_lte as _max, };
|
||||
export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
|
||||
export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export {
|
||||
/** @deprecated Use `z.gte()` instead. */
|
||||
_gte as _min, };
|
||||
export declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
|
||||
export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
|
||||
export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
|
||||
export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
|
||||
export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
|
||||
export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
|
||||
export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
|
||||
export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
|
||||
export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
|
||||
export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
|
||||
export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
|
||||
export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
|
||||
export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
|
||||
export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
|
||||
export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
|
||||
export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
|
||||
export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
|
||||
export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
|
||||
export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
|
||||
export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
|
||||
export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
|
||||
export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
|
||||
export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
|
||||
export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
|
||||
export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
|
||||
export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
|
||||
export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
|
||||
export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
|
||||
[k in K]: core.output<T>;
|
||||
}>;
|
||||
export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
|
||||
export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
|
||||
export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
|
||||
export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _trim(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _slugify(): checks.$ZodCheckOverwrite<string>;
|
||||
export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
|
||||
export declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;
|
||||
export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
|
||||
export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
|
||||
export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
|
||||
export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
|
||||
export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
|
||||
export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
|
||||
propValues: util.PropValues;
|
||||
}
|
||||
export interface $ZodTypeDiscriminable extends schemas.$ZodType {
|
||||
_zod: $ZodTypeDiscriminableInternals;
|
||||
}
|
||||
export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
|
||||
export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
|
||||
export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
|
||||
export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
|
||||
export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;
|
||||
export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
|
||||
export declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;
|
||||
export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
|
||||
export declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;
|
||||
export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
|
||||
export declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;
|
||||
export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
|
||||
export declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;
|
||||
export declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
|
||||
*
|
||||
* ```ts
|
||||
* enum Colors { red, green, blue }
|
||||
* z.enum(Colors);
|
||||
* ```
|
||||
*/
|
||||
export declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
export type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, "values">;
|
||||
export declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;
|
||||
export declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;
|
||||
export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
|
||||
export declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;
|
||||
export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
|
||||
export declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;
|
||||
export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
|
||||
export declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;
|
||||
export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
|
||||
export declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;
|
||||
export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
|
||||
export declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;
|
||||
export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
|
||||
export declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;
|
||||
export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
|
||||
export declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;
|
||||
export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
|
||||
export declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;
|
||||
export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
|
||||
export declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;
|
||||
export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
|
||||
export declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;
|
||||
export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
|
||||
export declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;
|
||||
export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
|
||||
export declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;
|
||||
export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
|
||||
export declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;
|
||||
export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
|
||||
export declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: schemas.$ZodType | checks.$ZodCheck;
|
||||
/** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
|
||||
addIssue(arg: string | $ZodSuperRefineIssue): void;
|
||||
}
|
||||
export declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;
|
||||
export declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;
|
||||
export declare function describe<T>(description: string): checks.$ZodCheck<T>;
|
||||
export declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;
|
||||
export interface $ZodStringBoolParams extends TypeParams {
|
||||
truthy?: string[];
|
||||
falsy?: string[];
|
||||
/**
|
||||
* Options: `"sensitive"`, `"insensitive"`
|
||||
*
|
||||
* @default `"insensitive"`
|
||||
*/
|
||||
case?: "sensitive" | "insensitive" | undefined;
|
||||
}
|
||||
export declare function _stringbool(Classes: {
|
||||
Codec?: typeof schemas.$ZodCodec;
|
||||
Boolean?: typeof schemas.$ZodBoolean;
|
||||
String?: typeof schemas.$ZodString;
|
||||
}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;
|
||||
export declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;
|
||||
1082
node_modules/zod/v4/core/api.js
generated
vendored
Normal file
1082
node_modules/zod/v4/core/api.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
601
node_modules/zod/v4/core/checks.cjs
generated
vendored
Normal file
601
node_modules/zod/v4/core/checks.cjs
generated
vendored
Normal file
@@ -0,0 +1,601 @@
|
||||
"use strict";
|
||||
// import { $ZodType } from "./schemas.js";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.$ZodCheckOverwrite = exports.$ZodCheckMimeType = exports.$ZodCheckProperty = exports.$ZodCheckEndsWith = exports.$ZodCheckStartsWith = exports.$ZodCheckIncludes = exports.$ZodCheckUpperCase = exports.$ZodCheckLowerCase = exports.$ZodCheckRegex = exports.$ZodCheckStringFormat = exports.$ZodCheckLengthEquals = exports.$ZodCheckMinLength = exports.$ZodCheckMaxLength = exports.$ZodCheckSizeEquals = exports.$ZodCheckMinSize = exports.$ZodCheckMaxSize = exports.$ZodCheckBigIntFormat = exports.$ZodCheckNumberFormat = exports.$ZodCheckMultipleOf = exports.$ZodCheckGreaterThan = exports.$ZodCheckLessThan = exports.$ZodCheck = void 0;
|
||||
const core = __importStar(require("./core.cjs"));
|
||||
const regexes = __importStar(require("./regexes.cjs"));
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
exports.$ZodCheck = core.$constructor("$ZodCheck", (inst, def) => {
|
||||
var _a;
|
||||
inst._zod ?? (inst._zod = {});
|
||||
inst._zod.def = def;
|
||||
(_a = inst._zod).onattach ?? (_a.onattach = []);
|
||||
});
|
||||
const numericOriginMap = {
|
||||
number: "number",
|
||||
bigint: "bigint",
|
||||
object: "date",
|
||||
};
|
||||
exports.$ZodCheckLessThan = core.$constructor("$ZodCheckLessThan", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const origin = numericOriginMap[typeof def.value];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
|
||||
if (def.value < curr) {
|
||||
if (def.inclusive)
|
||||
bag.maximum = def.value;
|
||||
else
|
||||
bag.exclusiveMaximum = def.value;
|
||||
}
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
|
||||
return;
|
||||
}
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_big",
|
||||
maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
||||
input: payload.value,
|
||||
inclusive: def.inclusive,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckGreaterThan = core.$constructor("$ZodCheckGreaterThan", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const origin = numericOriginMap[typeof def.value];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
|
||||
if (def.value > curr) {
|
||||
if (def.inclusive)
|
||||
bag.minimum = def.value;
|
||||
else
|
||||
bag.exclusiveMinimum = def.value;
|
||||
}
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
|
||||
return;
|
||||
}
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_small",
|
||||
minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
||||
input: payload.value,
|
||||
inclusive: def.inclusive,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMultipleOf =
|
||||
/*@__PURE__*/ core.$constructor("$ZodCheckMultipleOf", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
var _a;
|
||||
(_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (typeof payload.value !== typeof def.value)
|
||||
throw new Error("Cannot mix number and bigint in multiple_of check.");
|
||||
const isMultiple = typeof payload.value === "bigint"
|
||||
? payload.value % def.value === BigInt(0)
|
||||
: util.floatSafeRemainder(payload.value, def.value) === 0;
|
||||
if (isMultiple)
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: typeof payload.value,
|
||||
code: "not_multiple_of",
|
||||
divisor: def.value,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckNumberFormat = core.$constructor("$ZodCheckNumberFormat", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def); // no format checks
|
||||
def.format = def.format || "float64";
|
||||
const isInt = def.format?.includes("int");
|
||||
const origin = isInt ? "int" : "number";
|
||||
const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.format = def.format;
|
||||
bag.minimum = minimum;
|
||||
bag.maximum = maximum;
|
||||
if (isInt)
|
||||
bag.pattern = regexes.integer;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
if (isInt) {
|
||||
if (!Number.isInteger(input)) {
|
||||
// invalid_format issue
|
||||
// payload.issues.push({
|
||||
// expected: def.format,
|
||||
// format: def.format,
|
||||
// code: "invalid_format",
|
||||
// input,
|
||||
// inst,
|
||||
// });
|
||||
// invalid_type issue
|
||||
payload.issues.push({
|
||||
expected: origin,
|
||||
format: def.format,
|
||||
code: "invalid_type",
|
||||
continue: false,
|
||||
input,
|
||||
inst,
|
||||
});
|
||||
return;
|
||||
// not_multiple_of issue
|
||||
// payload.issues.push({
|
||||
// code: "not_multiple_of",
|
||||
// origin: "number",
|
||||
// input,
|
||||
// inst,
|
||||
// divisor: 1,
|
||||
// });
|
||||
}
|
||||
if (!Number.isSafeInteger(input)) {
|
||||
if (input > 0) {
|
||||
// too_big
|
||||
payload.issues.push({
|
||||
input,
|
||||
code: "too_big",
|
||||
maximum: Number.MAX_SAFE_INTEGER,
|
||||
note: "Integers must be within the safe integer range.",
|
||||
inst,
|
||||
origin,
|
||||
inclusive: true,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
else {
|
||||
// too_small
|
||||
payload.issues.push({
|
||||
input,
|
||||
code: "too_small",
|
||||
minimum: Number.MIN_SAFE_INTEGER,
|
||||
note: "Integers must be within the safe integer range.",
|
||||
inst,
|
||||
origin,
|
||||
inclusive: true,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (input < minimum) {
|
||||
payload.issues.push({
|
||||
origin: "number",
|
||||
input,
|
||||
code: "too_small",
|
||||
minimum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
if (input > maximum) {
|
||||
payload.issues.push({
|
||||
origin: "number",
|
||||
input,
|
||||
code: "too_big",
|
||||
maximum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckBigIntFormat = core.$constructor("$ZodCheckBigIntFormat", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def); // no format checks
|
||||
const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.format = def.format;
|
||||
bag.minimum = minimum;
|
||||
bag.maximum = maximum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
if (input < minimum) {
|
||||
payload.issues.push({
|
||||
origin: "bigint",
|
||||
input,
|
||||
code: "too_small",
|
||||
minimum: minimum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
if (input > maximum) {
|
||||
payload.issues.push({
|
||||
origin: "bigint",
|
||||
input,
|
||||
code: "too_big",
|
||||
maximum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) => {
|
||||
var _a;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.size !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
|
||||
if (def.maximum < curr)
|
||||
inst._zod.bag.maximum = def.maximum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const size = input.size;
|
||||
if (size <= def.maximum)
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: util.getSizableOrigin(input),
|
||||
code: "too_big",
|
||||
maximum: def.maximum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) => {
|
||||
var _a;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.size !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
|
||||
if (def.minimum > curr)
|
||||
inst._zod.bag.minimum = def.minimum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const size = input.size;
|
||||
if (size >= def.minimum)
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: util.getSizableOrigin(input),
|
||||
code: "too_small",
|
||||
minimum: def.minimum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
|
||||
var _a;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.size !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.minimum = def.size;
|
||||
bag.maximum = def.size;
|
||||
bag.size = def.size;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const size = input.size;
|
||||
if (size === def.size)
|
||||
return;
|
||||
const tooBig = size > def.size;
|
||||
payload.issues.push({
|
||||
origin: util.getSizableOrigin(input),
|
||||
...(tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }),
|
||||
inclusive: true,
|
||||
exact: true,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def) => {
|
||||
var _a;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.length !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
|
||||
if (def.maximum < curr)
|
||||
inst._zod.bag.maximum = def.maximum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const length = input.length;
|
||||
if (length <= def.maximum)
|
||||
return;
|
||||
const origin = util.getLengthableOrigin(input);
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_big",
|
||||
maximum: def.maximum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def) => {
|
||||
var _a;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.length !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
|
||||
if (def.minimum > curr)
|
||||
inst._zod.bag.minimum = def.minimum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const length = input.length;
|
||||
if (length >= def.minimum)
|
||||
return;
|
||||
const origin = util.getLengthableOrigin(input);
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_small",
|
||||
minimum: def.minimum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
|
||||
var _a;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.length !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.minimum = def.length;
|
||||
bag.maximum = def.length;
|
||||
bag.length = def.length;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const length = input.length;
|
||||
if (length === def.length)
|
||||
return;
|
||||
const origin = util.getLengthableOrigin(input);
|
||||
const tooBig = length > def.length;
|
||||
payload.issues.push({
|
||||
origin,
|
||||
...(tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }),
|
||||
inclusive: true,
|
||||
exact: true,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckStringFormat = core.$constructor("$ZodCheckStringFormat", (inst, def) => {
|
||||
var _a, _b;
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.format = def.format;
|
||||
if (def.pattern) {
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(def.pattern);
|
||||
}
|
||||
});
|
||||
if (def.pattern)
|
||||
(_a = inst._zod).check ?? (_a.check = (payload) => {
|
||||
def.pattern.lastIndex = 0;
|
||||
if (def.pattern.test(payload.value))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: def.format,
|
||||
input: payload.value,
|
||||
...(def.pattern ? { pattern: def.pattern.toString() } : {}),
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
});
|
||||
else
|
||||
(_b = inst._zod).check ?? (_b.check = () => { });
|
||||
});
|
||||
exports.$ZodCheckRegex = core.$constructor("$ZodCheckRegex", (inst, def) => {
|
||||
exports.$ZodCheckStringFormat.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
def.pattern.lastIndex = 0;
|
||||
if (def.pattern.test(payload.value))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "regex",
|
||||
input: payload.value,
|
||||
pattern: def.pattern.toString(),
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckLowerCase = core.$constructor("$ZodCheckLowerCase", (inst, def) => {
|
||||
def.pattern ?? (def.pattern = regexes.lowercase);
|
||||
exports.$ZodCheckStringFormat.init(inst, def);
|
||||
});
|
||||
exports.$ZodCheckUpperCase = core.$constructor("$ZodCheckUpperCase", (inst, def) => {
|
||||
def.pattern ?? (def.pattern = regexes.uppercase);
|
||||
exports.$ZodCheckStringFormat.init(inst, def);
|
||||
});
|
||||
exports.$ZodCheckIncludes = core.$constructor("$ZodCheckIncludes", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const escapedRegex = util.escapeRegex(def.includes);
|
||||
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
|
||||
def.pattern = pattern;
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(pattern);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.includes(def.includes, def.position))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "includes",
|
||||
includes: def.includes,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckStartsWith = core.$constructor("$ZodCheckStartsWith", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);
|
||||
def.pattern ?? (def.pattern = pattern);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(pattern);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.startsWith(def.prefix))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "starts_with",
|
||||
prefix: def.prefix,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckEndsWith = core.$constructor("$ZodCheckEndsWith", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);
|
||||
def.pattern ?? (def.pattern = pattern);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(pattern);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.endsWith(def.suffix))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "ends_with",
|
||||
suffix: def.suffix,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
///////////////////////////////////
|
||||
///// $ZodCheckProperty /////
|
||||
///////////////////////////////////
|
||||
function handleCheckPropertyResult(result, payload, property) {
|
||||
if (result.issues.length) {
|
||||
payload.issues.push(...util.prefixIssues(property, result.issues));
|
||||
}
|
||||
}
|
||||
exports.$ZodCheckProperty = core.$constructor("$ZodCheckProperty", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
const result = def.schema._zod.run({
|
||||
value: payload.value[def.property],
|
||||
issues: [],
|
||||
}, {});
|
||||
if (result instanceof Promise) {
|
||||
return result.then((result) => handleCheckPropertyResult(result, payload, def.property));
|
||||
}
|
||||
handleCheckPropertyResult(result, payload, def.property);
|
||||
return;
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMimeType = core.$constructor("$ZodCheckMimeType", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const mimeSet = new Set(def.mime);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
inst._zod.bag.mime = def.mime;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (mimeSet.has(payload.value.type))
|
||||
return;
|
||||
payload.issues.push({
|
||||
code: "invalid_value",
|
||||
values: def.mime,
|
||||
input: payload.value.type,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckOverwrite = core.$constructor("$ZodCheckOverwrite", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
payload.value = def.tx(payload.value);
|
||||
};
|
||||
});
|
||||
278
node_modules/zod/v4/core/checks.d.cts
generated
vendored
Normal file
278
node_modules/zod/v4/core/checks.d.cts
generated
vendored
Normal file
@@ -0,0 +1,278 @@
|
||||
import * as core from "./core.cjs";
|
||||
import type * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export interface $ZodCheckDef {
|
||||
check: string;
|
||||
error?: errors.$ZodErrorMap<never> | undefined;
|
||||
/** If true, no later checks will be executed if this check fails. Default `false`. */
|
||||
abort?: boolean | undefined;
|
||||
/** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
|
||||
when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
|
||||
}
|
||||
export interface $ZodCheckInternals<T> {
|
||||
def: $ZodCheckDef;
|
||||
/** The set of issues this check might throw. */
|
||||
issc?: errors.$ZodIssueBase;
|
||||
check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
|
||||
onattach: ((schema: schemas.$ZodType) => void)[];
|
||||
}
|
||||
export interface $ZodCheck<in T = never> {
|
||||
_zod: $ZodCheckInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;
|
||||
export interface $ZodCheckLessThanDef extends $ZodCheckDef {
|
||||
check: "less_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLessThanDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLessThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;
|
||||
export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
|
||||
check: "greater_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckGreaterThanDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckGreaterThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;
|
||||
export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
|
||||
check: "multiple_of";
|
||||
value: T;
|
||||
}
|
||||
export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMultipleOfDef<T>;
|
||||
issc: errors.$ZodIssueNotMultipleOf;
|
||||
}
|
||||
export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMultipleOfInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;
|
||||
export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
|
||||
export interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
|
||||
check: "number_format";
|
||||
format: $ZodNumberFormats;
|
||||
}
|
||||
export interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
|
||||
def: $ZodCheckNumberFormatDef;
|
||||
issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<"number"> | errors.$ZodIssueTooSmall<"number">;
|
||||
}
|
||||
export interface $ZodCheckNumberFormat extends $ZodCheck<number> {
|
||||
_zod: $ZodCheckNumberFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;
|
||||
export type $ZodBigIntFormats = "int64" | "uint64";
|
||||
export interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {
|
||||
check: "bigint_format";
|
||||
format: $ZodBigIntFormats | undefined;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {
|
||||
def: $ZodCheckBigIntFormatDef;
|
||||
issc: errors.$ZodIssueTooBig<"bigint"> | errors.$ZodIssueTooSmall<"bigint">;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {
|
||||
_zod: $ZodCheckBigIntFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;
|
||||
export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
|
||||
check: "max_size";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxSizeDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;
|
||||
export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
|
||||
check: "min_size";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinSizeDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;
|
||||
export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
|
||||
check: "size_equals";
|
||||
size: number;
|
||||
}
|
||||
export interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckSizeEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckSizeEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;
|
||||
export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
|
||||
check: "max_length";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxLengthDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;
|
||||
export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
|
||||
check: "min_length";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinLengthDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;
|
||||
export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
|
||||
check: "length_equals";
|
||||
length: number;
|
||||
}
|
||||
export interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLengthEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLengthEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;
|
||||
export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
|
||||
export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
|
||||
check: "string_format";
|
||||
format: Format;
|
||||
pattern?: RegExp | undefined;
|
||||
}
|
||||
export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStringFormatDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStringFormat extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStringFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;
|
||||
export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
|
||||
format: "regex";
|
||||
pattern: RegExp;
|
||||
}
|
||||
export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckRegexDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckRegex extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckRegexInternals;
|
||||
}
|
||||
export declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;
|
||||
export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
|
||||
}
|
||||
export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckLowerCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckLowerCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckLowerCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;
|
||||
export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
|
||||
}
|
||||
export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckUpperCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckUpperCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckUpperCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;
|
||||
export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
|
||||
includes: string;
|
||||
position?: number | undefined;
|
||||
}
|
||||
export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckIncludesDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckIncludes extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckIncludesInternals;
|
||||
}
|
||||
export declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;
|
||||
export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStartsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStartsWith extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStartsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;
|
||||
export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckEndsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
|
||||
_zod: $ZodCheckEndsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;
|
||||
export interface $ZodCheckPropertyDef extends $ZodCheckDef {
|
||||
check: "property";
|
||||
property: string;
|
||||
schema: schemas.$ZodType;
|
||||
}
|
||||
export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckPropertyDef;
|
||||
issc: errors.$ZodIssue;
|
||||
}
|
||||
export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckPropertyInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
|
||||
export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
|
||||
check: "mime_type";
|
||||
mime: util.MimeTypes[];
|
||||
}
|
||||
export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMimeTypeDef;
|
||||
issc: errors.$ZodIssueInvalidValue;
|
||||
}
|
||||
export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMimeTypeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;
|
||||
export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
|
||||
check: "overwrite";
|
||||
tx(value: T): T;
|
||||
}
|
||||
export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckOverwriteDef<T>;
|
||||
issc: never;
|
||||
}
|
||||
export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckOverwriteInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;
|
||||
export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
|
||||
export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;
|
||||
278
node_modules/zod/v4/core/checks.d.ts
generated
vendored
Normal file
278
node_modules/zod/v4/core/checks.d.ts
generated
vendored
Normal file
@@ -0,0 +1,278 @@
|
||||
import * as core from "./core.js";
|
||||
import type * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import * as util from "./util.js";
|
||||
export interface $ZodCheckDef {
|
||||
check: string;
|
||||
error?: errors.$ZodErrorMap<never> | undefined;
|
||||
/** If true, no later checks will be executed if this check fails. Default `false`. */
|
||||
abort?: boolean | undefined;
|
||||
/** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
|
||||
when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
|
||||
}
|
||||
export interface $ZodCheckInternals<T> {
|
||||
def: $ZodCheckDef;
|
||||
/** The set of issues this check might throw. */
|
||||
issc?: errors.$ZodIssueBase;
|
||||
check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
|
||||
onattach: ((schema: schemas.$ZodType) => void)[];
|
||||
}
|
||||
export interface $ZodCheck<in T = never> {
|
||||
_zod: $ZodCheckInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;
|
||||
export interface $ZodCheckLessThanDef extends $ZodCheckDef {
|
||||
check: "less_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLessThanDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLessThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;
|
||||
export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
|
||||
check: "greater_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckGreaterThanDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckGreaterThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;
|
||||
export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
|
||||
check: "multiple_of";
|
||||
value: T;
|
||||
}
|
||||
export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMultipleOfDef<T>;
|
||||
issc: errors.$ZodIssueNotMultipleOf;
|
||||
}
|
||||
export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMultipleOfInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;
|
||||
export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
|
||||
export interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
|
||||
check: "number_format";
|
||||
format: $ZodNumberFormats;
|
||||
}
|
||||
export interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
|
||||
def: $ZodCheckNumberFormatDef;
|
||||
issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<"number"> | errors.$ZodIssueTooSmall<"number">;
|
||||
}
|
||||
export interface $ZodCheckNumberFormat extends $ZodCheck<number> {
|
||||
_zod: $ZodCheckNumberFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;
|
||||
export type $ZodBigIntFormats = "int64" | "uint64";
|
||||
export interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {
|
||||
check: "bigint_format";
|
||||
format: $ZodBigIntFormats | undefined;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {
|
||||
def: $ZodCheckBigIntFormatDef;
|
||||
issc: errors.$ZodIssueTooBig<"bigint"> | errors.$ZodIssueTooSmall<"bigint">;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {
|
||||
_zod: $ZodCheckBigIntFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;
|
||||
export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
|
||||
check: "max_size";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxSizeDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;
|
||||
export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
|
||||
check: "min_size";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinSizeDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;
|
||||
export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
|
||||
check: "size_equals";
|
||||
size: number;
|
||||
}
|
||||
export interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckSizeEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckSizeEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;
|
||||
export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
|
||||
check: "max_length";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxLengthDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;
|
||||
export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
|
||||
check: "min_length";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinLengthDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;
|
||||
export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
|
||||
check: "length_equals";
|
||||
length: number;
|
||||
}
|
||||
export interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLengthEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLengthEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;
|
||||
export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
|
||||
export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
|
||||
check: "string_format";
|
||||
format: Format;
|
||||
pattern?: RegExp | undefined;
|
||||
}
|
||||
export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStringFormatDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStringFormat extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStringFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;
|
||||
export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
|
||||
format: "regex";
|
||||
pattern: RegExp;
|
||||
}
|
||||
export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckRegexDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckRegex extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckRegexInternals;
|
||||
}
|
||||
export declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;
|
||||
export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
|
||||
}
|
||||
export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckLowerCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckLowerCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckLowerCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;
|
||||
export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
|
||||
}
|
||||
export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckUpperCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckUpperCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckUpperCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;
|
||||
export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
|
||||
includes: string;
|
||||
position?: number | undefined;
|
||||
}
|
||||
export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckIncludesDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckIncludes extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckIncludesInternals;
|
||||
}
|
||||
export declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;
|
||||
export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStartsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStartsWith extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStartsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;
|
||||
export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckEndsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
|
||||
_zod: $ZodCheckEndsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;
|
||||
export interface $ZodCheckPropertyDef extends $ZodCheckDef {
|
||||
check: "property";
|
||||
property: string;
|
||||
schema: schemas.$ZodType;
|
||||
}
|
||||
export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckPropertyDef;
|
||||
issc: errors.$ZodIssue;
|
||||
}
|
||||
export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckPropertyInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
|
||||
export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
|
||||
check: "mime_type";
|
||||
mime: util.MimeTypes[];
|
||||
}
|
||||
export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMimeTypeDef;
|
||||
issc: errors.$ZodIssueInvalidValue;
|
||||
}
|
||||
export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMimeTypeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;
|
||||
export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
|
||||
check: "overwrite";
|
||||
tx(value: T): T;
|
||||
}
|
||||
export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckOverwriteDef<T>;
|
||||
issc: never;
|
||||
}
|
||||
export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckOverwriteInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;
|
||||
export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
|
||||
export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;
|
||||
575
node_modules/zod/v4/core/checks.js
generated
vendored
Normal file
575
node_modules/zod/v4/core/checks.js
generated
vendored
Normal file
@@ -0,0 +1,575 @@
|
||||
// import { $ZodType } from "./schemas.js";
|
||||
import * as core from "./core.js";
|
||||
import * as regexes from "./regexes.js";
|
||||
import * as util from "./util.js";
|
||||
export const $ZodCheck = /*@__PURE__*/ core.$constructor("$ZodCheck", (inst, def) => {
|
||||
var _a;
|
||||
inst._zod ?? (inst._zod = {});
|
||||
inst._zod.def = def;
|
||||
(_a = inst._zod).onattach ?? (_a.onattach = []);
|
||||
});
|
||||
const numericOriginMap = {
|
||||
number: "number",
|
||||
bigint: "bigint",
|
||||
object: "date",
|
||||
};
|
||||
export const $ZodCheckLessThan = /*@__PURE__*/ core.$constructor("$ZodCheckLessThan", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
const origin = numericOriginMap[typeof def.value];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
|
||||
if (def.value < curr) {
|
||||
if (def.inclusive)
|
||||
bag.maximum = def.value;
|
||||
else
|
||||
bag.exclusiveMaximum = def.value;
|
||||
}
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
|
||||
return;
|
||||
}
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_big",
|
||||
maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
||||
input: payload.value,
|
||||
inclusive: def.inclusive,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckGreaterThan = /*@__PURE__*/ core.$constructor("$ZodCheckGreaterThan", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
const origin = numericOriginMap[typeof def.value];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
|
||||
if (def.value > curr) {
|
||||
if (def.inclusive)
|
||||
bag.minimum = def.value;
|
||||
else
|
||||
bag.exclusiveMinimum = def.value;
|
||||
}
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
|
||||
return;
|
||||
}
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_small",
|
||||
minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
||||
input: payload.value,
|
||||
inclusive: def.inclusive,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckMultipleOf =
|
||||
/*@__PURE__*/ core.$constructor("$ZodCheckMultipleOf", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
var _a;
|
||||
(_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (typeof payload.value !== typeof def.value)
|
||||
throw new Error("Cannot mix number and bigint in multiple_of check.");
|
||||
const isMultiple = typeof payload.value === "bigint"
|
||||
? payload.value % def.value === BigInt(0)
|
||||
: util.floatSafeRemainder(payload.value, def.value) === 0;
|
||||
if (isMultiple)
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: typeof payload.value,
|
||||
code: "not_multiple_of",
|
||||
divisor: def.value,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckNumberFormat = /*@__PURE__*/ core.$constructor("$ZodCheckNumberFormat", (inst, def) => {
|
||||
$ZodCheck.init(inst, def); // no format checks
|
||||
def.format = def.format || "float64";
|
||||
const isInt = def.format?.includes("int");
|
||||
const origin = isInt ? "int" : "number";
|
||||
const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.format = def.format;
|
||||
bag.minimum = minimum;
|
||||
bag.maximum = maximum;
|
||||
if (isInt)
|
||||
bag.pattern = regexes.integer;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
if (isInt) {
|
||||
if (!Number.isInteger(input)) {
|
||||
// invalid_format issue
|
||||
// payload.issues.push({
|
||||
// expected: def.format,
|
||||
// format: def.format,
|
||||
// code: "invalid_format",
|
||||
// input,
|
||||
// inst,
|
||||
// });
|
||||
// invalid_type issue
|
||||
payload.issues.push({
|
||||
expected: origin,
|
||||
format: def.format,
|
||||
code: "invalid_type",
|
||||
continue: false,
|
||||
input,
|
||||
inst,
|
||||
});
|
||||
return;
|
||||
// not_multiple_of issue
|
||||
// payload.issues.push({
|
||||
// code: "not_multiple_of",
|
||||
// origin: "number",
|
||||
// input,
|
||||
// inst,
|
||||
// divisor: 1,
|
||||
// });
|
||||
}
|
||||
if (!Number.isSafeInteger(input)) {
|
||||
if (input > 0) {
|
||||
// too_big
|
||||
payload.issues.push({
|
||||
input,
|
||||
code: "too_big",
|
||||
maximum: Number.MAX_SAFE_INTEGER,
|
||||
note: "Integers must be within the safe integer range.",
|
||||
inst,
|
||||
origin,
|
||||
inclusive: true,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
else {
|
||||
// too_small
|
||||
payload.issues.push({
|
||||
input,
|
||||
code: "too_small",
|
||||
minimum: Number.MIN_SAFE_INTEGER,
|
||||
note: "Integers must be within the safe integer range.",
|
||||
inst,
|
||||
origin,
|
||||
inclusive: true,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (input < minimum) {
|
||||
payload.issues.push({
|
||||
origin: "number",
|
||||
input,
|
||||
code: "too_small",
|
||||
minimum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
if (input > maximum) {
|
||||
payload.issues.push({
|
||||
origin: "number",
|
||||
input,
|
||||
code: "too_big",
|
||||
maximum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
};
|
||||
});
|
||||
export const $ZodCheckBigIntFormat = /*@__PURE__*/ core.$constructor("$ZodCheckBigIntFormat", (inst, def) => {
|
||||
$ZodCheck.init(inst, def); // no format checks
|
||||
const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.format = def.format;
|
||||
bag.minimum = minimum;
|
||||
bag.maximum = maximum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
if (input < minimum) {
|
||||
payload.issues.push({
|
||||
origin: "bigint",
|
||||
input,
|
||||
code: "too_small",
|
||||
minimum: minimum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
if (input > maximum) {
|
||||
payload.issues.push({
|
||||
origin: "bigint",
|
||||
input,
|
||||
code: "too_big",
|
||||
maximum,
|
||||
inclusive: true,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
}
|
||||
};
|
||||
});
|
||||
export const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor("$ZodCheckMaxSize", (inst, def) => {
|
||||
var _a;
|
||||
$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.size !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
|
||||
if (def.maximum < curr)
|
||||
inst._zod.bag.maximum = def.maximum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const size = input.size;
|
||||
if (size <= def.maximum)
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: util.getSizableOrigin(input),
|
||||
code: "too_big",
|
||||
maximum: def.maximum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor("$ZodCheckMinSize", (inst, def) => {
|
||||
var _a;
|
||||
$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.size !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
|
||||
if (def.minimum > curr)
|
||||
inst._zod.bag.minimum = def.minimum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const size = input.size;
|
||||
if (size >= def.minimum)
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: util.getSizableOrigin(input),
|
||||
code: "too_small",
|
||||
minimum: def.minimum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
|
||||
var _a;
|
||||
$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.size !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.minimum = def.size;
|
||||
bag.maximum = def.size;
|
||||
bag.size = def.size;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const size = input.size;
|
||||
if (size === def.size)
|
||||
return;
|
||||
const tooBig = size > def.size;
|
||||
payload.issues.push({
|
||||
origin: util.getSizableOrigin(input),
|
||||
...(tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }),
|
||||
inclusive: true,
|
||||
exact: true,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxLength", (inst, def) => {
|
||||
var _a;
|
||||
$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.length !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
|
||||
if (def.maximum < curr)
|
||||
inst._zod.bag.maximum = def.maximum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const length = input.length;
|
||||
if (length <= def.maximum)
|
||||
return;
|
||||
const origin = util.getLengthableOrigin(input);
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_big",
|
||||
maximum: def.maximum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinLength", (inst, def) => {
|
||||
var _a;
|
||||
$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.length !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
|
||||
if (def.minimum > curr)
|
||||
inst._zod.bag.minimum = def.minimum;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const length = input.length;
|
||||
if (length >= def.minimum)
|
||||
return;
|
||||
const origin = util.getLengthableOrigin(input);
|
||||
payload.issues.push({
|
||||
origin,
|
||||
code: "too_small",
|
||||
minimum: def.minimum,
|
||||
inclusive: true,
|
||||
input,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
|
||||
var _a;
|
||||
$ZodCheck.init(inst, def);
|
||||
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
||||
const val = payload.value;
|
||||
return !util.nullish(val) && val.length !== undefined;
|
||||
});
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.minimum = def.length;
|
||||
bag.maximum = def.length;
|
||||
bag.length = def.length;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
const input = payload.value;
|
||||
const length = input.length;
|
||||
if (length === def.length)
|
||||
return;
|
||||
const origin = util.getLengthableOrigin(input);
|
||||
const tooBig = length > def.length;
|
||||
payload.issues.push({
|
||||
origin,
|
||||
...(tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }),
|
||||
inclusive: true,
|
||||
exact: true,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckStringFormat = /*@__PURE__*/ core.$constructor("$ZodCheckStringFormat", (inst, def) => {
|
||||
var _a, _b;
|
||||
$ZodCheck.init(inst, def);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.format = def.format;
|
||||
if (def.pattern) {
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(def.pattern);
|
||||
}
|
||||
});
|
||||
if (def.pattern)
|
||||
(_a = inst._zod).check ?? (_a.check = (payload) => {
|
||||
def.pattern.lastIndex = 0;
|
||||
if (def.pattern.test(payload.value))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: def.format,
|
||||
input: payload.value,
|
||||
...(def.pattern ? { pattern: def.pattern.toString() } : {}),
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
});
|
||||
else
|
||||
(_b = inst._zod).check ?? (_b.check = () => { });
|
||||
});
|
||||
export const $ZodCheckRegex = /*@__PURE__*/ core.$constructor("$ZodCheckRegex", (inst, def) => {
|
||||
$ZodCheckStringFormat.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
def.pattern.lastIndex = 0;
|
||||
if (def.pattern.test(payload.value))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "regex",
|
||||
input: payload.value,
|
||||
pattern: def.pattern.toString(),
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckLowerCase = /*@__PURE__*/ core.$constructor("$ZodCheckLowerCase", (inst, def) => {
|
||||
def.pattern ?? (def.pattern = regexes.lowercase);
|
||||
$ZodCheckStringFormat.init(inst, def);
|
||||
});
|
||||
export const $ZodCheckUpperCase = /*@__PURE__*/ core.$constructor("$ZodCheckUpperCase", (inst, def) => {
|
||||
def.pattern ?? (def.pattern = regexes.uppercase);
|
||||
$ZodCheckStringFormat.init(inst, def);
|
||||
});
|
||||
export const $ZodCheckIncludes = /*@__PURE__*/ core.$constructor("$ZodCheckIncludes", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
const escapedRegex = util.escapeRegex(def.includes);
|
||||
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
|
||||
def.pattern = pattern;
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(pattern);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.includes(def.includes, def.position))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "includes",
|
||||
includes: def.includes,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckStartsWith = /*@__PURE__*/ core.$constructor("$ZodCheckStartsWith", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);
|
||||
def.pattern ?? (def.pattern = pattern);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(pattern);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.startsWith(def.prefix))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "starts_with",
|
||||
prefix: def.prefix,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckEndsWith = /*@__PURE__*/ core.$constructor("$ZodCheckEndsWith", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);
|
||||
def.pattern ?? (def.pattern = pattern);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
const bag = inst._zod.bag;
|
||||
bag.patterns ?? (bag.patterns = new Set());
|
||||
bag.patterns.add(pattern);
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.endsWith(def.suffix))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "ends_with",
|
||||
suffix: def.suffix,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
///////////////////////////////////
|
||||
///// $ZodCheckProperty /////
|
||||
///////////////////////////////////
|
||||
function handleCheckPropertyResult(result, payload, property) {
|
||||
if (result.issues.length) {
|
||||
payload.issues.push(...util.prefixIssues(property, result.issues));
|
||||
}
|
||||
}
|
||||
export const $ZodCheckProperty = /*@__PURE__*/ core.$constructor("$ZodCheckProperty", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
const result = def.schema._zod.run({
|
||||
value: payload.value[def.property],
|
||||
issues: [],
|
||||
}, {});
|
||||
if (result instanceof Promise) {
|
||||
return result.then((result) => handleCheckPropertyResult(result, payload, def.property));
|
||||
}
|
||||
handleCheckPropertyResult(result, payload, def.property);
|
||||
return;
|
||||
};
|
||||
});
|
||||
export const $ZodCheckMimeType = /*@__PURE__*/ core.$constructor("$ZodCheckMimeType", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
const mimeSet = new Set(def.mime);
|
||||
inst._zod.onattach.push((inst) => {
|
||||
inst._zod.bag.mime = def.mime;
|
||||
});
|
||||
inst._zod.check = (payload) => {
|
||||
if (mimeSet.has(payload.value.type))
|
||||
return;
|
||||
payload.issues.push({
|
||||
code: "invalid_value",
|
||||
values: def.mime,
|
||||
input: payload.value.type,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
export const $ZodCheckOverwrite = /*@__PURE__*/ core.$constructor("$ZodCheckOverwrite", (inst, def) => {
|
||||
$ZodCheck.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
payload.value = def.tx(payload.value);
|
||||
};
|
||||
});
|
||||
83
node_modules/zod/v4/core/core.cjs
generated
vendored
Normal file
83
node_modules/zod/v4/core/core.cjs
generated
vendored
Normal file
@@ -0,0 +1,83 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.globalConfig = exports.$ZodEncodeError = exports.$ZodAsyncError = exports.$brand = exports.NEVER = void 0;
|
||||
exports.$constructor = $constructor;
|
||||
exports.config = config;
|
||||
/** A special constant with type `never` */
|
||||
exports.NEVER = Object.freeze({
|
||||
status: "aborted",
|
||||
});
|
||||
function $constructor(name, initializer, params) {
|
||||
function init(inst, def) {
|
||||
if (!inst._zod) {
|
||||
Object.defineProperty(inst, "_zod", {
|
||||
value: {
|
||||
def,
|
||||
constr: _,
|
||||
traits: new Set(),
|
||||
},
|
||||
enumerable: false,
|
||||
});
|
||||
}
|
||||
if (inst._zod.traits.has(name)) {
|
||||
return;
|
||||
}
|
||||
inst._zod.traits.add(name);
|
||||
initializer(inst, def);
|
||||
// support prototype modifications
|
||||
const proto = _.prototype;
|
||||
const keys = Object.keys(proto);
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
const k = keys[i];
|
||||
if (!(k in inst)) {
|
||||
inst[k] = proto[k].bind(inst);
|
||||
}
|
||||
}
|
||||
}
|
||||
// doesn't work if Parent has a constructor with arguments
|
||||
const Parent = params?.Parent ?? Object;
|
||||
class Definition extends Parent {
|
||||
}
|
||||
Object.defineProperty(Definition, "name", { value: name });
|
||||
function _(def) {
|
||||
var _a;
|
||||
const inst = params?.Parent ? new Definition() : this;
|
||||
init(inst, def);
|
||||
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
||||
for (const fn of inst._zod.deferred) {
|
||||
fn();
|
||||
}
|
||||
return inst;
|
||||
}
|
||||
Object.defineProperty(_, "init", { value: init });
|
||||
Object.defineProperty(_, Symbol.hasInstance, {
|
||||
value: (inst) => {
|
||||
if (params?.Parent && inst instanceof params.Parent)
|
||||
return true;
|
||||
return inst?._zod?.traits?.has(name);
|
||||
},
|
||||
});
|
||||
Object.defineProperty(_, "name", { value: name });
|
||||
return _;
|
||||
}
|
||||
////////////////////////////// UTILITIES ///////////////////////////////////////
|
||||
exports.$brand = Symbol("zod_brand");
|
||||
class $ZodAsyncError extends Error {
|
||||
constructor() {
|
||||
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
||||
}
|
||||
}
|
||||
exports.$ZodAsyncError = $ZodAsyncError;
|
||||
class $ZodEncodeError extends Error {
|
||||
constructor(name) {
|
||||
super(`Encountered unidirectional transform during encode: ${name}`);
|
||||
this.name = "ZodEncodeError";
|
||||
}
|
||||
}
|
||||
exports.$ZodEncodeError = $ZodEncodeError;
|
||||
exports.globalConfig = {};
|
||||
function config(newConfig) {
|
||||
if (newConfig)
|
||||
Object.assign(exports.globalConfig, newConfig);
|
||||
return exports.globalConfig;
|
||||
}
|
||||
70
node_modules/zod/v4/core/core.d.cts
generated
vendored
Normal file
70
node_modules/zod/v4/core/core.d.cts
generated
vendored
Normal file
@@ -0,0 +1,70 @@
|
||||
import type * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import type { Class } from "./util.cjs";
|
||||
type ZodTrait = {
|
||||
_zod: {
|
||||
def: any;
|
||||
[k: string]: any;
|
||||
};
|
||||
};
|
||||
export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
|
||||
new (def: D): T;
|
||||
init(inst: T, def: D): asserts inst is T;
|
||||
}
|
||||
/** A special constant with type `never` */
|
||||
export declare const NEVER: never;
|
||||
export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
|
||||
Parent?: typeof Class;
|
||||
}): $constructor<T, D>;
|
||||
export declare const $brand: unique symbol;
|
||||
export type $brand<T extends string | number | symbol = string | number | symbol> = {
|
||||
[$brand]: {
|
||||
[k in T]: true;
|
||||
};
|
||||
};
|
||||
export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
} : Dir extends "in" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
};
|
||||
} : {
|
||||
_zod: {
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
});
|
||||
export type $ZodNarrow<T extends schemas.SomeType, Out> = T & {
|
||||
_zod: {
|
||||
output: Out;
|
||||
};
|
||||
};
|
||||
export declare class $ZodAsyncError extends Error {
|
||||
constructor();
|
||||
}
|
||||
export declare class $ZodEncodeError extends Error {
|
||||
constructor(name: string);
|
||||
}
|
||||
export type input<T> = T extends {
|
||||
_zod: {
|
||||
input: any;
|
||||
};
|
||||
} ? T["_zod"]["input"] : unknown;
|
||||
export type output<T> = T extends {
|
||||
_zod: {
|
||||
output: any;
|
||||
};
|
||||
} ? T["_zod"]["output"] : unknown;
|
||||
export type { output as infer };
|
||||
export interface $ZodConfig {
|
||||
/** Custom error map. Overrides `config().localeError`. */
|
||||
customError?: errors.$ZodErrorMap | undefined;
|
||||
/** Localized error map. Lowest priority. */
|
||||
localeError?: errors.$ZodErrorMap | undefined;
|
||||
/** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
|
||||
jitless?: boolean | undefined;
|
||||
}
|
||||
export declare const globalConfig: $ZodConfig;
|
||||
export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
|
||||
70
node_modules/zod/v4/core/core.d.ts
generated
vendored
Normal file
70
node_modules/zod/v4/core/core.d.ts
generated
vendored
Normal file
@@ -0,0 +1,70 @@
|
||||
import type * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import type { Class } from "./util.js";
|
||||
type ZodTrait = {
|
||||
_zod: {
|
||||
def: any;
|
||||
[k: string]: any;
|
||||
};
|
||||
};
|
||||
export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
|
||||
new (def: D): T;
|
||||
init(inst: T, def: D): asserts inst is T;
|
||||
}
|
||||
/** A special constant with type `never` */
|
||||
export declare const NEVER: never;
|
||||
export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
|
||||
Parent?: typeof Class;
|
||||
}): $constructor<T, D>;
|
||||
export declare const $brand: unique symbol;
|
||||
export type $brand<T extends string | number | symbol = string | number | symbol> = {
|
||||
[$brand]: {
|
||||
[k in T]: true;
|
||||
};
|
||||
};
|
||||
export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
} : Dir extends "in" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
};
|
||||
} : {
|
||||
_zod: {
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
});
|
||||
export type $ZodNarrow<T extends schemas.SomeType, Out> = T & {
|
||||
_zod: {
|
||||
output: Out;
|
||||
};
|
||||
};
|
||||
export declare class $ZodAsyncError extends Error {
|
||||
constructor();
|
||||
}
|
||||
export declare class $ZodEncodeError extends Error {
|
||||
constructor(name: string);
|
||||
}
|
||||
export type input<T> = T extends {
|
||||
_zod: {
|
||||
input: any;
|
||||
};
|
||||
} ? T["_zod"]["input"] : unknown;
|
||||
export type output<T> = T extends {
|
||||
_zod: {
|
||||
output: any;
|
||||
};
|
||||
} ? T["_zod"]["output"] : unknown;
|
||||
export type { output as infer };
|
||||
export interface $ZodConfig {
|
||||
/** Custom error map. Overrides `config().localeError`. */
|
||||
customError?: errors.$ZodErrorMap | undefined;
|
||||
/** Localized error map. Lowest priority. */
|
||||
localeError?: errors.$ZodErrorMap | undefined;
|
||||
/** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
|
||||
jitless?: boolean | undefined;
|
||||
}
|
||||
export declare const globalConfig: $ZodConfig;
|
||||
export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
|
||||
76
node_modules/zod/v4/core/core.js
generated
vendored
Normal file
76
node_modules/zod/v4/core/core.js
generated
vendored
Normal file
@@ -0,0 +1,76 @@
|
||||
/** A special constant with type `never` */
|
||||
export const NEVER = Object.freeze({
|
||||
status: "aborted",
|
||||
});
|
||||
export /*@__NO_SIDE_EFFECTS__*/ function $constructor(name, initializer, params) {
|
||||
function init(inst, def) {
|
||||
if (!inst._zod) {
|
||||
Object.defineProperty(inst, "_zod", {
|
||||
value: {
|
||||
def,
|
||||
constr: _,
|
||||
traits: new Set(),
|
||||
},
|
||||
enumerable: false,
|
||||
});
|
||||
}
|
||||
if (inst._zod.traits.has(name)) {
|
||||
return;
|
||||
}
|
||||
inst._zod.traits.add(name);
|
||||
initializer(inst, def);
|
||||
// support prototype modifications
|
||||
const proto = _.prototype;
|
||||
const keys = Object.keys(proto);
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
const k = keys[i];
|
||||
if (!(k in inst)) {
|
||||
inst[k] = proto[k].bind(inst);
|
||||
}
|
||||
}
|
||||
}
|
||||
// doesn't work if Parent has a constructor with arguments
|
||||
const Parent = params?.Parent ?? Object;
|
||||
class Definition extends Parent {
|
||||
}
|
||||
Object.defineProperty(Definition, "name", { value: name });
|
||||
function _(def) {
|
||||
var _a;
|
||||
const inst = params?.Parent ? new Definition() : this;
|
||||
init(inst, def);
|
||||
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
||||
for (const fn of inst._zod.deferred) {
|
||||
fn();
|
||||
}
|
||||
return inst;
|
||||
}
|
||||
Object.defineProperty(_, "init", { value: init });
|
||||
Object.defineProperty(_, Symbol.hasInstance, {
|
||||
value: (inst) => {
|
||||
if (params?.Parent && inst instanceof params.Parent)
|
||||
return true;
|
||||
return inst?._zod?.traits?.has(name);
|
||||
},
|
||||
});
|
||||
Object.defineProperty(_, "name", { value: name });
|
||||
return _;
|
||||
}
|
||||
////////////////////////////// UTILITIES ///////////////////////////////////////
|
||||
export const $brand = Symbol("zod_brand");
|
||||
export class $ZodAsyncError extends Error {
|
||||
constructor() {
|
||||
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
||||
}
|
||||
}
|
||||
export class $ZodEncodeError extends Error {
|
||||
constructor(name) {
|
||||
super(`Encountered unidirectional transform during encode: ${name}`);
|
||||
this.name = "ZodEncodeError";
|
||||
}
|
||||
}
|
||||
export const globalConfig = {};
|
||||
export function config(newConfig) {
|
||||
if (newConfig)
|
||||
Object.assign(globalConfig, newConfig);
|
||||
return globalConfig;
|
||||
}
|
||||
39
node_modules/zod/v4/core/doc.cjs
generated
vendored
Normal file
39
node_modules/zod/v4/core/doc.cjs
generated
vendored
Normal file
@@ -0,0 +1,39 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Doc = void 0;
|
||||
class Doc {
|
||||
constructor(args = []) {
|
||||
this.content = [];
|
||||
this.indent = 0;
|
||||
if (this)
|
||||
this.args = args;
|
||||
}
|
||||
indented(fn) {
|
||||
this.indent += 1;
|
||||
fn(this);
|
||||
this.indent -= 1;
|
||||
}
|
||||
write(arg) {
|
||||
if (typeof arg === "function") {
|
||||
arg(this, { execution: "sync" });
|
||||
arg(this, { execution: "async" });
|
||||
return;
|
||||
}
|
||||
const content = arg;
|
||||
const lines = content.split("\n").filter((x) => x);
|
||||
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
|
||||
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
|
||||
for (const line of dedented) {
|
||||
this.content.push(line);
|
||||
}
|
||||
}
|
||||
compile() {
|
||||
const F = Function;
|
||||
const args = this?.args;
|
||||
const content = this?.content ?? [``];
|
||||
const lines = [...content.map((x) => ` ${x}`)];
|
||||
// console.log(lines.join("\n"));
|
||||
return new F(...args, lines.join("\n"));
|
||||
}
|
||||
}
|
||||
exports.Doc = Doc;
|
||||
14
node_modules/zod/v4/core/doc.d.cts
generated
vendored
Normal file
14
node_modules/zod/v4/core/doc.d.cts
generated
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
type ModeWriter = (doc: Doc, modes: {
|
||||
execution: "sync" | "async";
|
||||
}) => void;
|
||||
export declare class Doc {
|
||||
args: string[];
|
||||
content: string[];
|
||||
indent: number;
|
||||
constructor(args?: string[]);
|
||||
indented(fn: (doc: Doc) => void): void;
|
||||
write(fn: ModeWriter): void;
|
||||
write(line: string): void;
|
||||
compile(): any;
|
||||
}
|
||||
export {};
|
||||
14
node_modules/zod/v4/core/doc.d.ts
generated
vendored
Normal file
14
node_modules/zod/v4/core/doc.d.ts
generated
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
type ModeWriter = (doc: Doc, modes: {
|
||||
execution: "sync" | "async";
|
||||
}) => void;
|
||||
export declare class Doc {
|
||||
args: string[];
|
||||
content: string[];
|
||||
indent: number;
|
||||
constructor(args?: string[]);
|
||||
indented(fn: (doc: Doc) => void): void;
|
||||
write(fn: ModeWriter): void;
|
||||
write(line: string): void;
|
||||
compile(): any;
|
||||
}
|
||||
export {};
|
||||
35
node_modules/zod/v4/core/doc.js
generated
vendored
Normal file
35
node_modules/zod/v4/core/doc.js
generated
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
export class Doc {
|
||||
constructor(args = []) {
|
||||
this.content = [];
|
||||
this.indent = 0;
|
||||
if (this)
|
||||
this.args = args;
|
||||
}
|
||||
indented(fn) {
|
||||
this.indent += 1;
|
||||
fn(this);
|
||||
this.indent -= 1;
|
||||
}
|
||||
write(arg) {
|
||||
if (typeof arg === "function") {
|
||||
arg(this, { execution: "sync" });
|
||||
arg(this, { execution: "async" });
|
||||
return;
|
||||
}
|
||||
const content = arg;
|
||||
const lines = content.split("\n").filter((x) => x);
|
||||
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
|
||||
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
|
||||
for (const line of dedented) {
|
||||
this.content.push(line);
|
||||
}
|
||||
}
|
||||
compile() {
|
||||
const F = Function;
|
||||
const args = this?.args;
|
||||
const content = this?.content ?? [``];
|
||||
const lines = [...content.map((x) => ` ${x}`)];
|
||||
// console.log(lines.join("\n"));
|
||||
return new F(...args, lines.join("\n"));
|
||||
}
|
||||
}
|
||||
213
node_modules/zod/v4/core/errors.cjs
generated
vendored
Normal file
213
node_modules/zod/v4/core/errors.cjs
generated
vendored
Normal file
@@ -0,0 +1,213 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.$ZodRealError = exports.$ZodError = void 0;
|
||||
exports.flattenError = flattenError;
|
||||
exports.formatError = formatError;
|
||||
exports.treeifyError = treeifyError;
|
||||
exports.toDotPath = toDotPath;
|
||||
exports.prettifyError = prettifyError;
|
||||
const core_js_1 = require("./core.cjs");
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
const initializer = (inst, def) => {
|
||||
inst.name = "$ZodError";
|
||||
Object.defineProperty(inst, "_zod", {
|
||||
value: inst._zod,
|
||||
enumerable: false,
|
||||
});
|
||||
Object.defineProperty(inst, "issues", {
|
||||
value: def,
|
||||
enumerable: false,
|
||||
});
|
||||
inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
|
||||
Object.defineProperty(inst, "toString", {
|
||||
value: () => inst.message,
|
||||
enumerable: false,
|
||||
});
|
||||
};
|
||||
exports.$ZodError = (0, core_js_1.$constructor)("$ZodError", initializer);
|
||||
exports.$ZodRealError = (0, core_js_1.$constructor)("$ZodError", initializer, { Parent: Error });
|
||||
function flattenError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = {};
|
||||
const formErrors = [];
|
||||
for (const sub of error.issues) {
|
||||
if (sub.path.length > 0) {
|
||||
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
|
||||
fieldErrors[sub.path[0]].push(mapper(sub));
|
||||
}
|
||||
else {
|
||||
formErrors.push(mapper(sub));
|
||||
}
|
||||
}
|
||||
return { formErrors, fieldErrors };
|
||||
}
|
||||
function formatError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = { _errors: [] };
|
||||
const processError = (error) => {
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
issue.errors.map((issues) => processError({ issues }));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues });
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues });
|
||||
}
|
||||
else if (issue.path.length === 0) {
|
||||
fieldErrors._errors.push(mapper(issue));
|
||||
}
|
||||
else {
|
||||
let curr = fieldErrors;
|
||||
let i = 0;
|
||||
while (i < issue.path.length) {
|
||||
const el = issue.path[i];
|
||||
const terminal = i === issue.path.length - 1;
|
||||
if (!terminal) {
|
||||
curr[el] = curr[el] || { _errors: [] };
|
||||
}
|
||||
else {
|
||||
curr[el] = curr[el] || { _errors: [] };
|
||||
curr[el]._errors.push(mapper(issue));
|
||||
}
|
||||
curr = curr[el];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return fieldErrors;
|
||||
}
|
||||
function treeifyError(error, mapper = (issue) => issue.message) {
|
||||
const result = { errors: [] };
|
||||
const processError = (error, path = []) => {
|
||||
var _a, _b;
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
// regular union error
|
||||
issue.errors.map((issues) => processError({ issues }, issue.path));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues }, issue.path);
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues }, issue.path);
|
||||
}
|
||||
else {
|
||||
const fullpath = [...path, ...issue.path];
|
||||
if (fullpath.length === 0) {
|
||||
result.errors.push(mapper(issue));
|
||||
continue;
|
||||
}
|
||||
let curr = result;
|
||||
let i = 0;
|
||||
while (i < fullpath.length) {
|
||||
const el = fullpath[i];
|
||||
const terminal = i === fullpath.length - 1;
|
||||
if (typeof el === "string") {
|
||||
curr.properties ?? (curr.properties = {});
|
||||
(_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
|
||||
curr = curr.properties[el];
|
||||
}
|
||||
else {
|
||||
curr.items ?? (curr.items = []);
|
||||
(_b = curr.items)[el] ?? (_b[el] = { errors: [] });
|
||||
curr = curr.items[el];
|
||||
}
|
||||
if (terminal) {
|
||||
curr.errors.push(mapper(issue));
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return result;
|
||||
}
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
function toDotPath(_path) {
|
||||
const segs = [];
|
||||
const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
|
||||
for (const seg of path) {
|
||||
if (typeof seg === "number")
|
||||
segs.push(`[${seg}]`);
|
||||
else if (typeof seg === "symbol")
|
||||
segs.push(`[${JSON.stringify(String(seg))}]`);
|
||||
else if (/[^\w$]/.test(seg))
|
||||
segs.push(`[${JSON.stringify(seg)}]`);
|
||||
else {
|
||||
if (segs.length)
|
||||
segs.push(".");
|
||||
segs.push(seg);
|
||||
}
|
||||
}
|
||||
return segs.join("");
|
||||
}
|
||||
function prettifyError(error) {
|
||||
const lines = [];
|
||||
// sort by path length
|
||||
const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
||||
// Process each issue
|
||||
for (const issue of issues) {
|
||||
lines.push(`✖ ${issue.message}`);
|
||||
if (issue.path?.length)
|
||||
lines.push(` → at ${toDotPath(issue.path)}`);
|
||||
}
|
||||
// Convert Map to formatted string
|
||||
return lines.join("\n");
|
||||
}
|
||||
220
node_modules/zod/v4/core/errors.d.cts
generated
vendored
Normal file
220
node_modules/zod/v4/core/errors.d.cts
generated
vendored
Normal file
@@ -0,0 +1,220 @@
|
||||
import type { $ZodCheck, $ZodStringFormats } from "./checks.cjs";
|
||||
import { $constructor } from "./core.cjs";
|
||||
import type { $ZodType } from "./schemas.cjs";
|
||||
import type { StandardSchemaV1 } from "./standard-schema.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export interface $ZodIssueBase {
|
||||
readonly code?: string;
|
||||
readonly input?: unknown;
|
||||
readonly path: PropertyKey[];
|
||||
readonly message: string;
|
||||
}
|
||||
export type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
|
||||
export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_type";
|
||||
readonly expected: $ZodInvalidTypeExpected;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_big";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly maximum: number | bigint;
|
||||
readonly inclusive?: boolean;
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_small";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly minimum: number | bigint;
|
||||
/** True if the allowable range includes the minimum */
|
||||
readonly inclusive?: boolean;
|
||||
/** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
|
||||
readonly code: "invalid_format";
|
||||
readonly format: $ZodStringFormats | (string & {});
|
||||
readonly pattern?: string;
|
||||
readonly input?: string;
|
||||
}
|
||||
export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
|
||||
readonly code: "not_multiple_of";
|
||||
readonly divisor: number;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
|
||||
readonly code: "unrecognized_keys";
|
||||
readonly keys: string[];
|
||||
readonly input?: Record<string, unknown>;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: $ZodIssue[][];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly inclusive?: true;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: [];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly inclusive: false;
|
||||
}
|
||||
export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
|
||||
export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_key";
|
||||
readonly origin: "map" | "record";
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_element";
|
||||
readonly origin: "map" | "set";
|
||||
readonly key: unknown;
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_value";
|
||||
readonly values: util.Primitive[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueCustom extends $ZodIssueBase {
|
||||
readonly code: "custom";
|
||||
readonly params?: Record<string, any> | undefined;
|
||||
readonly input?: unknown;
|
||||
}
|
||||
export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
|
||||
format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
|
||||
format: "regex";
|
||||
pattern: string;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
|
||||
format: "jwt";
|
||||
algorithm?: string;
|
||||
}
|
||||
export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "starts_with";
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "ends_with";
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
|
||||
format: "includes";
|
||||
includes: string;
|
||||
}
|
||||
export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
|
||||
export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
|
||||
export type $ZodIssueCode = $ZodIssue["code"];
|
||||
export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The input data */
|
||||
readonly input: unknown;
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: $ZodType | $ZodCheck;
|
||||
/** If `true`, Zod will continue executing checks/refinements after this issue. */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
|
||||
export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
|
||||
(issue: $ZodRawIssue<T>): {
|
||||
message: string;
|
||||
} | string | undefined | null;
|
||||
}
|
||||
export interface $ZodError<T = unknown> extends Error {
|
||||
type: T;
|
||||
issues: $ZodIssue[];
|
||||
_zod: {
|
||||
output: T;
|
||||
def: $ZodIssue[];
|
||||
};
|
||||
stack?: string;
|
||||
name: string;
|
||||
}
|
||||
export declare const $ZodError: $constructor<$ZodError>;
|
||||
interface $ZodRealError<T = any> extends $ZodError<T> {
|
||||
}
|
||||
export declare const $ZodRealError: $constructor<$ZodRealError>;
|
||||
export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
|
||||
type _FlattenedError<T, U = string> = {
|
||||
formErrors: U[];
|
||||
fieldErrors: {
|
||||
[P in keyof T]?: U[];
|
||||
};
|
||||
};
|
||||
export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
|
||||
export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
|
||||
type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
} : T extends any[] ? {
|
||||
[k: number]: $ZodFormattedError<T[number], U>;
|
||||
} : T extends object ? util.Flatten<{
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
}> : any;
|
||||
export type $ZodFormattedError<T, U = string> = {
|
||||
_errors: U[];
|
||||
} & util.Flatten<_ZodFormattedError<T, U>>;
|
||||
export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
|
||||
export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
|
||||
export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
|
||||
errors: U[];
|
||||
} : T extends [any, ...any[]] ? {
|
||||
errors: U[];
|
||||
items?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : T extends any[] ? {
|
||||
errors: U[];
|
||||
items?: Array<$ZodErrorTree<T[number], U>>;
|
||||
} : T extends object ? {
|
||||
errors: U[];
|
||||
properties?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : {
|
||||
errors: U[];
|
||||
};
|
||||
export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
|
||||
export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
|
||||
export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
|
||||
export {};
|
||||
220
node_modules/zod/v4/core/errors.d.ts
generated
vendored
Normal file
220
node_modules/zod/v4/core/errors.d.ts
generated
vendored
Normal file
@@ -0,0 +1,220 @@
|
||||
import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
|
||||
import { $constructor } from "./core.js";
|
||||
import type { $ZodType } from "./schemas.js";
|
||||
import type { StandardSchemaV1 } from "./standard-schema.js";
|
||||
import * as util from "./util.js";
|
||||
export interface $ZodIssueBase {
|
||||
readonly code?: string;
|
||||
readonly input?: unknown;
|
||||
readonly path: PropertyKey[];
|
||||
readonly message: string;
|
||||
}
|
||||
export type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
|
||||
export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_type";
|
||||
readonly expected: $ZodInvalidTypeExpected;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_big";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly maximum: number | bigint;
|
||||
readonly inclusive?: boolean;
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_small";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly minimum: number | bigint;
|
||||
/** True if the allowable range includes the minimum */
|
||||
readonly inclusive?: boolean;
|
||||
/** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
|
||||
readonly code: "invalid_format";
|
||||
readonly format: $ZodStringFormats | (string & {});
|
||||
readonly pattern?: string;
|
||||
readonly input?: string;
|
||||
}
|
||||
export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
|
||||
readonly code: "not_multiple_of";
|
||||
readonly divisor: number;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
|
||||
readonly code: "unrecognized_keys";
|
||||
readonly keys: string[];
|
||||
readonly input?: Record<string, unknown>;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: $ZodIssue[][];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly inclusive?: true;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: [];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly inclusive: false;
|
||||
}
|
||||
export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
|
||||
export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_key";
|
||||
readonly origin: "map" | "record";
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_element";
|
||||
readonly origin: "map" | "set";
|
||||
readonly key: unknown;
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_value";
|
||||
readonly values: util.Primitive[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueCustom extends $ZodIssueBase {
|
||||
readonly code: "custom";
|
||||
readonly params?: Record<string, any> | undefined;
|
||||
readonly input?: unknown;
|
||||
}
|
||||
export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
|
||||
format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
|
||||
format: "regex";
|
||||
pattern: string;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
|
||||
format: "jwt";
|
||||
algorithm?: string;
|
||||
}
|
||||
export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "starts_with";
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "ends_with";
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
|
||||
format: "includes";
|
||||
includes: string;
|
||||
}
|
||||
export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
|
||||
export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
|
||||
export type $ZodIssueCode = $ZodIssue["code"];
|
||||
export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The input data */
|
||||
readonly input: unknown;
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: $ZodType | $ZodCheck;
|
||||
/** If `true`, Zod will continue executing checks/refinements after this issue. */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
|
||||
export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
|
||||
(issue: $ZodRawIssue<T>): {
|
||||
message: string;
|
||||
} | string | undefined | null;
|
||||
}
|
||||
export interface $ZodError<T = unknown> extends Error {
|
||||
type: T;
|
||||
issues: $ZodIssue[];
|
||||
_zod: {
|
||||
output: T;
|
||||
def: $ZodIssue[];
|
||||
};
|
||||
stack?: string;
|
||||
name: string;
|
||||
}
|
||||
export declare const $ZodError: $constructor<$ZodError>;
|
||||
interface $ZodRealError<T = any> extends $ZodError<T> {
|
||||
}
|
||||
export declare const $ZodRealError: $constructor<$ZodRealError>;
|
||||
export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
|
||||
type _FlattenedError<T, U = string> = {
|
||||
formErrors: U[];
|
||||
fieldErrors: {
|
||||
[P in keyof T]?: U[];
|
||||
};
|
||||
};
|
||||
export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
|
||||
export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
|
||||
type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
} : T extends any[] ? {
|
||||
[k: number]: $ZodFormattedError<T[number], U>;
|
||||
} : T extends object ? util.Flatten<{
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
}> : any;
|
||||
export type $ZodFormattedError<T, U = string> = {
|
||||
_errors: U[];
|
||||
} & util.Flatten<_ZodFormattedError<T, U>>;
|
||||
export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
|
||||
export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
|
||||
export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
|
||||
errors: U[];
|
||||
} : T extends [any, ...any[]] ? {
|
||||
errors: U[];
|
||||
items?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : T extends any[] ? {
|
||||
errors: U[];
|
||||
items?: Array<$ZodErrorTree<T[number], U>>;
|
||||
} : T extends object ? {
|
||||
errors: U[];
|
||||
properties?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : {
|
||||
errors: U[];
|
||||
};
|
||||
export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
|
||||
export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
|
||||
export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
|
||||
export {};
|
||||
182
node_modules/zod/v4/core/errors.js
generated
vendored
Normal file
182
node_modules/zod/v4/core/errors.js
generated
vendored
Normal file
@@ -0,0 +1,182 @@
|
||||
import { $constructor } from "./core.js";
|
||||
import * as util from "./util.js";
|
||||
const initializer = (inst, def) => {
|
||||
inst.name = "$ZodError";
|
||||
Object.defineProperty(inst, "_zod", {
|
||||
value: inst._zod,
|
||||
enumerable: false,
|
||||
});
|
||||
Object.defineProperty(inst, "issues", {
|
||||
value: def,
|
||||
enumerable: false,
|
||||
});
|
||||
inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
|
||||
Object.defineProperty(inst, "toString", {
|
||||
value: () => inst.message,
|
||||
enumerable: false,
|
||||
});
|
||||
};
|
||||
export const $ZodError = $constructor("$ZodError", initializer);
|
||||
export const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
|
||||
export function flattenError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = {};
|
||||
const formErrors = [];
|
||||
for (const sub of error.issues) {
|
||||
if (sub.path.length > 0) {
|
||||
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
|
||||
fieldErrors[sub.path[0]].push(mapper(sub));
|
||||
}
|
||||
else {
|
||||
formErrors.push(mapper(sub));
|
||||
}
|
||||
}
|
||||
return { formErrors, fieldErrors };
|
||||
}
|
||||
export function formatError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = { _errors: [] };
|
||||
const processError = (error) => {
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
issue.errors.map((issues) => processError({ issues }));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues });
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues });
|
||||
}
|
||||
else if (issue.path.length === 0) {
|
||||
fieldErrors._errors.push(mapper(issue));
|
||||
}
|
||||
else {
|
||||
let curr = fieldErrors;
|
||||
let i = 0;
|
||||
while (i < issue.path.length) {
|
||||
const el = issue.path[i];
|
||||
const terminal = i === issue.path.length - 1;
|
||||
if (!terminal) {
|
||||
curr[el] = curr[el] || { _errors: [] };
|
||||
}
|
||||
else {
|
||||
curr[el] = curr[el] || { _errors: [] };
|
||||
curr[el]._errors.push(mapper(issue));
|
||||
}
|
||||
curr = curr[el];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return fieldErrors;
|
||||
}
|
||||
export function treeifyError(error, mapper = (issue) => issue.message) {
|
||||
const result = { errors: [] };
|
||||
const processError = (error, path = []) => {
|
||||
var _a, _b;
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
// regular union error
|
||||
issue.errors.map((issues) => processError({ issues }, issue.path));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues }, issue.path);
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues }, issue.path);
|
||||
}
|
||||
else {
|
||||
const fullpath = [...path, ...issue.path];
|
||||
if (fullpath.length === 0) {
|
||||
result.errors.push(mapper(issue));
|
||||
continue;
|
||||
}
|
||||
let curr = result;
|
||||
let i = 0;
|
||||
while (i < fullpath.length) {
|
||||
const el = fullpath[i];
|
||||
const terminal = i === fullpath.length - 1;
|
||||
if (typeof el === "string") {
|
||||
curr.properties ?? (curr.properties = {});
|
||||
(_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
|
||||
curr = curr.properties[el];
|
||||
}
|
||||
else {
|
||||
curr.items ?? (curr.items = []);
|
||||
(_b = curr.items)[el] ?? (_b[el] = { errors: [] });
|
||||
curr = curr.items[el];
|
||||
}
|
||||
if (terminal) {
|
||||
curr.errors.push(mapper(issue));
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return result;
|
||||
}
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
export function toDotPath(_path) {
|
||||
const segs = [];
|
||||
const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
|
||||
for (const seg of path) {
|
||||
if (typeof seg === "number")
|
||||
segs.push(`[${seg}]`);
|
||||
else if (typeof seg === "symbol")
|
||||
segs.push(`[${JSON.stringify(String(seg))}]`);
|
||||
else if (/[^\w$]/.test(seg))
|
||||
segs.push(`[${JSON.stringify(seg)}]`);
|
||||
else {
|
||||
if (segs.length)
|
||||
segs.push(".");
|
||||
segs.push(seg);
|
||||
}
|
||||
}
|
||||
return segs.join("");
|
||||
}
|
||||
export function prettifyError(error) {
|
||||
const lines = [];
|
||||
// sort by path length
|
||||
const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
||||
// Process each issue
|
||||
for (const issue of issues) {
|
||||
lines.push(`✖ ${issue.message}`);
|
||||
if (issue.path?.length)
|
||||
lines.push(` → at ${toDotPath(issue.path)}`);
|
||||
}
|
||||
// Convert Map to formatted string
|
||||
return lines.join("\n");
|
||||
}
|
||||
47
node_modules/zod/v4/core/index.cjs
generated
vendored
Normal file
47
node_modules/zod/v4/core/index.cjs
generated
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
||||
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
||||
};
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.JSONSchema = exports.JSONSchemaGenerator = exports.toJSONSchema = exports.locales = exports.regexes = exports.util = void 0;
|
||||
__exportStar(require("./core.cjs"), exports);
|
||||
__exportStar(require("./parse.cjs"), exports);
|
||||
__exportStar(require("./errors.cjs"), exports);
|
||||
__exportStar(require("./schemas.cjs"), exports);
|
||||
__exportStar(require("./checks.cjs"), exports);
|
||||
__exportStar(require("./versions.cjs"), exports);
|
||||
exports.util = __importStar(require("./util.cjs"));
|
||||
exports.regexes = __importStar(require("./regexes.cjs"));
|
||||
exports.locales = __importStar(require("../locales/index.cjs"));
|
||||
__exportStar(require("./registries.cjs"), exports);
|
||||
__exportStar(require("./doc.cjs"), exports);
|
||||
__exportStar(require("./api.cjs"), exports);
|
||||
__exportStar(require("./to-json-schema.cjs"), exports);
|
||||
var json_schema_processors_js_1 = require("./json-schema-processors.cjs");
|
||||
Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return json_schema_processors_js_1.toJSONSchema; } });
|
||||
var json_schema_generator_js_1 = require("./json-schema-generator.cjs");
|
||||
Object.defineProperty(exports, "JSONSchemaGenerator", { enumerable: true, get: function () { return json_schema_generator_js_1.JSONSchemaGenerator; } });
|
||||
exports.JSONSchema = __importStar(require("./json-schema.cjs"));
|
||||
16
node_modules/zod/v4/core/index.d.cts
generated
vendored
Normal file
16
node_modules/zod/v4/core/index.d.cts
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
export * from "./core.cjs";
|
||||
export * from "./parse.cjs";
|
||||
export * from "./errors.cjs";
|
||||
export * from "./schemas.cjs";
|
||||
export * from "./checks.cjs";
|
||||
export * from "./versions.cjs";
|
||||
export * as util from "./util.cjs";
|
||||
export * as regexes from "./regexes.cjs";
|
||||
export * as locales from "../locales/index.cjs";
|
||||
export * from "./registries.cjs";
|
||||
export * from "./doc.cjs";
|
||||
export * from "./api.cjs";
|
||||
export * from "./to-json-schema.cjs";
|
||||
export { toJSONSchema } from "./json-schema-processors.cjs";
|
||||
export { JSONSchemaGenerator } from "./json-schema-generator.cjs";
|
||||
export * as JSONSchema from "./json-schema.cjs";
|
||||
16
node_modules/zod/v4/core/index.d.ts
generated
vendored
Normal file
16
node_modules/zod/v4/core/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
export * from "./core.js";
|
||||
export * from "./parse.js";
|
||||
export * from "./errors.js";
|
||||
export * from "./schemas.js";
|
||||
export * from "./checks.js";
|
||||
export * from "./versions.js";
|
||||
export * as util from "./util.js";
|
||||
export * as regexes from "./regexes.js";
|
||||
export * as locales from "../locales/index.js";
|
||||
export * from "./registries.js";
|
||||
export * from "./doc.js";
|
||||
export * from "./api.js";
|
||||
export * from "./to-json-schema.js";
|
||||
export { toJSONSchema } from "./json-schema-processors.js";
|
||||
export { JSONSchemaGenerator } from "./json-schema-generator.js";
|
||||
export * as JSONSchema from "./json-schema.js";
|
||||
16
node_modules/zod/v4/core/index.js
generated
vendored
Normal file
16
node_modules/zod/v4/core/index.js
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
export * from "./core.js";
|
||||
export * from "./parse.js";
|
||||
export * from "./errors.js";
|
||||
export * from "./schemas.js";
|
||||
export * from "./checks.js";
|
||||
export * from "./versions.js";
|
||||
export * as util from "./util.js";
|
||||
export * as regexes from "./regexes.js";
|
||||
export * as locales from "../locales/index.js";
|
||||
export * from "./registries.js";
|
||||
export * from "./doc.js";
|
||||
export * from "./api.js";
|
||||
export * from "./to-json-schema.js";
|
||||
export { toJSONSchema } from "./json-schema-processors.js";
|
||||
export { JSONSchemaGenerator } from "./json-schema-generator.js";
|
||||
export * as JSONSchema from "./json-schema.js";
|
||||
99
node_modules/zod/v4/core/json-schema-generator.cjs
generated
vendored
Normal file
99
node_modules/zod/v4/core/json-schema-generator.cjs
generated
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.JSONSchemaGenerator = void 0;
|
||||
const json_schema_processors_js_1 = require("./json-schema-processors.cjs");
|
||||
const to_json_schema_js_1 = require("./to-json-schema.cjs");
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
class JSONSchemaGenerator {
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry() {
|
||||
return this.ctx.metadataRegistry;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target() {
|
||||
return this.ctx.target;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable() {
|
||||
return this.ctx.unrepresentable;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override() {
|
||||
return this.ctx.override;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io() {
|
||||
return this.ctx.io;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter() {
|
||||
return this.ctx.counter;
|
||||
}
|
||||
set counter(value) {
|
||||
this.ctx.counter = value;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen() {
|
||||
return this.ctx.seen;
|
||||
}
|
||||
constructor(params) {
|
||||
// Normalize target for internal context
|
||||
let normalizedTarget = params?.target ?? "draft-2020-12";
|
||||
if (normalizedTarget === "draft-4")
|
||||
normalizedTarget = "draft-04";
|
||||
if (normalizedTarget === "draft-7")
|
||||
normalizedTarget = "draft-07";
|
||||
this.ctx = (0, to_json_schema_js_1.initializeContext)({
|
||||
processors: json_schema_processors_js_1.allProcessors,
|
||||
target: normalizedTarget,
|
||||
...(params?.metadata && { metadata: params.metadata }),
|
||||
...(params?.unrepresentable && { unrepresentable: params.unrepresentable }),
|
||||
...(params?.override && { override: params.override }),
|
||||
...(params?.io && { io: params.io }),
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema, _params = { path: [], schemaPath: [] }) {
|
||||
return (0, to_json_schema_js_1.process)(schema, this.ctx, _params);
|
||||
}
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema, _params) {
|
||||
// Apply emit params to the context
|
||||
if (_params) {
|
||||
if (_params.cycles)
|
||||
this.ctx.cycles = _params.cycles;
|
||||
if (_params.reused)
|
||||
this.ctx.reused = _params.reused;
|
||||
if (_params.external)
|
||||
this.ctx.external = _params.external;
|
||||
}
|
||||
(0, to_json_schema_js_1.extractDefs)(this.ctx, schema);
|
||||
const result = (0, to_json_schema_js_1.finalize)(this.ctx, schema);
|
||||
// Strip ~standard property to match old implementation's return type
|
||||
const { "~standard": _, ...plainResult } = result;
|
||||
return plainResult;
|
||||
}
|
||||
}
|
||||
exports.JSONSchemaGenerator = JSONSchemaGenerator;
|
||||
65
node_modules/zod/v4/core/json-schema-generator.d.cts
generated
vendored
Normal file
65
node_modules/zod/v4/core/json-schema-generator.d.cts
generated
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
import type * as JSONSchema from "./json-schema.cjs";
|
||||
import type { $ZodRegistry } from "./registries.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen } from "./to-json-schema.cjs";
|
||||
/**
|
||||
* Parameters for the emit method of JSONSchemaGenerator.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
|
||||
/**
|
||||
* Parameters for JSONSchemaGenerator constructor.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
export declare class JSONSchemaGenerator {
|
||||
private ctx;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry(): $ZodRegistry<Record<string, any>>;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable(): "any" | "throw";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override(): (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io(): "input" | "output";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter(): number;
|
||||
set counter(value: number);
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen(): Map<schemas.$ZodType, Seen>;
|
||||
constructor(params?: JSONSchemaGeneratorConstructorParams);
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
|
||||
}
|
||||
export {};
|
||||
65
node_modules/zod/v4/core/json-schema-generator.d.ts
generated
vendored
Normal file
65
node_modules/zod/v4/core/json-schema-generator.d.ts
generated
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
import type * as JSONSchema from "./json-schema.js";
|
||||
import type { $ZodRegistry } from "./registries.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen } from "./to-json-schema.js";
|
||||
/**
|
||||
* Parameters for the emit method of JSONSchemaGenerator.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
|
||||
/**
|
||||
* Parameters for JSONSchemaGenerator constructor.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
export declare class JSONSchemaGenerator {
|
||||
private ctx;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry(): $ZodRegistry<Record<string, any>>;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable(): "any" | "throw";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override(): (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io(): "input" | "output";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter(): number;
|
||||
set counter(value: number);
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen(): Map<schemas.$ZodType, Seen>;
|
||||
constructor(params?: JSONSchemaGeneratorConstructorParams);
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
|
||||
}
|
||||
export {};
|
||||
95
node_modules/zod/v4/core/json-schema-generator.js
generated
vendored
Normal file
95
node_modules/zod/v4/core/json-schema-generator.js
generated
vendored
Normal file
@@ -0,0 +1,95 @@
|
||||
import { allProcessors } from "./json-schema-processors.js";
|
||||
import { extractDefs, finalize, initializeContext, process, } from "./to-json-schema.js";
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
export class JSONSchemaGenerator {
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry() {
|
||||
return this.ctx.metadataRegistry;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target() {
|
||||
return this.ctx.target;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable() {
|
||||
return this.ctx.unrepresentable;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override() {
|
||||
return this.ctx.override;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io() {
|
||||
return this.ctx.io;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter() {
|
||||
return this.ctx.counter;
|
||||
}
|
||||
set counter(value) {
|
||||
this.ctx.counter = value;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen() {
|
||||
return this.ctx.seen;
|
||||
}
|
||||
constructor(params) {
|
||||
// Normalize target for internal context
|
||||
let normalizedTarget = params?.target ?? "draft-2020-12";
|
||||
if (normalizedTarget === "draft-4")
|
||||
normalizedTarget = "draft-04";
|
||||
if (normalizedTarget === "draft-7")
|
||||
normalizedTarget = "draft-07";
|
||||
this.ctx = initializeContext({
|
||||
processors: allProcessors,
|
||||
target: normalizedTarget,
|
||||
...(params?.metadata && { metadata: params.metadata }),
|
||||
...(params?.unrepresentable && { unrepresentable: params.unrepresentable }),
|
||||
...(params?.override && { override: params.override }),
|
||||
...(params?.io && { io: params.io }),
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema, _params = { path: [], schemaPath: [] }) {
|
||||
return process(schema, this.ctx, _params);
|
||||
}
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema, _params) {
|
||||
// Apply emit params to the context
|
||||
if (_params) {
|
||||
if (_params.cycles)
|
||||
this.ctx.cycles = _params.cycles;
|
||||
if (_params.reused)
|
||||
this.ctx.reused = _params.reused;
|
||||
if (_params.external)
|
||||
this.ctx.external = _params.external;
|
||||
}
|
||||
extractDefs(this.ctx, schema);
|
||||
const result = finalize(this.ctx, schema);
|
||||
// Strip ~standard property to match old implementation's return type
|
||||
const { "~standard": _, ...plainResult } = result;
|
||||
return plainResult;
|
||||
}
|
||||
}
|
||||
648
node_modules/zod/v4/core/json-schema-processors.cjs
generated
vendored
Normal file
648
node_modules/zod/v4/core/json-schema-processors.cjs
generated
vendored
Normal file
@@ -0,0 +1,648 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.allProcessors = exports.lazyProcessor = exports.optionalProcessor = exports.promiseProcessor = exports.readonlyProcessor = exports.pipeProcessor = exports.catchProcessor = exports.prefaultProcessor = exports.defaultProcessor = exports.nonoptionalProcessor = exports.nullableProcessor = exports.recordProcessor = exports.tupleProcessor = exports.intersectionProcessor = exports.unionProcessor = exports.objectProcessor = exports.arrayProcessor = exports.setProcessor = exports.mapProcessor = exports.transformProcessor = exports.functionProcessor = exports.customProcessor = exports.successProcessor = exports.fileProcessor = exports.templateLiteralProcessor = exports.nanProcessor = exports.literalProcessor = exports.enumProcessor = exports.dateProcessor = exports.unknownProcessor = exports.anyProcessor = exports.neverProcessor = exports.voidProcessor = exports.undefinedProcessor = exports.nullProcessor = exports.symbolProcessor = exports.bigintProcessor = exports.booleanProcessor = exports.numberProcessor = exports.stringProcessor = void 0;
|
||||
exports.toJSONSchema = toJSONSchema;
|
||||
const to_json_schema_js_1 = require("./to-json-schema.cjs");
|
||||
const util_js_1 = require("./util.cjs");
|
||||
const formatMap = {
|
||||
guid: "uuid",
|
||||
url: "uri",
|
||||
datetime: "date-time",
|
||||
json_string: "json-string",
|
||||
regex: "", // do not set
|
||||
};
|
||||
// ==================== SIMPLE TYPE PROCESSORS ====================
|
||||
const stringProcessor = (schema, ctx, _json, _params) => {
|
||||
const json = _json;
|
||||
json.type = "string";
|
||||
const { minimum, maximum, format, patterns, contentEncoding } = schema._zod
|
||||
.bag;
|
||||
if (typeof minimum === "number")
|
||||
json.minLength = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxLength = maximum;
|
||||
// custom pattern overrides format
|
||||
if (format) {
|
||||
json.format = formatMap[format] ?? format;
|
||||
if (json.format === "")
|
||||
delete json.format; // empty format is not valid
|
||||
// JSON Schema format: "time" requires a full time with offset or Z
|
||||
// z.iso.time() does not include timezone information, so format: "time" should never be used
|
||||
if (format === "time") {
|
||||
delete json.format;
|
||||
}
|
||||
}
|
||||
if (contentEncoding)
|
||||
json.contentEncoding = contentEncoding;
|
||||
if (patterns && patterns.size > 0) {
|
||||
const regexes = [...patterns];
|
||||
if (regexes.length === 1)
|
||||
json.pattern = regexes[0].source;
|
||||
else if (regexes.length > 1) {
|
||||
json.allOf = [
|
||||
...regexes.map((regex) => ({
|
||||
...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
|
||||
? { type: "string" }
|
||||
: {}),
|
||||
pattern: regex.source,
|
||||
})),
|
||||
];
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.stringProcessor = stringProcessor;
|
||||
const numberProcessor = (schema, ctx, _json, _params) => {
|
||||
const json = _json;
|
||||
const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
|
||||
if (typeof format === "string" && format.includes("int"))
|
||||
json.type = "integer";
|
||||
else
|
||||
json.type = "number";
|
||||
if (typeof exclusiveMinimum === "number") {
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.minimum = exclusiveMinimum;
|
||||
json.exclusiveMinimum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMinimum = exclusiveMinimum;
|
||||
}
|
||||
}
|
||||
if (typeof minimum === "number") {
|
||||
json.minimum = minimum;
|
||||
if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
|
||||
if (exclusiveMinimum >= minimum)
|
||||
delete json.minimum;
|
||||
else
|
||||
delete json.exclusiveMinimum;
|
||||
}
|
||||
}
|
||||
if (typeof exclusiveMaximum === "number") {
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.maximum = exclusiveMaximum;
|
||||
json.exclusiveMaximum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMaximum = exclusiveMaximum;
|
||||
}
|
||||
}
|
||||
if (typeof maximum === "number") {
|
||||
json.maximum = maximum;
|
||||
if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
|
||||
if (exclusiveMaximum <= maximum)
|
||||
delete json.maximum;
|
||||
else
|
||||
delete json.exclusiveMaximum;
|
||||
}
|
||||
}
|
||||
if (typeof multipleOf === "number")
|
||||
json.multipleOf = multipleOf;
|
||||
};
|
||||
exports.numberProcessor = numberProcessor;
|
||||
const booleanProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
exports.booleanProcessor = booleanProcessor;
|
||||
const bigintProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("BigInt cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.bigintProcessor = bigintProcessor;
|
||||
const symbolProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Symbols cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.symbolProcessor = symbolProcessor;
|
||||
const nullProcessor = (_schema, ctx, json, _params) => {
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
json.type = "string";
|
||||
json.nullable = true;
|
||||
json.enum = [null];
|
||||
}
|
||||
else {
|
||||
json.type = "null";
|
||||
}
|
||||
};
|
||||
exports.nullProcessor = nullProcessor;
|
||||
const undefinedProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Undefined cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.undefinedProcessor = undefinedProcessor;
|
||||
const voidProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Void cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.voidProcessor = voidProcessor;
|
||||
const neverProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.not = {};
|
||||
};
|
||||
exports.neverProcessor = neverProcessor;
|
||||
const anyProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
exports.anyProcessor = anyProcessor;
|
||||
const unknownProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
exports.unknownProcessor = unknownProcessor;
|
||||
const dateProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Date cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.dateProcessor = dateProcessor;
|
||||
const enumProcessor = (schema, _ctx, json, _params) => {
|
||||
const def = schema._zod.def;
|
||||
const values = (0, util_js_1.getEnumValues)(def.entries);
|
||||
// Number enums can have both string and number values
|
||||
if (values.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (values.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
json.enum = values;
|
||||
};
|
||||
exports.enumProcessor = enumProcessor;
|
||||
const literalProcessor = (schema, ctx, json, _params) => {
|
||||
const def = schema._zod.def;
|
||||
const vals = [];
|
||||
for (const val of def.values) {
|
||||
if (val === undefined) {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Literal `undefined` cannot be represented in JSON Schema");
|
||||
}
|
||||
else {
|
||||
// do not add to vals
|
||||
}
|
||||
}
|
||||
else if (typeof val === "bigint") {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("BigInt literals cannot be represented in JSON Schema");
|
||||
}
|
||||
else {
|
||||
vals.push(Number(val));
|
||||
}
|
||||
}
|
||||
else {
|
||||
vals.push(val);
|
||||
}
|
||||
}
|
||||
if (vals.length === 0) {
|
||||
// do nothing (an undefined literal was stripped)
|
||||
}
|
||||
else if (vals.length === 1) {
|
||||
const val = vals[0];
|
||||
json.type = val === null ? "null" : typeof val;
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.enum = [val];
|
||||
}
|
||||
else {
|
||||
json.const = val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (vals.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (vals.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
if (vals.every((v) => typeof v === "boolean"))
|
||||
json.type = "boolean";
|
||||
if (vals.every((v) => v === null))
|
||||
json.type = "null";
|
||||
json.enum = vals;
|
||||
}
|
||||
};
|
||||
exports.literalProcessor = literalProcessor;
|
||||
const nanProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("NaN cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.nanProcessor = nanProcessor;
|
||||
const templateLiteralProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
const pattern = schema._zod.pattern;
|
||||
if (!pattern)
|
||||
throw new Error("Pattern not found in template literal");
|
||||
_json.type = "string";
|
||||
_json.pattern = pattern.source;
|
||||
};
|
||||
exports.templateLiteralProcessor = templateLiteralProcessor;
|
||||
const fileProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
const file = {
|
||||
type: "string",
|
||||
format: "binary",
|
||||
contentEncoding: "binary",
|
||||
};
|
||||
const { minimum, maximum, mime } = schema._zod.bag;
|
||||
if (minimum !== undefined)
|
||||
file.minLength = minimum;
|
||||
if (maximum !== undefined)
|
||||
file.maxLength = maximum;
|
||||
if (mime) {
|
||||
if (mime.length === 1) {
|
||||
file.contentMediaType = mime[0];
|
||||
Object.assign(_json, file);
|
||||
}
|
||||
else {
|
||||
Object.assign(_json, file); // shared props at root
|
||||
_json.anyOf = mime.map((m) => ({ contentMediaType: m })); // only contentMediaType differs
|
||||
}
|
||||
}
|
||||
else {
|
||||
Object.assign(_json, file);
|
||||
}
|
||||
};
|
||||
exports.fileProcessor = fileProcessor;
|
||||
const successProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
exports.successProcessor = successProcessor;
|
||||
const customProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Custom types cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.customProcessor = customProcessor;
|
||||
const functionProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Function types cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.functionProcessor = functionProcessor;
|
||||
const transformProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Transforms cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.transformProcessor = transformProcessor;
|
||||
const mapProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Map cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.mapProcessor = mapProcessor;
|
||||
const setProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Set cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
exports.setProcessor = setProcessor;
|
||||
// ==================== COMPOSITE TYPE PROCESSORS ====================
|
||||
const arrayProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
const { minimum, maximum } = schema._zod.bag;
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
json.type = "array";
|
||||
json.items = (0, to_json_schema_js_1.process)(def.element, ctx, { ...params, path: [...params.path, "items"] });
|
||||
};
|
||||
exports.arrayProcessor = arrayProcessor;
|
||||
const objectProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "object";
|
||||
json.properties = {};
|
||||
const shape = def.shape;
|
||||
for (const key in shape) {
|
||||
json.properties[key] = (0, to_json_schema_js_1.process)(shape[key], ctx, {
|
||||
...params,
|
||||
path: [...params.path, "properties", key],
|
||||
});
|
||||
}
|
||||
// required keys
|
||||
const allKeys = new Set(Object.keys(shape));
|
||||
const requiredKeys = new Set([...allKeys].filter((key) => {
|
||||
const v = def.shape[key]._zod;
|
||||
if (ctx.io === "input") {
|
||||
return v.optin === undefined;
|
||||
}
|
||||
else {
|
||||
return v.optout === undefined;
|
||||
}
|
||||
}));
|
||||
if (requiredKeys.size > 0) {
|
||||
json.required = Array.from(requiredKeys);
|
||||
}
|
||||
// catchall
|
||||
if (def.catchall?._zod.def.type === "never") {
|
||||
// strict
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (!def.catchall) {
|
||||
// regular
|
||||
if (ctx.io === "output")
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (def.catchall) {
|
||||
json.additionalProperties = (0, to_json_schema_js_1.process)(def.catchall, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
};
|
||||
exports.objectProcessor = objectProcessor;
|
||||
const unionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
// Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
|
||||
// This includes both z.xor() and discriminated unions
|
||||
const isExclusive = def.inclusive === false;
|
||||
const options = def.options.map((x, i) => (0, to_json_schema_js_1.process)(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
|
||||
}));
|
||||
if (isExclusive) {
|
||||
json.oneOf = options;
|
||||
}
|
||||
else {
|
||||
json.anyOf = options;
|
||||
}
|
||||
};
|
||||
exports.unionProcessor = unionProcessor;
|
||||
const intersectionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const a = (0, to_json_schema_js_1.process)(def.left, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 0],
|
||||
});
|
||||
const b = (0, to_json_schema_js_1.process)(def.right, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 1],
|
||||
});
|
||||
const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
|
||||
const allOf = [
|
||||
...(isSimpleIntersection(a) ? a.allOf : [a]),
|
||||
...(isSimpleIntersection(b) ? b.allOf : [b]),
|
||||
];
|
||||
json.allOf = allOf;
|
||||
};
|
||||
exports.intersectionProcessor = intersectionProcessor;
|
||||
const tupleProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "array";
|
||||
const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
|
||||
const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
|
||||
const prefixItems = def.items.map((x, i) => (0, to_json_schema_js_1.process)(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, prefixPath, i],
|
||||
}));
|
||||
const rest = def.rest
|
||||
? (0, to_json_schema_js_1.process)(def.rest, ctx, {
|
||||
...params,
|
||||
path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
|
||||
})
|
||||
: null;
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
json.prefixItems = prefixItems;
|
||||
if (rest) {
|
||||
json.items = rest;
|
||||
}
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
json.items = {
|
||||
anyOf: prefixItems,
|
||||
};
|
||||
if (rest) {
|
||||
json.items.anyOf.push(rest);
|
||||
}
|
||||
json.minItems = prefixItems.length;
|
||||
if (!rest) {
|
||||
json.maxItems = prefixItems.length;
|
||||
}
|
||||
}
|
||||
else {
|
||||
json.items = prefixItems;
|
||||
if (rest) {
|
||||
json.additionalItems = rest;
|
||||
}
|
||||
}
|
||||
// length
|
||||
const { minimum, maximum } = schema._zod.bag;
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
};
|
||||
exports.tupleProcessor = tupleProcessor;
|
||||
const recordProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "object";
|
||||
// For looseRecord with regex patterns, use patternProperties
|
||||
// This correctly represents "only validate keys matching the pattern" semantics
|
||||
// and composes well with allOf (intersections)
|
||||
const keyType = def.keyType;
|
||||
const keyBag = keyType._zod.bag;
|
||||
const patterns = keyBag?.patterns;
|
||||
if (def.mode === "loose" && patterns && patterns.size > 0) {
|
||||
// Use patternProperties for looseRecord with regex patterns
|
||||
const valueSchema = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "patternProperties", "*"],
|
||||
});
|
||||
json.patternProperties = {};
|
||||
for (const pattern of patterns) {
|
||||
json.patternProperties[pattern.source] = valueSchema;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Default behavior: use propertyNames + additionalProperties
|
||||
if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
|
||||
json.propertyNames = (0, to_json_schema_js_1.process)(def.keyType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "propertyNames"],
|
||||
});
|
||||
}
|
||||
json.additionalProperties = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
// Add required for keys with discrete values (enum, literal, etc.)
|
||||
const keyValues = keyType._zod.values;
|
||||
if (keyValues) {
|
||||
const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
|
||||
if (validKeyValues.length > 0) {
|
||||
json.required = validKeyValues;
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.recordProcessor = recordProcessor;
|
||||
const nullableProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const inner = (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
seen.ref = def.innerType;
|
||||
json.nullable = true;
|
||||
}
|
||||
else {
|
||||
json.anyOf = [inner, { type: "null" }];
|
||||
}
|
||||
};
|
||||
exports.nullableProcessor = nullableProcessor;
|
||||
const nonoptionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
exports.nonoptionalProcessor = nonoptionalProcessor;
|
||||
const defaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
json.default = JSON.parse(JSON.stringify(def.defaultValue));
|
||||
};
|
||||
exports.defaultProcessor = defaultProcessor;
|
||||
const prefaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
if (ctx.io === "input")
|
||||
json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
|
||||
};
|
||||
exports.prefaultProcessor = prefaultProcessor;
|
||||
const catchProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
let catchValue;
|
||||
try {
|
||||
catchValue = def.catchValue(undefined);
|
||||
}
|
||||
catch {
|
||||
throw new Error("Dynamic catch values are not supported in JSON Schema");
|
||||
}
|
||||
json.default = catchValue;
|
||||
};
|
||||
exports.catchProcessor = catchProcessor;
|
||||
const pipeProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
|
||||
(0, to_json_schema_js_1.process)(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
exports.pipeProcessor = pipeProcessor;
|
||||
const readonlyProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
json.readOnly = true;
|
||||
};
|
||||
exports.readonlyProcessor = readonlyProcessor;
|
||||
const promiseProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
exports.promiseProcessor = promiseProcessor;
|
||||
const optionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.process)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
exports.optionalProcessor = optionalProcessor;
|
||||
const lazyProcessor = (schema, ctx, _json, params) => {
|
||||
const innerType = schema._zod.innerType;
|
||||
(0, to_json_schema_js_1.process)(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
exports.lazyProcessor = lazyProcessor;
|
||||
// ==================== ALL PROCESSORS ====================
|
||||
exports.allProcessors = {
|
||||
string: exports.stringProcessor,
|
||||
number: exports.numberProcessor,
|
||||
boolean: exports.booleanProcessor,
|
||||
bigint: exports.bigintProcessor,
|
||||
symbol: exports.symbolProcessor,
|
||||
null: exports.nullProcessor,
|
||||
undefined: exports.undefinedProcessor,
|
||||
void: exports.voidProcessor,
|
||||
never: exports.neverProcessor,
|
||||
any: exports.anyProcessor,
|
||||
unknown: exports.unknownProcessor,
|
||||
date: exports.dateProcessor,
|
||||
enum: exports.enumProcessor,
|
||||
literal: exports.literalProcessor,
|
||||
nan: exports.nanProcessor,
|
||||
template_literal: exports.templateLiteralProcessor,
|
||||
file: exports.fileProcessor,
|
||||
success: exports.successProcessor,
|
||||
custom: exports.customProcessor,
|
||||
function: exports.functionProcessor,
|
||||
transform: exports.transformProcessor,
|
||||
map: exports.mapProcessor,
|
||||
set: exports.setProcessor,
|
||||
array: exports.arrayProcessor,
|
||||
object: exports.objectProcessor,
|
||||
union: exports.unionProcessor,
|
||||
intersection: exports.intersectionProcessor,
|
||||
tuple: exports.tupleProcessor,
|
||||
record: exports.recordProcessor,
|
||||
nullable: exports.nullableProcessor,
|
||||
nonoptional: exports.nonoptionalProcessor,
|
||||
default: exports.defaultProcessor,
|
||||
prefault: exports.prefaultProcessor,
|
||||
catch: exports.catchProcessor,
|
||||
pipe: exports.pipeProcessor,
|
||||
readonly: exports.readonlyProcessor,
|
||||
promise: exports.promiseProcessor,
|
||||
optional: exports.optionalProcessor,
|
||||
lazy: exports.lazyProcessor,
|
||||
};
|
||||
function toJSONSchema(input, params) {
|
||||
if ("_idmap" in input) {
|
||||
// Registry case
|
||||
const registry = input;
|
||||
const ctx = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports.allProcessors });
|
||||
const defs = {};
|
||||
// First pass: process all schemas to build the seen map
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [_, schema] = entry;
|
||||
(0, to_json_schema_js_1.process)(schema, ctx);
|
||||
}
|
||||
const schemas = {};
|
||||
const external = {
|
||||
registry,
|
||||
uri: params?.uri,
|
||||
defs,
|
||||
};
|
||||
// Update the context with external configuration
|
||||
ctx.external = external;
|
||||
// Second pass: emit each schema
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [key, schema] = entry;
|
||||
(0, to_json_schema_js_1.extractDefs)(ctx, schema);
|
||||
schemas[key] = (0, to_json_schema_js_1.finalize)(ctx, schema);
|
||||
}
|
||||
if (Object.keys(defs).length > 0) {
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
schemas.__shared = {
|
||||
[defsSegment]: defs,
|
||||
};
|
||||
}
|
||||
return { schemas };
|
||||
}
|
||||
// Single schema case
|
||||
const ctx = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports.allProcessors });
|
||||
(0, to_json_schema_js_1.process)(input, ctx);
|
||||
(0, to_json_schema_js_1.extractDefs)(ctx, input);
|
||||
return (0, to_json_schema_js_1.finalize)(ctx, input);
|
||||
}
|
||||
49
node_modules/zod/v4/core/json-schema-processors.d.cts
generated
vendored
Normal file
49
node_modules/zod/v4/core/json-schema-processors.d.cts
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
import type { $ZodRegistry } from "./registries.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.cjs";
|
||||
export declare const stringProcessor: Processor<schemas.$ZodString>;
|
||||
export declare const numberProcessor: Processor<schemas.$ZodNumber>;
|
||||
export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
|
||||
export declare const bigintProcessor: Processor<schemas.$ZodBigInt>;
|
||||
export declare const symbolProcessor: Processor<schemas.$ZodSymbol>;
|
||||
export declare const nullProcessor: Processor<schemas.$ZodNull>;
|
||||
export declare const undefinedProcessor: Processor<schemas.$ZodUndefined>;
|
||||
export declare const voidProcessor: Processor<schemas.$ZodVoid>;
|
||||
export declare const neverProcessor: Processor<schemas.$ZodNever>;
|
||||
export declare const anyProcessor: Processor<schemas.$ZodAny>;
|
||||
export declare const unknownProcessor: Processor<schemas.$ZodUnknown>;
|
||||
export declare const dateProcessor: Processor<schemas.$ZodDate>;
|
||||
export declare const enumProcessor: Processor<schemas.$ZodEnum>;
|
||||
export declare const literalProcessor: Processor<schemas.$ZodLiteral>;
|
||||
export declare const nanProcessor: Processor<schemas.$ZodNaN>;
|
||||
export declare const templateLiteralProcessor: Processor<schemas.$ZodTemplateLiteral>;
|
||||
export declare const fileProcessor: Processor<schemas.$ZodFile>;
|
||||
export declare const successProcessor: Processor<schemas.$ZodSuccess>;
|
||||
export declare const customProcessor: Processor<schemas.$ZodCustom>;
|
||||
export declare const functionProcessor: Processor<schemas.$ZodFunction>;
|
||||
export declare const transformProcessor: Processor<schemas.$ZodTransform>;
|
||||
export declare const mapProcessor: Processor<schemas.$ZodMap>;
|
||||
export declare const setProcessor: Processor<schemas.$ZodSet>;
|
||||
export declare const arrayProcessor: Processor<schemas.$ZodArray>;
|
||||
export declare const objectProcessor: Processor<schemas.$ZodObject>;
|
||||
export declare const unionProcessor: Processor<schemas.$ZodUnion>;
|
||||
export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
|
||||
export declare const tupleProcessor: Processor<schemas.$ZodTuple>;
|
||||
export declare const recordProcessor: Processor<schemas.$ZodRecord>;
|
||||
export declare const nullableProcessor: Processor<schemas.$ZodNullable>;
|
||||
export declare const nonoptionalProcessor: Processor<schemas.$ZodNonOptional>;
|
||||
export declare const defaultProcessor: Processor<schemas.$ZodDefault>;
|
||||
export declare const prefaultProcessor: Processor<schemas.$ZodPrefault>;
|
||||
export declare const catchProcessor: Processor<schemas.$ZodCatch>;
|
||||
export declare const pipeProcessor: Processor<schemas.$ZodPipe>;
|
||||
export declare const readonlyProcessor: Processor<schemas.$ZodReadonly>;
|
||||
export declare const promiseProcessor: Processor<schemas.$ZodPromise>;
|
||||
export declare const optionalProcessor: Processor<schemas.$ZodOptional>;
|
||||
export declare const lazyProcessor: Processor<schemas.$ZodLazy>;
|
||||
export declare const allProcessors: Record<string, Processor<any>>;
|
||||
export declare function toJSONSchema<T extends schemas.$ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;
|
||||
export declare function toJSONSchema(registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>, params?: RegistryToJSONSchemaParams): {
|
||||
schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
|
||||
};
|
||||
49
node_modules/zod/v4/core/json-schema-processors.d.ts
generated
vendored
Normal file
49
node_modules/zod/v4/core/json-schema-processors.d.ts
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
import type { $ZodRegistry } from "./registries.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.js";
|
||||
export declare const stringProcessor: Processor<schemas.$ZodString>;
|
||||
export declare const numberProcessor: Processor<schemas.$ZodNumber>;
|
||||
export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
|
||||
export declare const bigintProcessor: Processor<schemas.$ZodBigInt>;
|
||||
export declare const symbolProcessor: Processor<schemas.$ZodSymbol>;
|
||||
export declare const nullProcessor: Processor<schemas.$ZodNull>;
|
||||
export declare const undefinedProcessor: Processor<schemas.$ZodUndefined>;
|
||||
export declare const voidProcessor: Processor<schemas.$ZodVoid>;
|
||||
export declare const neverProcessor: Processor<schemas.$ZodNever>;
|
||||
export declare const anyProcessor: Processor<schemas.$ZodAny>;
|
||||
export declare const unknownProcessor: Processor<schemas.$ZodUnknown>;
|
||||
export declare const dateProcessor: Processor<schemas.$ZodDate>;
|
||||
export declare const enumProcessor: Processor<schemas.$ZodEnum>;
|
||||
export declare const literalProcessor: Processor<schemas.$ZodLiteral>;
|
||||
export declare const nanProcessor: Processor<schemas.$ZodNaN>;
|
||||
export declare const templateLiteralProcessor: Processor<schemas.$ZodTemplateLiteral>;
|
||||
export declare const fileProcessor: Processor<schemas.$ZodFile>;
|
||||
export declare const successProcessor: Processor<schemas.$ZodSuccess>;
|
||||
export declare const customProcessor: Processor<schemas.$ZodCustom>;
|
||||
export declare const functionProcessor: Processor<schemas.$ZodFunction>;
|
||||
export declare const transformProcessor: Processor<schemas.$ZodTransform>;
|
||||
export declare const mapProcessor: Processor<schemas.$ZodMap>;
|
||||
export declare const setProcessor: Processor<schemas.$ZodSet>;
|
||||
export declare const arrayProcessor: Processor<schemas.$ZodArray>;
|
||||
export declare const objectProcessor: Processor<schemas.$ZodObject>;
|
||||
export declare const unionProcessor: Processor<schemas.$ZodUnion>;
|
||||
export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
|
||||
export declare const tupleProcessor: Processor<schemas.$ZodTuple>;
|
||||
export declare const recordProcessor: Processor<schemas.$ZodRecord>;
|
||||
export declare const nullableProcessor: Processor<schemas.$ZodNullable>;
|
||||
export declare const nonoptionalProcessor: Processor<schemas.$ZodNonOptional>;
|
||||
export declare const defaultProcessor: Processor<schemas.$ZodDefault>;
|
||||
export declare const prefaultProcessor: Processor<schemas.$ZodPrefault>;
|
||||
export declare const catchProcessor: Processor<schemas.$ZodCatch>;
|
||||
export declare const pipeProcessor: Processor<schemas.$ZodPipe>;
|
||||
export declare const readonlyProcessor: Processor<schemas.$ZodReadonly>;
|
||||
export declare const promiseProcessor: Processor<schemas.$ZodPromise>;
|
||||
export declare const optionalProcessor: Processor<schemas.$ZodOptional>;
|
||||
export declare const lazyProcessor: Processor<schemas.$ZodLazy>;
|
||||
export declare const allProcessors: Record<string, Processor<any>>;
|
||||
export declare function toJSONSchema<T extends schemas.$ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;
|
||||
export declare function toJSONSchema(registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>, params?: RegistryToJSONSchemaParams): {
|
||||
schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
|
||||
};
|
||||
605
node_modules/zod/v4/core/json-schema-processors.js
generated
vendored
Normal file
605
node_modules/zod/v4/core/json-schema-processors.js
generated
vendored
Normal file
@@ -0,0 +1,605 @@
|
||||
import { extractDefs, finalize, initializeContext, process, } from "./to-json-schema.js";
|
||||
import { getEnumValues } from "./util.js";
|
||||
const formatMap = {
|
||||
guid: "uuid",
|
||||
url: "uri",
|
||||
datetime: "date-time",
|
||||
json_string: "json-string",
|
||||
regex: "", // do not set
|
||||
};
|
||||
// ==================== SIMPLE TYPE PROCESSORS ====================
|
||||
export const stringProcessor = (schema, ctx, _json, _params) => {
|
||||
const json = _json;
|
||||
json.type = "string";
|
||||
const { minimum, maximum, format, patterns, contentEncoding } = schema._zod
|
||||
.bag;
|
||||
if (typeof minimum === "number")
|
||||
json.minLength = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxLength = maximum;
|
||||
// custom pattern overrides format
|
||||
if (format) {
|
||||
json.format = formatMap[format] ?? format;
|
||||
if (json.format === "")
|
||||
delete json.format; // empty format is not valid
|
||||
// JSON Schema format: "time" requires a full time with offset or Z
|
||||
// z.iso.time() does not include timezone information, so format: "time" should never be used
|
||||
if (format === "time") {
|
||||
delete json.format;
|
||||
}
|
||||
}
|
||||
if (contentEncoding)
|
||||
json.contentEncoding = contentEncoding;
|
||||
if (patterns && patterns.size > 0) {
|
||||
const regexes = [...patterns];
|
||||
if (regexes.length === 1)
|
||||
json.pattern = regexes[0].source;
|
||||
else if (regexes.length > 1) {
|
||||
json.allOf = [
|
||||
...regexes.map((regex) => ({
|
||||
...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
|
||||
? { type: "string" }
|
||||
: {}),
|
||||
pattern: regex.source,
|
||||
})),
|
||||
];
|
||||
}
|
||||
}
|
||||
};
|
||||
export const numberProcessor = (schema, ctx, _json, _params) => {
|
||||
const json = _json;
|
||||
const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
|
||||
if (typeof format === "string" && format.includes("int"))
|
||||
json.type = "integer";
|
||||
else
|
||||
json.type = "number";
|
||||
if (typeof exclusiveMinimum === "number") {
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.minimum = exclusiveMinimum;
|
||||
json.exclusiveMinimum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMinimum = exclusiveMinimum;
|
||||
}
|
||||
}
|
||||
if (typeof minimum === "number") {
|
||||
json.minimum = minimum;
|
||||
if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
|
||||
if (exclusiveMinimum >= minimum)
|
||||
delete json.minimum;
|
||||
else
|
||||
delete json.exclusiveMinimum;
|
||||
}
|
||||
}
|
||||
if (typeof exclusiveMaximum === "number") {
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.maximum = exclusiveMaximum;
|
||||
json.exclusiveMaximum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMaximum = exclusiveMaximum;
|
||||
}
|
||||
}
|
||||
if (typeof maximum === "number") {
|
||||
json.maximum = maximum;
|
||||
if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
|
||||
if (exclusiveMaximum <= maximum)
|
||||
delete json.maximum;
|
||||
else
|
||||
delete json.exclusiveMaximum;
|
||||
}
|
||||
}
|
||||
if (typeof multipleOf === "number")
|
||||
json.multipleOf = multipleOf;
|
||||
};
|
||||
export const booleanProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
export const bigintProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("BigInt cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const symbolProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Symbols cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const nullProcessor = (_schema, ctx, json, _params) => {
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
json.type = "string";
|
||||
json.nullable = true;
|
||||
json.enum = [null];
|
||||
}
|
||||
else {
|
||||
json.type = "null";
|
||||
}
|
||||
};
|
||||
export const undefinedProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Undefined cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const voidProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Void cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const neverProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.not = {};
|
||||
};
|
||||
export const anyProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
export const unknownProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
export const dateProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Date cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const enumProcessor = (schema, _ctx, json, _params) => {
|
||||
const def = schema._zod.def;
|
||||
const values = getEnumValues(def.entries);
|
||||
// Number enums can have both string and number values
|
||||
if (values.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (values.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
json.enum = values;
|
||||
};
|
||||
export const literalProcessor = (schema, ctx, json, _params) => {
|
||||
const def = schema._zod.def;
|
||||
const vals = [];
|
||||
for (const val of def.values) {
|
||||
if (val === undefined) {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Literal `undefined` cannot be represented in JSON Schema");
|
||||
}
|
||||
else {
|
||||
// do not add to vals
|
||||
}
|
||||
}
|
||||
else if (typeof val === "bigint") {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("BigInt literals cannot be represented in JSON Schema");
|
||||
}
|
||||
else {
|
||||
vals.push(Number(val));
|
||||
}
|
||||
}
|
||||
else {
|
||||
vals.push(val);
|
||||
}
|
||||
}
|
||||
if (vals.length === 0) {
|
||||
// do nothing (an undefined literal was stripped)
|
||||
}
|
||||
else if (vals.length === 1) {
|
||||
const val = vals[0];
|
||||
json.type = val === null ? "null" : typeof val;
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.enum = [val];
|
||||
}
|
||||
else {
|
||||
json.const = val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (vals.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (vals.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
if (vals.every((v) => typeof v === "boolean"))
|
||||
json.type = "boolean";
|
||||
if (vals.every((v) => v === null))
|
||||
json.type = "null";
|
||||
json.enum = vals;
|
||||
}
|
||||
};
|
||||
export const nanProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("NaN cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const templateLiteralProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
const pattern = schema._zod.pattern;
|
||||
if (!pattern)
|
||||
throw new Error("Pattern not found in template literal");
|
||||
_json.type = "string";
|
||||
_json.pattern = pattern.source;
|
||||
};
|
||||
export const fileProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
const file = {
|
||||
type: "string",
|
||||
format: "binary",
|
||||
contentEncoding: "binary",
|
||||
};
|
||||
const { minimum, maximum, mime } = schema._zod.bag;
|
||||
if (minimum !== undefined)
|
||||
file.minLength = minimum;
|
||||
if (maximum !== undefined)
|
||||
file.maxLength = maximum;
|
||||
if (mime) {
|
||||
if (mime.length === 1) {
|
||||
file.contentMediaType = mime[0];
|
||||
Object.assign(_json, file);
|
||||
}
|
||||
else {
|
||||
Object.assign(_json, file); // shared props at root
|
||||
_json.anyOf = mime.map((m) => ({ contentMediaType: m })); // only contentMediaType differs
|
||||
}
|
||||
}
|
||||
else {
|
||||
Object.assign(_json, file);
|
||||
}
|
||||
};
|
||||
export const successProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
export const customProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Custom types cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const functionProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Function types cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const transformProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Transforms cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const mapProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Map cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
export const setProcessor = (_schema, ctx, _json, _params) => {
|
||||
if (ctx.unrepresentable === "throw") {
|
||||
throw new Error("Set cannot be represented in JSON Schema");
|
||||
}
|
||||
};
|
||||
// ==================== COMPOSITE TYPE PROCESSORS ====================
|
||||
export const arrayProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
const { minimum, maximum } = schema._zod.bag;
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
json.type = "array";
|
||||
json.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
|
||||
};
|
||||
export const objectProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "object";
|
||||
json.properties = {};
|
||||
const shape = def.shape;
|
||||
for (const key in shape) {
|
||||
json.properties[key] = process(shape[key], ctx, {
|
||||
...params,
|
||||
path: [...params.path, "properties", key],
|
||||
});
|
||||
}
|
||||
// required keys
|
||||
const allKeys = new Set(Object.keys(shape));
|
||||
const requiredKeys = new Set([...allKeys].filter((key) => {
|
||||
const v = def.shape[key]._zod;
|
||||
if (ctx.io === "input") {
|
||||
return v.optin === undefined;
|
||||
}
|
||||
else {
|
||||
return v.optout === undefined;
|
||||
}
|
||||
}));
|
||||
if (requiredKeys.size > 0) {
|
||||
json.required = Array.from(requiredKeys);
|
||||
}
|
||||
// catchall
|
||||
if (def.catchall?._zod.def.type === "never") {
|
||||
// strict
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (!def.catchall) {
|
||||
// regular
|
||||
if (ctx.io === "output")
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (def.catchall) {
|
||||
json.additionalProperties = process(def.catchall, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
};
|
||||
export const unionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
// Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
|
||||
// This includes both z.xor() and discriminated unions
|
||||
const isExclusive = def.inclusive === false;
|
||||
const options = def.options.map((x, i) => process(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
|
||||
}));
|
||||
if (isExclusive) {
|
||||
json.oneOf = options;
|
||||
}
|
||||
else {
|
||||
json.anyOf = options;
|
||||
}
|
||||
};
|
||||
export const intersectionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const a = process(def.left, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 0],
|
||||
});
|
||||
const b = process(def.right, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 1],
|
||||
});
|
||||
const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
|
||||
const allOf = [
|
||||
...(isSimpleIntersection(a) ? a.allOf : [a]),
|
||||
...(isSimpleIntersection(b) ? b.allOf : [b]),
|
||||
];
|
||||
json.allOf = allOf;
|
||||
};
|
||||
export const tupleProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "array";
|
||||
const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
|
||||
const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
|
||||
const prefixItems = def.items.map((x, i) => process(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, prefixPath, i],
|
||||
}));
|
||||
const rest = def.rest
|
||||
? process(def.rest, ctx, {
|
||||
...params,
|
||||
path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
|
||||
})
|
||||
: null;
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
json.prefixItems = prefixItems;
|
||||
if (rest) {
|
||||
json.items = rest;
|
||||
}
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
json.items = {
|
||||
anyOf: prefixItems,
|
||||
};
|
||||
if (rest) {
|
||||
json.items.anyOf.push(rest);
|
||||
}
|
||||
json.minItems = prefixItems.length;
|
||||
if (!rest) {
|
||||
json.maxItems = prefixItems.length;
|
||||
}
|
||||
}
|
||||
else {
|
||||
json.items = prefixItems;
|
||||
if (rest) {
|
||||
json.additionalItems = rest;
|
||||
}
|
||||
}
|
||||
// length
|
||||
const { minimum, maximum } = schema._zod.bag;
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
};
|
||||
export const recordProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "object";
|
||||
// For looseRecord with regex patterns, use patternProperties
|
||||
// This correctly represents "only validate keys matching the pattern" semantics
|
||||
// and composes well with allOf (intersections)
|
||||
const keyType = def.keyType;
|
||||
const keyBag = keyType._zod.bag;
|
||||
const patterns = keyBag?.patterns;
|
||||
if (def.mode === "loose" && patterns && patterns.size > 0) {
|
||||
// Use patternProperties for looseRecord with regex patterns
|
||||
const valueSchema = process(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "patternProperties", "*"],
|
||||
});
|
||||
json.patternProperties = {};
|
||||
for (const pattern of patterns) {
|
||||
json.patternProperties[pattern.source] = valueSchema;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Default behavior: use propertyNames + additionalProperties
|
||||
if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
|
||||
json.propertyNames = process(def.keyType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "propertyNames"],
|
||||
});
|
||||
}
|
||||
json.additionalProperties = process(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
// Add required for keys with discrete values (enum, literal, etc.)
|
||||
const keyValues = keyType._zod.values;
|
||||
if (keyValues) {
|
||||
const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
|
||||
if (validKeyValues.length > 0) {
|
||||
json.required = validKeyValues;
|
||||
}
|
||||
}
|
||||
};
|
||||
export const nullableProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const inner = process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
seen.ref = def.innerType;
|
||||
json.nullable = true;
|
||||
}
|
||||
else {
|
||||
json.anyOf = [inner, { type: "null" }];
|
||||
}
|
||||
};
|
||||
export const nonoptionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
export const defaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
json.default = JSON.parse(JSON.stringify(def.defaultValue));
|
||||
};
|
||||
export const prefaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
if (ctx.io === "input")
|
||||
json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
|
||||
};
|
||||
export const catchProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
let catchValue;
|
||||
try {
|
||||
catchValue = def.catchValue(undefined);
|
||||
}
|
||||
catch {
|
||||
throw new Error("Dynamic catch values are not supported in JSON Schema");
|
||||
}
|
||||
json.default = catchValue;
|
||||
};
|
||||
export const pipeProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
|
||||
process(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
export const readonlyProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
json.readOnly = true;
|
||||
};
|
||||
export const promiseProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
export const optionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
process(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
export const lazyProcessor = (schema, ctx, _json, params) => {
|
||||
const innerType = schema._zod.innerType;
|
||||
process(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
// ==================== ALL PROCESSORS ====================
|
||||
export const allProcessors = {
|
||||
string: stringProcessor,
|
||||
number: numberProcessor,
|
||||
boolean: booleanProcessor,
|
||||
bigint: bigintProcessor,
|
||||
symbol: symbolProcessor,
|
||||
null: nullProcessor,
|
||||
undefined: undefinedProcessor,
|
||||
void: voidProcessor,
|
||||
never: neverProcessor,
|
||||
any: anyProcessor,
|
||||
unknown: unknownProcessor,
|
||||
date: dateProcessor,
|
||||
enum: enumProcessor,
|
||||
literal: literalProcessor,
|
||||
nan: nanProcessor,
|
||||
template_literal: templateLiteralProcessor,
|
||||
file: fileProcessor,
|
||||
success: successProcessor,
|
||||
custom: customProcessor,
|
||||
function: functionProcessor,
|
||||
transform: transformProcessor,
|
||||
map: mapProcessor,
|
||||
set: setProcessor,
|
||||
array: arrayProcessor,
|
||||
object: objectProcessor,
|
||||
union: unionProcessor,
|
||||
intersection: intersectionProcessor,
|
||||
tuple: tupleProcessor,
|
||||
record: recordProcessor,
|
||||
nullable: nullableProcessor,
|
||||
nonoptional: nonoptionalProcessor,
|
||||
default: defaultProcessor,
|
||||
prefault: prefaultProcessor,
|
||||
catch: catchProcessor,
|
||||
pipe: pipeProcessor,
|
||||
readonly: readonlyProcessor,
|
||||
promise: promiseProcessor,
|
||||
optional: optionalProcessor,
|
||||
lazy: lazyProcessor,
|
||||
};
|
||||
export function toJSONSchema(input, params) {
|
||||
if ("_idmap" in input) {
|
||||
// Registry case
|
||||
const registry = input;
|
||||
const ctx = initializeContext({ ...params, processors: allProcessors });
|
||||
const defs = {};
|
||||
// First pass: process all schemas to build the seen map
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [_, schema] = entry;
|
||||
process(schema, ctx);
|
||||
}
|
||||
const schemas = {};
|
||||
const external = {
|
||||
registry,
|
||||
uri: params?.uri,
|
||||
defs,
|
||||
};
|
||||
// Update the context with external configuration
|
||||
ctx.external = external;
|
||||
// Second pass: emit each schema
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [key, schema] = entry;
|
||||
extractDefs(ctx, schema);
|
||||
schemas[key] = finalize(ctx, schema);
|
||||
}
|
||||
if (Object.keys(defs).length > 0) {
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
schemas.__shared = {
|
||||
[defsSegment]: defs,
|
||||
};
|
||||
}
|
||||
return { schemas };
|
||||
}
|
||||
// Single schema case
|
||||
const ctx = initializeContext({ ...params, processors: allProcessors });
|
||||
process(input, ctx);
|
||||
extractDefs(ctx, input);
|
||||
return finalize(ctx, input);
|
||||
}
|
||||
2
node_modules/zod/v4/core/json-schema.cjs
generated
vendored
Normal file
2
node_modules/zod/v4/core/json-schema.cjs
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
88
node_modules/zod/v4/core/json-schema.d.cts
generated
vendored
Normal file
88
node_modules/zod/v4/core/json-schema.d.cts
generated
vendored
Normal file
@@ -0,0 +1,88 @@
|
||||
export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
|
||||
export type _JSONSchema = boolean | JSONSchema;
|
||||
export type JSONSchema = {
|
||||
[k: string]: unknown;
|
||||
$schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
|
||||
$id?: string;
|
||||
$anchor?: string;
|
||||
$ref?: string;
|
||||
$dynamicRef?: string;
|
||||
$dynamicAnchor?: string;
|
||||
$vocabulary?: Record<string, boolean>;
|
||||
$comment?: string;
|
||||
$defs?: Record<string, JSONSchema>;
|
||||
type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
|
||||
additionalItems?: _JSONSchema;
|
||||
unevaluatedItems?: _JSONSchema;
|
||||
prefixItems?: _JSONSchema[];
|
||||
items?: _JSONSchema | _JSONSchema[];
|
||||
contains?: _JSONSchema;
|
||||
additionalProperties?: _JSONSchema;
|
||||
unevaluatedProperties?: _JSONSchema;
|
||||
properties?: Record<string, _JSONSchema>;
|
||||
patternProperties?: Record<string, _JSONSchema>;
|
||||
dependentSchemas?: Record<string, _JSONSchema>;
|
||||
propertyNames?: _JSONSchema;
|
||||
if?: _JSONSchema;
|
||||
then?: _JSONSchema;
|
||||
else?: _JSONSchema;
|
||||
allOf?: JSONSchema[];
|
||||
anyOf?: JSONSchema[];
|
||||
oneOf?: JSONSchema[];
|
||||
not?: _JSONSchema;
|
||||
multipleOf?: number;
|
||||
maximum?: number;
|
||||
exclusiveMaximum?: number | boolean;
|
||||
minimum?: number;
|
||||
exclusiveMinimum?: number | boolean;
|
||||
maxLength?: number;
|
||||
minLength?: number;
|
||||
pattern?: string;
|
||||
maxItems?: number;
|
||||
minItems?: number;
|
||||
uniqueItems?: boolean;
|
||||
maxContains?: number;
|
||||
minContains?: number;
|
||||
maxProperties?: number;
|
||||
minProperties?: number;
|
||||
required?: string[];
|
||||
dependentRequired?: Record<string, string[]>;
|
||||
enum?: Array<string | number | boolean | null>;
|
||||
const?: string | number | boolean | null;
|
||||
id?: string;
|
||||
title?: string;
|
||||
description?: string;
|
||||
default?: unknown;
|
||||
deprecated?: boolean;
|
||||
readOnly?: boolean;
|
||||
writeOnly?: boolean;
|
||||
nullable?: boolean;
|
||||
examples?: unknown[];
|
||||
format?: string;
|
||||
contentMediaType?: string;
|
||||
contentEncoding?: string;
|
||||
contentSchema?: JSONSchema;
|
||||
_prefault?: unknown;
|
||||
};
|
||||
export type BaseSchema = JSONSchema;
|
||||
export interface ObjectSchema extends JSONSchema {
|
||||
type: "object";
|
||||
}
|
||||
export interface ArraySchema extends JSONSchema {
|
||||
type: "array";
|
||||
}
|
||||
export interface StringSchema extends JSONSchema {
|
||||
type: "string";
|
||||
}
|
||||
export interface NumberSchema extends JSONSchema {
|
||||
type: "number";
|
||||
}
|
||||
export interface IntegerSchema extends JSONSchema {
|
||||
type: "integer";
|
||||
}
|
||||
export interface BooleanSchema extends JSONSchema {
|
||||
type: "boolean";
|
||||
}
|
||||
export interface NullSchema extends JSONSchema {
|
||||
type: "null";
|
||||
}
|
||||
88
node_modules/zod/v4/core/json-schema.d.ts
generated
vendored
Normal file
88
node_modules/zod/v4/core/json-schema.d.ts
generated
vendored
Normal file
@@ -0,0 +1,88 @@
|
||||
export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
|
||||
export type _JSONSchema = boolean | JSONSchema;
|
||||
export type JSONSchema = {
|
||||
[k: string]: unknown;
|
||||
$schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
|
||||
$id?: string;
|
||||
$anchor?: string;
|
||||
$ref?: string;
|
||||
$dynamicRef?: string;
|
||||
$dynamicAnchor?: string;
|
||||
$vocabulary?: Record<string, boolean>;
|
||||
$comment?: string;
|
||||
$defs?: Record<string, JSONSchema>;
|
||||
type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
|
||||
additionalItems?: _JSONSchema;
|
||||
unevaluatedItems?: _JSONSchema;
|
||||
prefixItems?: _JSONSchema[];
|
||||
items?: _JSONSchema | _JSONSchema[];
|
||||
contains?: _JSONSchema;
|
||||
additionalProperties?: _JSONSchema;
|
||||
unevaluatedProperties?: _JSONSchema;
|
||||
properties?: Record<string, _JSONSchema>;
|
||||
patternProperties?: Record<string, _JSONSchema>;
|
||||
dependentSchemas?: Record<string, _JSONSchema>;
|
||||
propertyNames?: _JSONSchema;
|
||||
if?: _JSONSchema;
|
||||
then?: _JSONSchema;
|
||||
else?: _JSONSchema;
|
||||
allOf?: JSONSchema[];
|
||||
anyOf?: JSONSchema[];
|
||||
oneOf?: JSONSchema[];
|
||||
not?: _JSONSchema;
|
||||
multipleOf?: number;
|
||||
maximum?: number;
|
||||
exclusiveMaximum?: number | boolean;
|
||||
minimum?: number;
|
||||
exclusiveMinimum?: number | boolean;
|
||||
maxLength?: number;
|
||||
minLength?: number;
|
||||
pattern?: string;
|
||||
maxItems?: number;
|
||||
minItems?: number;
|
||||
uniqueItems?: boolean;
|
||||
maxContains?: number;
|
||||
minContains?: number;
|
||||
maxProperties?: number;
|
||||
minProperties?: number;
|
||||
required?: string[];
|
||||
dependentRequired?: Record<string, string[]>;
|
||||
enum?: Array<string | number | boolean | null>;
|
||||
const?: string | number | boolean | null;
|
||||
id?: string;
|
||||
title?: string;
|
||||
description?: string;
|
||||
default?: unknown;
|
||||
deprecated?: boolean;
|
||||
readOnly?: boolean;
|
||||
writeOnly?: boolean;
|
||||
nullable?: boolean;
|
||||
examples?: unknown[];
|
||||
format?: string;
|
||||
contentMediaType?: string;
|
||||
contentEncoding?: string;
|
||||
contentSchema?: JSONSchema;
|
||||
_prefault?: unknown;
|
||||
};
|
||||
export type BaseSchema = JSONSchema;
|
||||
export interface ObjectSchema extends JSONSchema {
|
||||
type: "object";
|
||||
}
|
||||
export interface ArraySchema extends JSONSchema {
|
||||
type: "array";
|
||||
}
|
||||
export interface StringSchema extends JSONSchema {
|
||||
type: "string";
|
||||
}
|
||||
export interface NumberSchema extends JSONSchema {
|
||||
type: "number";
|
||||
}
|
||||
export interface IntegerSchema extends JSONSchema {
|
||||
type: "integer";
|
||||
}
|
||||
export interface BooleanSchema extends JSONSchema {
|
||||
type: "boolean";
|
||||
}
|
||||
export interface NullSchema extends JSONSchema {
|
||||
type: "null";
|
||||
}
|
||||
1
node_modules/zod/v4/core/json-schema.js
generated
vendored
Normal file
1
node_modules/zod/v4/core/json-schema.js
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export {};
|
||||
6
node_modules/zod/v4/core/package.json
generated
vendored
Normal file
6
node_modules/zod/v4/core/package.json
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"type": "module",
|
||||
"main": "./index.cjs",
|
||||
"module": "./index.js",
|
||||
"types": "./index.d.cts"
|
||||
}
|
||||
131
node_modules/zod/v4/core/parse.cjs
generated
vendored
Normal file
131
node_modules/zod/v4/core/parse.cjs
generated
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.safeDecodeAsync = exports._safeDecodeAsync = exports.safeEncodeAsync = exports._safeEncodeAsync = exports.safeDecode = exports._safeDecode = exports.safeEncode = exports._safeEncode = exports.decodeAsync = exports._decodeAsync = exports.encodeAsync = exports._encodeAsync = exports.decode = exports._decode = exports.encode = exports._encode = exports.safeParseAsync = exports._safeParseAsync = exports.safeParse = exports._safeParse = exports.parseAsync = exports._parseAsync = exports.parse = exports._parse = void 0;
|
||||
const core = __importStar(require("./core.cjs"));
|
||||
const errors = __importStar(require("./errors.cjs"));
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
const _parse = (_Err) => (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
if (result.issues.length) {
|
||||
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, _params?.callee);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
exports._parse = _parse;
|
||||
exports.parse = (0, exports._parse)(errors.$ZodRealError);
|
||||
const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
if (result.issues.length) {
|
||||
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, params?.callee);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
exports._parseAsync = _parseAsync;
|
||||
exports.parseAsync = (0, exports._parseAsync)(errors.$ZodRealError);
|
||||
const _safeParse = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
return result.issues.length
|
||||
? {
|
||||
success: false,
|
||||
error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
|
||||
}
|
||||
: { success: true, data: result.value };
|
||||
};
|
||||
exports._safeParse = _safeParse;
|
||||
exports.safeParse = (0, exports._safeParse)(errors.$ZodRealError);
|
||||
const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
return result.issues.length
|
||||
? {
|
||||
success: false,
|
||||
error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
|
||||
}
|
||||
: { success: true, data: result.value };
|
||||
};
|
||||
exports._safeParseAsync = _safeParseAsync;
|
||||
exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodRealError);
|
||||
const _encode = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return (0, exports._parse)(_Err)(schema, value, ctx);
|
||||
};
|
||||
exports._encode = _encode;
|
||||
exports.encode = (0, exports._encode)(errors.$ZodRealError);
|
||||
const _decode = (_Err) => (schema, value, _ctx) => {
|
||||
return (0, exports._parse)(_Err)(schema, value, _ctx);
|
||||
};
|
||||
exports._decode = _decode;
|
||||
exports.decode = (0, exports._decode)(errors.$ZodRealError);
|
||||
const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return (0, exports._parseAsync)(_Err)(schema, value, ctx);
|
||||
};
|
||||
exports._encodeAsync = _encodeAsync;
|
||||
exports.encodeAsync = (0, exports._encodeAsync)(errors.$ZodRealError);
|
||||
const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
return (0, exports._parseAsync)(_Err)(schema, value, _ctx);
|
||||
};
|
||||
exports._decodeAsync = _decodeAsync;
|
||||
exports.decodeAsync = (0, exports._decodeAsync)(errors.$ZodRealError);
|
||||
const _safeEncode = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return (0, exports._safeParse)(_Err)(schema, value, ctx);
|
||||
};
|
||||
exports._safeEncode = _safeEncode;
|
||||
exports.safeEncode = (0, exports._safeEncode)(errors.$ZodRealError);
|
||||
const _safeDecode = (_Err) => (schema, value, _ctx) => {
|
||||
return (0, exports._safeParse)(_Err)(schema, value, _ctx);
|
||||
};
|
||||
exports._safeDecode = _safeDecode;
|
||||
exports.safeDecode = (0, exports._safeDecode)(errors.$ZodRealError);
|
||||
const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return (0, exports._safeParseAsync)(_Err)(schema, value, ctx);
|
||||
};
|
||||
exports._safeEncodeAsync = _safeEncodeAsync;
|
||||
exports.safeEncodeAsync = (0, exports._safeEncodeAsync)(errors.$ZodRealError);
|
||||
const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
return (0, exports._safeParseAsync)(_Err)(schema, value, _ctx);
|
||||
};
|
||||
exports._safeDecodeAsync = _safeDecodeAsync;
|
||||
exports.safeDecodeAsync = (0, exports._safeDecodeAsync)(errors.$ZodRealError);
|
||||
49
node_modules/zod/v4/core/parse.d.cts
generated
vendored
Normal file
49
node_modules/zod/v4/core/parse.d.cts
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
import * as core from "./core.cjs";
|
||||
import * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export type $ZodErrorClass = {
|
||||
new (issues: errors.$ZodIssue[]): errors.$ZodError;
|
||||
};
|
||||
export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
|
||||
callee?: util.AnyFunc;
|
||||
Err?: $ZodErrorClass;
|
||||
}) => core.output<T>;
|
||||
export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
|
||||
export declare const parse: $Parse;
|
||||
export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
|
||||
callee?: util.AnyFunc;
|
||||
Err?: $ZodErrorClass;
|
||||
}) => Promise<core.output<T>>;
|
||||
export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
|
||||
export declare const parseAsync: $ParseAsync;
|
||||
export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
|
||||
export declare const safeParse: $SafeParse;
|
||||
export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
|
||||
export declare const safeParseAsync: $SafeParseAsync;
|
||||
export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.input<T>;
|
||||
export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
|
||||
export declare const encode: $Encode;
|
||||
export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.output<T>;
|
||||
export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
|
||||
export declare const decode: $Decode;
|
||||
export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.input<T>>;
|
||||
export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
|
||||
export declare const encodeAsync: $EncodeAsync;
|
||||
export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.output<T>>;
|
||||
export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
|
||||
export declare const decodeAsync: $DecodeAsync;
|
||||
export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
|
||||
export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
|
||||
export declare const safeEncode: $SafeEncode;
|
||||
export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
|
||||
export declare const safeDecode: $SafeDecode;
|
||||
export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
|
||||
export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
|
||||
export declare const safeEncodeAsync: $SafeEncodeAsync;
|
||||
export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
|
||||
export declare const safeDecodeAsync: $SafeDecodeAsync;
|
||||
49
node_modules/zod/v4/core/parse.d.ts
generated
vendored
Normal file
49
node_modules/zod/v4/core/parse.d.ts
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
import * as core from "./core.js";
|
||||
import * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import * as util from "./util.js";
|
||||
export type $ZodErrorClass = {
|
||||
new (issues: errors.$ZodIssue[]): errors.$ZodError;
|
||||
};
|
||||
export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
|
||||
callee?: util.AnyFunc;
|
||||
Err?: $ZodErrorClass;
|
||||
}) => core.output<T>;
|
||||
export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
|
||||
export declare const parse: $Parse;
|
||||
export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
|
||||
callee?: util.AnyFunc;
|
||||
Err?: $ZodErrorClass;
|
||||
}) => Promise<core.output<T>>;
|
||||
export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
|
||||
export declare const parseAsync: $ParseAsync;
|
||||
export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
|
||||
export declare const safeParse: $SafeParse;
|
||||
export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
|
||||
export declare const safeParseAsync: $SafeParseAsync;
|
||||
export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.input<T>;
|
||||
export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
|
||||
export declare const encode: $Encode;
|
||||
export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.output<T>;
|
||||
export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
|
||||
export declare const decode: $Decode;
|
||||
export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.input<T>>;
|
||||
export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
|
||||
export declare const encodeAsync: $EncodeAsync;
|
||||
export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.output<T>>;
|
||||
export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
|
||||
export declare const decodeAsync: $DecodeAsync;
|
||||
export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
|
||||
export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
|
||||
export declare const safeEncode: $SafeEncode;
|
||||
export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
|
||||
export declare const safeDecode: $SafeDecode;
|
||||
export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
|
||||
export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
|
||||
export declare const safeEncodeAsync: $SafeEncodeAsync;
|
||||
export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
|
||||
export declare const safeDecodeAsync: $SafeDecodeAsync;
|
||||
93
node_modules/zod/v4/core/parse.js
generated
vendored
Normal file
93
node_modules/zod/v4/core/parse.js
generated
vendored
Normal file
@@ -0,0 +1,93 @@
|
||||
import * as core from "./core.js";
|
||||
import * as errors from "./errors.js";
|
||||
import * as util from "./util.js";
|
||||
export const _parse = (_Err) => (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
if (result.issues.length) {
|
||||
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, _params?.callee);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
export const parse = /* @__PURE__*/ _parse(errors.$ZodRealError);
|
||||
export const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
if (result.issues.length) {
|
||||
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, params?.callee);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
export const parseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);
|
||||
export const _safeParse = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
return result.issues.length
|
||||
? {
|
||||
success: false,
|
||||
error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
|
||||
}
|
||||
: { success: true, data: result.value };
|
||||
};
|
||||
export const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
|
||||
export const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
return result.issues.length
|
||||
? {
|
||||
success: false,
|
||||
error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
|
||||
}
|
||||
: { success: true, data: result.value };
|
||||
};
|
||||
export const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);
|
||||
export const _encode = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return _parse(_Err)(schema, value, ctx);
|
||||
};
|
||||
export const encode = /* @__PURE__*/ _encode(errors.$ZodRealError);
|
||||
export const _decode = (_Err) => (schema, value, _ctx) => {
|
||||
return _parse(_Err)(schema, value, _ctx);
|
||||
};
|
||||
export const decode = /* @__PURE__*/ _decode(errors.$ZodRealError);
|
||||
export const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return _parseAsync(_Err)(schema, value, ctx);
|
||||
};
|
||||
export const encodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);
|
||||
export const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
return _parseAsync(_Err)(schema, value, _ctx);
|
||||
};
|
||||
export const decodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);
|
||||
export const _safeEncode = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return _safeParse(_Err)(schema, value, ctx);
|
||||
};
|
||||
export const safeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);
|
||||
export const _safeDecode = (_Err) => (schema, value, _ctx) => {
|
||||
return _safeParse(_Err)(schema, value, _ctx);
|
||||
};
|
||||
export const safeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);
|
||||
export const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
||||
return _safeParseAsync(_Err)(schema, value, ctx);
|
||||
};
|
||||
export const safeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);
|
||||
export const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
return _safeParseAsync(_Err)(schema, value, _ctx);
|
||||
};
|
||||
export const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);
|
||||
166
node_modules/zod/v4/core/regexes.cjs
generated
vendored
Normal file
166
node_modules/zod/v4/core/regexes.cjs
generated
vendored
Normal file
@@ -0,0 +1,166 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.sha384_hex = exports.sha256_base64url = exports.sha256_base64 = exports.sha256_hex = exports.sha1_base64url = exports.sha1_base64 = exports.sha1_hex = exports.md5_base64url = exports.md5_base64 = exports.md5_hex = exports.hex = exports.uppercase = exports.lowercase = exports.undefined = exports.null = exports.boolean = exports.number = exports.integer = exports.bigint = exports.string = exports.date = exports.e164 = exports.domain = exports.hostname = exports.base64url = exports.base64 = exports.cidrv6 = exports.cidrv4 = exports.mac = exports.ipv6 = exports.ipv4 = exports.browserEmail = exports.idnEmail = exports.unicodeEmail = exports.rfc5322Email = exports.html5Email = exports.email = exports.uuid7 = exports.uuid6 = exports.uuid4 = exports.uuid = exports.guid = exports.extendedDuration = exports.duration = exports.nanoid = exports.ksuid = exports.xid = exports.ulid = exports.cuid2 = exports.cuid = void 0;
|
||||
exports.sha512_base64url = exports.sha512_base64 = exports.sha512_hex = exports.sha384_base64url = exports.sha384_base64 = void 0;
|
||||
exports.emoji = emoji;
|
||||
exports.time = time;
|
||||
exports.datetime = datetime;
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
exports.cuid = /^[cC][^\s-]{8,}$/;
|
||||
exports.cuid2 = /^[0-9a-z]+$/;
|
||||
exports.ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
|
||||
exports.xid = /^[0-9a-vA-V]{20}$/;
|
||||
exports.ksuid = /^[A-Za-z0-9]{27}$/;
|
||||
exports.nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
exports.duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
exports.extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
exports.guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
const uuid = (version) => {
|
||||
if (!version)
|
||||
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
||||
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
||||
};
|
||||
exports.uuid = uuid;
|
||||
exports.uuid4 = (0, exports.uuid)(4);
|
||||
exports.uuid6 = (0, exports.uuid)(6);
|
||||
exports.uuid7 = (0, exports.uuid)(7);
|
||||
/** Practical email validation */
|
||||
exports.email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
exports.html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
exports.rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
exports.unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
|
||||
exports.idnEmail = exports.unicodeEmail;
|
||||
exports.browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
|
||||
const _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
|
||||
function emoji() {
|
||||
return new RegExp(_emoji, "u");
|
||||
}
|
||||
exports.ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
||||
exports.ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
||||
const mac = (delimiter) => {
|
||||
const escapedDelim = util.escapeRegex(delimiter ?? ":");
|
||||
return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
|
||||
};
|
||||
exports.mac = mac;
|
||||
exports.cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
||||
exports.cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
||||
// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
|
||||
exports.base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
||||
exports.base64url = /^[A-Za-z0-9_-]*$/;
|
||||
// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
|
||||
// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
|
||||
exports.hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
|
||||
exports.domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
|
||||
// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
|
||||
// E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
|
||||
exports.e164 = /^\+[1-9]\d{6,14}$/;
|
||||
// const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
|
||||
const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
||||
exports.date = new RegExp(`^${dateSource}$`);
|
||||
function timeSource(args) {
|
||||
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
||||
const regex = typeof args.precision === "number"
|
||||
? args.precision === -1
|
||||
? `${hhmm}`
|
||||
: args.precision === 0
|
||||
? `${hhmm}:[0-5]\\d`
|
||||
: `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}`
|
||||
: `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
||||
return regex;
|
||||
}
|
||||
function time(args) {
|
||||
return new RegExp(`^${timeSource(args)}$`);
|
||||
}
|
||||
// Adapted from https://stackoverflow.com/a/3143231
|
||||
function datetime(args) {
|
||||
const time = timeSource({ precision: args.precision });
|
||||
const opts = ["Z"];
|
||||
if (args.local)
|
||||
opts.push("");
|
||||
// if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
|
||||
if (args.offset)
|
||||
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
||||
const timeRegex = `${time}(?:${opts.join("|")})`;
|
||||
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
|
||||
}
|
||||
const string = (params) => {
|
||||
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
||||
return new RegExp(`^${regex}$`);
|
||||
};
|
||||
exports.string = string;
|
||||
exports.bigint = /^-?\d+n?$/;
|
||||
exports.integer = /^-?\d+$/;
|
||||
exports.number = /^-?\d+(?:\.\d+)?$/;
|
||||
exports.boolean = /^(?:true|false)$/i;
|
||||
const _null = /^null$/i;
|
||||
exports.null = _null;
|
||||
const _undefined = /^undefined$/i;
|
||||
exports.undefined = _undefined;
|
||||
// regex for string with no uppercase letters
|
||||
exports.lowercase = /^[^A-Z]*$/;
|
||||
// regex for string with no lowercase letters
|
||||
exports.uppercase = /^[^a-z]*$/;
|
||||
// regex for hexadecimal strings (any length)
|
||||
exports.hex = /^[0-9a-fA-F]*$/;
|
||||
// Hash regexes for different algorithms and encodings
|
||||
// Helper function to create base64 regex with exact length and padding
|
||||
function fixedBase64(bodyLength, padding) {
|
||||
return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
|
||||
}
|
||||
// Helper function to create base64url regex with exact length (no padding)
|
||||
function fixedBase64url(length) {
|
||||
return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
|
||||
}
|
||||
// MD5 (16 bytes): base64 = 24 chars total (22 + "==")
|
||||
exports.md5_hex = /^[0-9a-fA-F]{32}$/;
|
||||
exports.md5_base64 = fixedBase64(22, "==");
|
||||
exports.md5_base64url = fixedBase64url(22);
|
||||
// SHA1 (20 bytes): base64 = 28 chars total (27 + "=")
|
||||
exports.sha1_hex = /^[0-9a-fA-F]{40}$/;
|
||||
exports.sha1_base64 = fixedBase64(27, "=");
|
||||
exports.sha1_base64url = fixedBase64url(27);
|
||||
// SHA256 (32 bytes): base64 = 44 chars total (43 + "=")
|
||||
exports.sha256_hex = /^[0-9a-fA-F]{64}$/;
|
||||
exports.sha256_base64 = fixedBase64(43, "=");
|
||||
exports.sha256_base64url = fixedBase64url(43);
|
||||
// SHA384 (48 bytes): base64 = 64 chars total (no padding)
|
||||
exports.sha384_hex = /^[0-9a-fA-F]{96}$/;
|
||||
exports.sha384_base64 = fixedBase64(64, "");
|
||||
exports.sha384_base64url = fixedBase64url(64);
|
||||
// SHA512 (64 bytes): base64 = 88 chars total (86 + "==")
|
||||
exports.sha512_hex = /^[0-9a-fA-F]{128}$/;
|
||||
exports.sha512_base64 = fixedBase64(86, "==");
|
||||
exports.sha512_base64url = fixedBase64url(86);
|
||||
79
node_modules/zod/v4/core/regexes.d.cts
generated
vendored
Normal file
79
node_modules/zod/v4/core/regexes.d.cts
generated
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
export declare const cuid: RegExp;
|
||||
export declare const cuid2: RegExp;
|
||||
export declare const ulid: RegExp;
|
||||
export declare const xid: RegExp;
|
||||
export declare const ksuid: RegExp;
|
||||
export declare const nanoid: RegExp;
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
export declare const duration: RegExp;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
export declare const extendedDuration: RegExp;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
export declare const guid: RegExp;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
export declare const uuid: (version?: number | undefined) => RegExp;
|
||||
export declare const uuid4: RegExp;
|
||||
export declare const uuid6: RegExp;
|
||||
export declare const uuid7: RegExp;
|
||||
/** Practical email validation */
|
||||
export declare const email: RegExp;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
export declare const html5Email: RegExp;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
export declare const rfc5322Email: RegExp;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
export declare const unicodeEmail: RegExp;
|
||||
export declare const idnEmail: RegExp;
|
||||
export declare const browserEmail: RegExp;
|
||||
export declare function emoji(): RegExp;
|
||||
export declare const ipv4: RegExp;
|
||||
export declare const ipv6: RegExp;
|
||||
export declare const mac: (delimiter?: string) => RegExp;
|
||||
export declare const cidrv4: RegExp;
|
||||
export declare const cidrv6: RegExp;
|
||||
export declare const base64: RegExp;
|
||||
export declare const base64url: RegExp;
|
||||
export declare const hostname: RegExp;
|
||||
export declare const domain: RegExp;
|
||||
export declare const e164: RegExp;
|
||||
export declare const date: RegExp;
|
||||
export declare function time(args: {
|
||||
precision?: number | null;
|
||||
}): RegExp;
|
||||
export declare function datetime(args: {
|
||||
precision?: number | null;
|
||||
offset?: boolean;
|
||||
local?: boolean;
|
||||
}): RegExp;
|
||||
export declare const string: (params?: {
|
||||
minimum?: number | undefined;
|
||||
maximum?: number | undefined;
|
||||
}) => RegExp;
|
||||
export declare const bigint: RegExp;
|
||||
export declare const integer: RegExp;
|
||||
export declare const number: RegExp;
|
||||
export declare const boolean: RegExp;
|
||||
declare const _null: RegExp;
|
||||
export { _null as null };
|
||||
declare const _undefined: RegExp;
|
||||
export { _undefined as undefined };
|
||||
export declare const lowercase: RegExp;
|
||||
export declare const uppercase: RegExp;
|
||||
export declare const hex: RegExp;
|
||||
export declare const md5_hex: RegExp;
|
||||
export declare const md5_base64: RegExp;
|
||||
export declare const md5_base64url: RegExp;
|
||||
export declare const sha1_hex: RegExp;
|
||||
export declare const sha1_base64: RegExp;
|
||||
export declare const sha1_base64url: RegExp;
|
||||
export declare const sha256_hex: RegExp;
|
||||
export declare const sha256_base64: RegExp;
|
||||
export declare const sha256_base64url: RegExp;
|
||||
export declare const sha384_hex: RegExp;
|
||||
export declare const sha384_base64: RegExp;
|
||||
export declare const sha384_base64url: RegExp;
|
||||
export declare const sha512_hex: RegExp;
|
||||
export declare const sha512_base64: RegExp;
|
||||
export declare const sha512_base64url: RegExp;
|
||||
79
node_modules/zod/v4/core/regexes.d.ts
generated
vendored
Normal file
79
node_modules/zod/v4/core/regexes.d.ts
generated
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
export declare const cuid: RegExp;
|
||||
export declare const cuid2: RegExp;
|
||||
export declare const ulid: RegExp;
|
||||
export declare const xid: RegExp;
|
||||
export declare const ksuid: RegExp;
|
||||
export declare const nanoid: RegExp;
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
export declare const duration: RegExp;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
export declare const extendedDuration: RegExp;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
export declare const guid: RegExp;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
export declare const uuid: (version?: number | undefined) => RegExp;
|
||||
export declare const uuid4: RegExp;
|
||||
export declare const uuid6: RegExp;
|
||||
export declare const uuid7: RegExp;
|
||||
/** Practical email validation */
|
||||
export declare const email: RegExp;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
export declare const html5Email: RegExp;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
export declare const rfc5322Email: RegExp;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
export declare const unicodeEmail: RegExp;
|
||||
export declare const idnEmail: RegExp;
|
||||
export declare const browserEmail: RegExp;
|
||||
export declare function emoji(): RegExp;
|
||||
export declare const ipv4: RegExp;
|
||||
export declare const ipv6: RegExp;
|
||||
export declare const mac: (delimiter?: string) => RegExp;
|
||||
export declare const cidrv4: RegExp;
|
||||
export declare const cidrv6: RegExp;
|
||||
export declare const base64: RegExp;
|
||||
export declare const base64url: RegExp;
|
||||
export declare const hostname: RegExp;
|
||||
export declare const domain: RegExp;
|
||||
export declare const e164: RegExp;
|
||||
export declare const date: RegExp;
|
||||
export declare function time(args: {
|
||||
precision?: number | null;
|
||||
}): RegExp;
|
||||
export declare function datetime(args: {
|
||||
precision?: number | null;
|
||||
offset?: boolean;
|
||||
local?: boolean;
|
||||
}): RegExp;
|
||||
export declare const string: (params?: {
|
||||
minimum?: number | undefined;
|
||||
maximum?: number | undefined;
|
||||
}) => RegExp;
|
||||
export declare const bigint: RegExp;
|
||||
export declare const integer: RegExp;
|
||||
export declare const number: RegExp;
|
||||
export declare const boolean: RegExp;
|
||||
declare const _null: RegExp;
|
||||
export { _null as null };
|
||||
declare const _undefined: RegExp;
|
||||
export { _undefined as undefined };
|
||||
export declare const lowercase: RegExp;
|
||||
export declare const uppercase: RegExp;
|
||||
export declare const hex: RegExp;
|
||||
export declare const md5_hex: RegExp;
|
||||
export declare const md5_base64: RegExp;
|
||||
export declare const md5_base64url: RegExp;
|
||||
export declare const sha1_hex: RegExp;
|
||||
export declare const sha1_base64: RegExp;
|
||||
export declare const sha1_base64url: RegExp;
|
||||
export declare const sha256_hex: RegExp;
|
||||
export declare const sha256_base64: RegExp;
|
||||
export declare const sha256_base64url: RegExp;
|
||||
export declare const sha384_hex: RegExp;
|
||||
export declare const sha384_base64: RegExp;
|
||||
export declare const sha384_base64url: RegExp;
|
||||
export declare const sha512_hex: RegExp;
|
||||
export declare const sha512_base64: RegExp;
|
||||
export declare const sha512_base64url: RegExp;
|
||||
133
node_modules/zod/v4/core/regexes.js
generated
vendored
Normal file
133
node_modules/zod/v4/core/regexes.js
generated
vendored
Normal file
@@ -0,0 +1,133 @@
|
||||
import * as util from "./util.js";
|
||||
export const cuid = /^[cC][^\s-]{8,}$/;
|
||||
export const cuid2 = /^[0-9a-z]+$/;
|
||||
export const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
|
||||
export const xid = /^[0-9a-vA-V]{20}$/;
|
||||
export const ksuid = /^[A-Za-z0-9]{27}$/;
|
||||
export const nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
export const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
export const extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
export const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
export const uuid = (version) => {
|
||||
if (!version)
|
||||
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
||||
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
||||
};
|
||||
export const uuid4 = /*@__PURE__*/ uuid(4);
|
||||
export const uuid6 = /*@__PURE__*/ uuid(6);
|
||||
export const uuid7 = /*@__PURE__*/ uuid(7);
|
||||
/** Practical email validation */
|
||||
export const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
export const html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
export const rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
export const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
|
||||
export const idnEmail = unicodeEmail;
|
||||
export const browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
|
||||
const _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
|
||||
export function emoji() {
|
||||
return new RegExp(_emoji, "u");
|
||||
}
|
||||
export const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
||||
export const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
||||
export const mac = (delimiter) => {
|
||||
const escapedDelim = util.escapeRegex(delimiter ?? ":");
|
||||
return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
|
||||
};
|
||||
export const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
||||
export const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
||||
// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
|
||||
export const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
||||
export const base64url = /^[A-Za-z0-9_-]*$/;
|
||||
// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
|
||||
// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
|
||||
export const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
|
||||
export const domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
|
||||
// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
|
||||
// E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
|
||||
export const e164 = /^\+[1-9]\d{6,14}$/;
|
||||
// const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
|
||||
const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
||||
export const date = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
|
||||
function timeSource(args) {
|
||||
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
||||
const regex = typeof args.precision === "number"
|
||||
? args.precision === -1
|
||||
? `${hhmm}`
|
||||
: args.precision === 0
|
||||
? `${hhmm}:[0-5]\\d`
|
||||
: `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}`
|
||||
: `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
||||
return regex;
|
||||
}
|
||||
export function time(args) {
|
||||
return new RegExp(`^${timeSource(args)}$`);
|
||||
}
|
||||
// Adapted from https://stackoverflow.com/a/3143231
|
||||
export function datetime(args) {
|
||||
const time = timeSource({ precision: args.precision });
|
||||
const opts = ["Z"];
|
||||
if (args.local)
|
||||
opts.push("");
|
||||
// if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
|
||||
if (args.offset)
|
||||
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
||||
const timeRegex = `${time}(?:${opts.join("|")})`;
|
||||
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
|
||||
}
|
||||
export const string = (params) => {
|
||||
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
||||
return new RegExp(`^${regex}$`);
|
||||
};
|
||||
export const bigint = /^-?\d+n?$/;
|
||||
export const integer = /^-?\d+$/;
|
||||
export const number = /^-?\d+(?:\.\d+)?$/;
|
||||
export const boolean = /^(?:true|false)$/i;
|
||||
const _null = /^null$/i;
|
||||
export { _null as null };
|
||||
const _undefined = /^undefined$/i;
|
||||
export { _undefined as undefined };
|
||||
// regex for string with no uppercase letters
|
||||
export const lowercase = /^[^A-Z]*$/;
|
||||
// regex for string with no lowercase letters
|
||||
export const uppercase = /^[^a-z]*$/;
|
||||
// regex for hexadecimal strings (any length)
|
||||
export const hex = /^[0-9a-fA-F]*$/;
|
||||
// Hash regexes for different algorithms and encodings
|
||||
// Helper function to create base64 regex with exact length and padding
|
||||
function fixedBase64(bodyLength, padding) {
|
||||
return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
|
||||
}
|
||||
// Helper function to create base64url regex with exact length (no padding)
|
||||
function fixedBase64url(length) {
|
||||
return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
|
||||
}
|
||||
// MD5 (16 bytes): base64 = 24 chars total (22 + "==")
|
||||
export const md5_hex = /^[0-9a-fA-F]{32}$/;
|
||||
export const md5_base64 = /*@__PURE__*/ fixedBase64(22, "==");
|
||||
export const md5_base64url = /*@__PURE__*/ fixedBase64url(22);
|
||||
// SHA1 (20 bytes): base64 = 28 chars total (27 + "=")
|
||||
export const sha1_hex = /^[0-9a-fA-F]{40}$/;
|
||||
export const sha1_base64 = /*@__PURE__*/ fixedBase64(27, "=");
|
||||
export const sha1_base64url = /*@__PURE__*/ fixedBase64url(27);
|
||||
// SHA256 (32 bytes): base64 = 44 chars total (43 + "=")
|
||||
export const sha256_hex = /^[0-9a-fA-F]{64}$/;
|
||||
export const sha256_base64 = /*@__PURE__*/ fixedBase64(43, "=");
|
||||
export const sha256_base64url = /*@__PURE__*/ fixedBase64url(43);
|
||||
// SHA384 (48 bytes): base64 = 64 chars total (no padding)
|
||||
export const sha384_hex = /^[0-9a-fA-F]{96}$/;
|
||||
export const sha384_base64 = /*@__PURE__*/ fixedBase64(64, "");
|
||||
export const sha384_base64url = /*@__PURE__*/ fixedBase64url(64);
|
||||
// SHA512 (64 bytes): base64 = 88 chars total (86 + "==")
|
||||
export const sha512_hex = /^[0-9a-fA-F]{128}$/;
|
||||
export const sha512_base64 = /*@__PURE__*/ fixedBase64(86, "==");
|
||||
export const sha512_base64url = /*@__PURE__*/ fixedBase64url(86);
|
||||
56
node_modules/zod/v4/core/registries.cjs
generated
vendored
Normal file
56
node_modules/zod/v4/core/registries.cjs
generated
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
"use strict";
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.globalRegistry = exports.$ZodRegistry = exports.$input = exports.$output = void 0;
|
||||
exports.registry = registry;
|
||||
exports.$output = Symbol("ZodOutput");
|
||||
exports.$input = Symbol("ZodInput");
|
||||
class $ZodRegistry {
|
||||
constructor() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
}
|
||||
add(schema, ..._meta) {
|
||||
const meta = _meta[0];
|
||||
this._map.set(schema, meta);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.set(meta.id, schema);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
clear() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
return this;
|
||||
}
|
||||
remove(schema) {
|
||||
const meta = this._map.get(schema);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.delete(meta.id);
|
||||
}
|
||||
this._map.delete(schema);
|
||||
return this;
|
||||
}
|
||||
get(schema) {
|
||||
// return this._map.get(schema) as any;
|
||||
// inherit metadata
|
||||
const p = schema._zod.parent;
|
||||
if (p) {
|
||||
const pm = { ...(this.get(p) ?? {}) };
|
||||
delete pm.id; // do not inherit id
|
||||
const f = { ...pm, ...this._map.get(schema) };
|
||||
return Object.keys(f).length ? f : undefined;
|
||||
}
|
||||
return this._map.get(schema);
|
||||
}
|
||||
has(schema) {
|
||||
return this._map.has(schema);
|
||||
}
|
||||
}
|
||||
exports.$ZodRegistry = $ZodRegistry;
|
||||
// registries
|
||||
function registry() {
|
||||
return new $ZodRegistry();
|
||||
}
|
||||
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
|
||||
exports.globalRegistry = globalThis.__zod_globalRegistry;
|
||||
35
node_modules/zod/v4/core/registries.d.cts
generated
vendored
Normal file
35
node_modules/zod/v4/core/registries.d.cts
generated
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
import type * as core from "./core.cjs";
|
||||
import type { $ZodType } from "./schemas.cjs";
|
||||
export declare const $output: unique symbol;
|
||||
export type $output = typeof $output;
|
||||
export declare const $input: unique symbol;
|
||||
export type $input = typeof $input;
|
||||
export type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
|
||||
[K in keyof P]: $replace<P[K], S>;
|
||||
}) => $replace<R, S> : Meta extends object ? {
|
||||
[K in keyof Meta]: $replace<Meta[K], S>;
|
||||
} : Meta;
|
||||
type MetadataType = object | undefined;
|
||||
export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
|
||||
_meta: Meta;
|
||||
_schema: Schema;
|
||||
_map: WeakMap<Schema, $replace<Meta, Schema>>;
|
||||
_idmap: Map<string, Schema>;
|
||||
add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
|
||||
clear(): this;
|
||||
remove(schema: Schema): this;
|
||||
get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
|
||||
has(schema: Schema): boolean;
|
||||
}
|
||||
export interface JSONSchemaMeta {
|
||||
id?: string | undefined;
|
||||
title?: string | undefined;
|
||||
description?: string | undefined;
|
||||
deprecated?: boolean | undefined;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
export interface GlobalMeta extends JSONSchemaMeta {
|
||||
}
|
||||
export declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
|
||||
export declare const globalRegistry: $ZodRegistry<GlobalMeta>;
|
||||
export {};
|
||||
35
node_modules/zod/v4/core/registries.d.ts
generated
vendored
Normal file
35
node_modules/zod/v4/core/registries.d.ts
generated
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
import type * as core from "./core.js";
|
||||
import type { $ZodType } from "./schemas.js";
|
||||
export declare const $output: unique symbol;
|
||||
export type $output = typeof $output;
|
||||
export declare const $input: unique symbol;
|
||||
export type $input = typeof $input;
|
||||
export type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
|
||||
[K in keyof P]: $replace<P[K], S>;
|
||||
}) => $replace<R, S> : Meta extends object ? {
|
||||
[K in keyof Meta]: $replace<Meta[K], S>;
|
||||
} : Meta;
|
||||
type MetadataType = object | undefined;
|
||||
export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
|
||||
_meta: Meta;
|
||||
_schema: Schema;
|
||||
_map: WeakMap<Schema, $replace<Meta, Schema>>;
|
||||
_idmap: Map<string, Schema>;
|
||||
add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
|
||||
clear(): this;
|
||||
remove(schema: Schema): this;
|
||||
get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
|
||||
has(schema: Schema): boolean;
|
||||
}
|
||||
export interface JSONSchemaMeta {
|
||||
id?: string | undefined;
|
||||
title?: string | undefined;
|
||||
description?: string | undefined;
|
||||
deprecated?: boolean | undefined;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
export interface GlobalMeta extends JSONSchemaMeta {
|
||||
}
|
||||
export declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
|
||||
export declare const globalRegistry: $ZodRegistry<GlobalMeta>;
|
||||
export {};
|
||||
51
node_modules/zod/v4/core/registries.js
generated
vendored
Normal file
51
node_modules/zod/v4/core/registries.js
generated
vendored
Normal file
@@ -0,0 +1,51 @@
|
||||
var _a;
|
||||
export const $output = Symbol("ZodOutput");
|
||||
export const $input = Symbol("ZodInput");
|
||||
export class $ZodRegistry {
|
||||
constructor() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
}
|
||||
add(schema, ..._meta) {
|
||||
const meta = _meta[0];
|
||||
this._map.set(schema, meta);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.set(meta.id, schema);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
clear() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
return this;
|
||||
}
|
||||
remove(schema) {
|
||||
const meta = this._map.get(schema);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.delete(meta.id);
|
||||
}
|
||||
this._map.delete(schema);
|
||||
return this;
|
||||
}
|
||||
get(schema) {
|
||||
// return this._map.get(schema) as any;
|
||||
// inherit metadata
|
||||
const p = schema._zod.parent;
|
||||
if (p) {
|
||||
const pm = { ...(this.get(p) ?? {}) };
|
||||
delete pm.id; // do not inherit id
|
||||
const f = { ...pm, ...this._map.get(schema) };
|
||||
return Object.keys(f).length ? f : undefined;
|
||||
}
|
||||
return this._map.get(schema);
|
||||
}
|
||||
has(schema) {
|
||||
return this._map.has(schema);
|
||||
}
|
||||
}
|
||||
// registries
|
||||
export function registry() {
|
||||
return new $ZodRegistry();
|
||||
}
|
||||
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
|
||||
export const globalRegistry = globalThis.__zod_globalRegistry;
|
||||
2124
node_modules/zod/v4/core/schemas.cjs
generated
vendored
Normal file
2124
node_modules/zod/v4/core/schemas.cjs
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1146
node_modules/zod/v4/core/schemas.d.cts
generated
vendored
Normal file
1146
node_modules/zod/v4/core/schemas.d.cts
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1146
node_modules/zod/v4/core/schemas.d.ts
generated
vendored
Normal file
1146
node_modules/zod/v4/core/schemas.d.ts
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2093
node_modules/zod/v4/core/schemas.js
generated
vendored
Normal file
2093
node_modules/zod/v4/core/schemas.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2
node_modules/zod/v4/core/standard-schema.cjs
generated
vendored
Normal file
2
node_modules/zod/v4/core/standard-schema.cjs
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
126
node_modules/zod/v4/core/standard-schema.d.cts
generated
vendored
Normal file
126
node_modules/zod/v4/core/standard-schema.d.cts
generated
vendored
Normal file
@@ -0,0 +1,126 @@
|
||||
/** The Standard interface. */
|
||||
export interface StandardTypedV1<Input = unknown, Output = Input> {
|
||||
/** The Standard properties. */
|
||||
readonly "~standard": StandardTypedV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardTypedV1 {
|
||||
/** The Standard properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> {
|
||||
/** The version number of the standard. */
|
||||
readonly version: 1;
|
||||
/** The vendor name of the schema library. */
|
||||
readonly vendor: string;
|
||||
/** Inferred types associated with the schema. */
|
||||
readonly types?: Types<Input, Output> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> {
|
||||
/** The input type of the schema. */
|
||||
readonly input: Input;
|
||||
/** The output type of the schema. */
|
||||
readonly output: Output;
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
|
||||
}
|
||||
/** The Standard Schema interface. */
|
||||
export interface StandardSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard Schema properties. */
|
||||
readonly "~standard": StandardSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardSchemaV1 {
|
||||
/** The Standard Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Validates unknown input values. */
|
||||
readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
|
||||
}
|
||||
/** The result interface of the validate function. */
|
||||
type Result<Output> = SuccessResult<Output> | FailureResult;
|
||||
/** The result interface if validation succeeds. */
|
||||
interface SuccessResult<Output> {
|
||||
/** The typed output value. */
|
||||
readonly value: Output;
|
||||
/** The absence of issues indicates success. */
|
||||
readonly issues?: undefined;
|
||||
}
|
||||
interface Options {
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The result interface if validation fails. */
|
||||
interface FailureResult {
|
||||
/** The issues of failed validation. */
|
||||
readonly issues: ReadonlyArray<Issue>;
|
||||
}
|
||||
/** The issue interface of the failure output. */
|
||||
interface Issue {
|
||||
/** The error message of the issue. */
|
||||
readonly message: string;
|
||||
/** The path of the issue, if any. */
|
||||
readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
|
||||
}
|
||||
/** The path segment interface of the issue. */
|
||||
interface PathSegment {
|
||||
/** The key representing a path segment. */
|
||||
readonly key: PropertyKey;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
/** The Standard JSON Schema interface. */
|
||||
export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard JSON Schema properties. */
|
||||
readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardJSONSchemaV1 {
|
||||
/** The Standard JSON Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Methods for generating the input/output JSON Schema. */
|
||||
readonly jsonSchema: Converter;
|
||||
}
|
||||
/** The Standard JSON Schema converter interface. */
|
||||
interface Converter {
|
||||
/** Converts the input type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
/** Converts the output type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
}
|
||||
/** The target version of the generated JSON Schema.
|
||||
*
|
||||
* It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
|
||||
*
|
||||
* The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
|
||||
*
|
||||
* All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
|
||||
*/
|
||||
type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
|
||||
/** The options for the input/output methods. */
|
||||
interface Options {
|
||||
/** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
|
||||
readonly target: Target;
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
|
||||
}
|
||||
/**
|
||||
* An interface that combines StandardJSONSchema and StandardSchema.
|
||||
*/
|
||||
export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
|
||||
"~standard": StandardSchemaWithJSONProps<Input, Output>;
|
||||
}
|
||||
126
node_modules/zod/v4/core/standard-schema.d.ts
generated
vendored
Normal file
126
node_modules/zod/v4/core/standard-schema.d.ts
generated
vendored
Normal file
@@ -0,0 +1,126 @@
|
||||
/** The Standard interface. */
|
||||
export interface StandardTypedV1<Input = unknown, Output = Input> {
|
||||
/** The Standard properties. */
|
||||
readonly "~standard": StandardTypedV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardTypedV1 {
|
||||
/** The Standard properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> {
|
||||
/** The version number of the standard. */
|
||||
readonly version: 1;
|
||||
/** The vendor name of the schema library. */
|
||||
readonly vendor: string;
|
||||
/** Inferred types associated with the schema. */
|
||||
readonly types?: Types<Input, Output> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> {
|
||||
/** The input type of the schema. */
|
||||
readonly input: Input;
|
||||
/** The output type of the schema. */
|
||||
readonly output: Output;
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
|
||||
}
|
||||
/** The Standard Schema interface. */
|
||||
export interface StandardSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard Schema properties. */
|
||||
readonly "~standard": StandardSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardSchemaV1 {
|
||||
/** The Standard Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Validates unknown input values. */
|
||||
readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
|
||||
}
|
||||
/** The result interface of the validate function. */
|
||||
type Result<Output> = SuccessResult<Output> | FailureResult;
|
||||
/** The result interface if validation succeeds. */
|
||||
interface SuccessResult<Output> {
|
||||
/** The typed output value. */
|
||||
readonly value: Output;
|
||||
/** The absence of issues indicates success. */
|
||||
readonly issues?: undefined;
|
||||
}
|
||||
interface Options {
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The result interface if validation fails. */
|
||||
interface FailureResult {
|
||||
/** The issues of failed validation. */
|
||||
readonly issues: ReadonlyArray<Issue>;
|
||||
}
|
||||
/** The issue interface of the failure output. */
|
||||
interface Issue {
|
||||
/** The error message of the issue. */
|
||||
readonly message: string;
|
||||
/** The path of the issue, if any. */
|
||||
readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
|
||||
}
|
||||
/** The path segment interface of the issue. */
|
||||
interface PathSegment {
|
||||
/** The key representing a path segment. */
|
||||
readonly key: PropertyKey;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
/** The Standard JSON Schema interface. */
|
||||
export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard JSON Schema properties. */
|
||||
readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardJSONSchemaV1 {
|
||||
/** The Standard JSON Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Methods for generating the input/output JSON Schema. */
|
||||
readonly jsonSchema: Converter;
|
||||
}
|
||||
/** The Standard JSON Schema converter interface. */
|
||||
interface Converter {
|
||||
/** Converts the input type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
/** Converts the output type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
}
|
||||
/** The target version of the generated JSON Schema.
|
||||
*
|
||||
* It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
|
||||
*
|
||||
* The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
|
||||
*
|
||||
* All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
|
||||
*/
|
||||
type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
|
||||
/** The options for the input/output methods. */
|
||||
interface Options {
|
||||
/** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
|
||||
readonly target: Target;
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
|
||||
}
|
||||
/**
|
||||
* An interface that combines StandardJSONSchema and StandardSchema.
|
||||
*/
|
||||
export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
|
||||
"~standard": StandardSchemaWithJSONProps<Input, Output>;
|
||||
}
|
||||
1
node_modules/zod/v4/core/standard-schema.js
generated
vendored
Normal file
1
node_modules/zod/v4/core/standard-schema.js
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export {};
|
||||
446
node_modules/zod/v4/core/to-json-schema.cjs
generated
vendored
Normal file
446
node_modules/zod/v4/core/to-json-schema.cjs
generated
vendored
Normal file
@@ -0,0 +1,446 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createStandardJSONSchemaMethod = exports.createToJSONSchemaMethod = void 0;
|
||||
exports.initializeContext = initializeContext;
|
||||
exports.process = process;
|
||||
exports.extractDefs = extractDefs;
|
||||
exports.finalize = finalize;
|
||||
const registries_js_1 = require("./registries.cjs");
|
||||
// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
|
||||
// return {
|
||||
// processor: inputs.processor,
|
||||
// metadataRegistry: inputs.metadata ?? globalRegistry,
|
||||
// target: inputs.target ?? "draft-2020-12",
|
||||
// unrepresentable: inputs.unrepresentable ?? "throw",
|
||||
// };
|
||||
// }
|
||||
function initializeContext(params) {
|
||||
// Normalize target: convert old non-hyphenated versions to hyphenated versions
|
||||
let target = params?.target ?? "draft-2020-12";
|
||||
if (target === "draft-4")
|
||||
target = "draft-04";
|
||||
if (target === "draft-7")
|
||||
target = "draft-07";
|
||||
return {
|
||||
processors: params.processors ?? {},
|
||||
metadataRegistry: params?.metadata ?? registries_js_1.globalRegistry,
|
||||
target,
|
||||
unrepresentable: params?.unrepresentable ?? "throw",
|
||||
override: params?.override ?? (() => { }),
|
||||
io: params?.io ?? "output",
|
||||
counter: 0,
|
||||
seen: new Map(),
|
||||
cycles: params?.cycles ?? "ref",
|
||||
reused: params?.reused ?? "inline",
|
||||
external: params?.external ?? undefined,
|
||||
};
|
||||
}
|
||||
function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
||||
var _a;
|
||||
const def = schema._zod.def;
|
||||
// check for schema in seens
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (seen) {
|
||||
seen.count++;
|
||||
// check if cycle
|
||||
const isCycle = _params.schemaPath.includes(schema);
|
||||
if (isCycle) {
|
||||
seen.cycle = _params.path;
|
||||
}
|
||||
return seen.schema;
|
||||
}
|
||||
// initialize
|
||||
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
||||
ctx.seen.set(schema, result);
|
||||
// custom method overrides default behavior
|
||||
const overrideSchema = schema._zod.toJSONSchema?.();
|
||||
if (overrideSchema) {
|
||||
result.schema = overrideSchema;
|
||||
}
|
||||
else {
|
||||
const params = {
|
||||
..._params,
|
||||
schemaPath: [..._params.schemaPath, schema],
|
||||
path: _params.path,
|
||||
};
|
||||
if (schema._zod.processJSONSchema) {
|
||||
schema._zod.processJSONSchema(ctx, result.schema, params);
|
||||
}
|
||||
else {
|
||||
const _json = result.schema;
|
||||
const processor = ctx.processors[def.type];
|
||||
if (!processor) {
|
||||
throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
|
||||
}
|
||||
processor(schema, ctx, _json, params);
|
||||
}
|
||||
const parent = schema._zod.parent;
|
||||
if (parent) {
|
||||
// Also set ref if processor didn't (for inheritance)
|
||||
if (!result.ref)
|
||||
result.ref = parent;
|
||||
process(parent, ctx, params);
|
||||
ctx.seen.get(parent).isParent = true;
|
||||
}
|
||||
}
|
||||
// metadata
|
||||
const meta = ctx.metadataRegistry.get(schema);
|
||||
if (meta)
|
||||
Object.assign(result.schema, meta);
|
||||
if (ctx.io === "input" && isTransforming(schema)) {
|
||||
// examples/defaults only apply to output type of pipe
|
||||
delete result.schema.examples;
|
||||
delete result.schema.default;
|
||||
}
|
||||
// set prefault as default
|
||||
if (ctx.io === "input" && result.schema._prefault)
|
||||
(_a = result.schema).default ?? (_a.default = result.schema._prefault);
|
||||
delete result.schema._prefault;
|
||||
// pulling fresh from ctx.seen in case it was overwritten
|
||||
const _result = ctx.seen.get(schema);
|
||||
return _result.schema;
|
||||
}
|
||||
function extractDefs(ctx, schema
|
||||
// params: EmitParams
|
||||
) {
|
||||
// iterate over seen map;
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// Track ids to detect duplicates across different schemas
|
||||
const idToSchema = new Map();
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
const existing = idToSchema.get(id);
|
||||
if (existing && existing !== entry[0]) {
|
||||
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
|
||||
}
|
||||
idToSchema.set(id, entry[0]);
|
||||
}
|
||||
}
|
||||
// returns a ref to the schema
|
||||
// defId will be empty if the ref points to an external schema (or #)
|
||||
const makeURI = (entry) => {
|
||||
// comparing the seen objects because sometimes
|
||||
// multiple schemas map to the same seen object.
|
||||
// e.g. lazy
|
||||
// external is configured
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
if (ctx.external) {
|
||||
const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
|
||||
// check if schema is in the external registry
|
||||
const uriGenerator = ctx.external.uri ?? ((id) => id);
|
||||
if (externalId) {
|
||||
return { ref: uriGenerator(externalId) };
|
||||
}
|
||||
// otherwise, add to __shared
|
||||
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
|
||||
entry[1].defId = id; // set defId so it will be reused if needed
|
||||
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
|
||||
}
|
||||
if (entry[1] === root) {
|
||||
return { ref: "#" };
|
||||
}
|
||||
// self-contained schema
|
||||
const uriPrefix = `#`;
|
||||
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
||||
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
|
||||
return { defId, ref: defUriPrefix + defId };
|
||||
};
|
||||
// stored cached version in `def` property
|
||||
// remove all properties, set $ref
|
||||
const extractToDef = (entry) => {
|
||||
// if the schema is already a reference, do not extract it
|
||||
if (entry[1].schema.$ref) {
|
||||
return;
|
||||
}
|
||||
const seen = entry[1];
|
||||
const { ref, defId } = makeURI(entry);
|
||||
seen.def = { ...seen.schema };
|
||||
// defId won't be set if the schema is a reference to an external schema
|
||||
// or if the schema is the root schema
|
||||
if (defId)
|
||||
seen.defId = defId;
|
||||
// wipe away all properties except $ref
|
||||
const schema = seen.schema;
|
||||
for (const key in schema) {
|
||||
delete schema[key];
|
||||
}
|
||||
schema.$ref = ref;
|
||||
};
|
||||
// throw on cycles
|
||||
// break cycles
|
||||
if (ctx.cycles === "throw") {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.cycle) {
|
||||
throw new Error("Cycle detected: " +
|
||||
`#/${seen.cycle?.join("/")}/<root>` +
|
||||
'\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
||||
}
|
||||
}
|
||||
}
|
||||
// extract schemas into $defs
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
// convert root schema to # $ref
|
||||
if (schema === entry[0]) {
|
||||
extractToDef(entry); // this has special handling for the root schema
|
||||
continue;
|
||||
}
|
||||
// extract schemas that are in the external registry
|
||||
if (ctx.external) {
|
||||
const ext = ctx.external.registry.get(entry[0])?.id;
|
||||
if (schema !== entry[0] && ext) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// extract schemas with `id` meta
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// break cycles
|
||||
if (seen.cycle) {
|
||||
// any
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// extract reused schemas
|
||||
if (seen.count > 1) {
|
||||
if (ctx.reused === "ref") {
|
||||
extractToDef(entry);
|
||||
// biome-ignore lint:
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function finalize(ctx, schema) {
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// flatten refs - inherit properties from parent schemas
|
||||
const flattenRef = (zodSchema) => {
|
||||
const seen = ctx.seen.get(zodSchema);
|
||||
// already processed
|
||||
if (seen.ref === null)
|
||||
return;
|
||||
const schema = seen.def ?? seen.schema;
|
||||
const _cached = { ...schema };
|
||||
const ref = seen.ref;
|
||||
seen.ref = null; // prevent infinite recursion
|
||||
if (ref) {
|
||||
flattenRef(ref);
|
||||
const refSeen = ctx.seen.get(ref);
|
||||
const refSchema = refSeen.schema;
|
||||
// merge referenced schema into current
|
||||
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
|
||||
// older drafts can't combine $ref with other properties
|
||||
schema.allOf = schema.allOf ?? [];
|
||||
schema.allOf.push(refSchema);
|
||||
}
|
||||
else {
|
||||
Object.assign(schema, refSchema);
|
||||
}
|
||||
// restore child's own properties (child wins)
|
||||
Object.assign(schema, _cached);
|
||||
const isParentRef = zodSchema._zod.parent === ref;
|
||||
// For parent chain, child is a refinement - remove parent-only properties
|
||||
if (isParentRef) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (!(key in _cached)) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
// When ref was extracted to $defs, remove properties that match the definition
|
||||
if (refSchema.$ref && refSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// If parent was extracted (has $ref), propagate $ref to this schema
|
||||
// This handles cases like: readonly().meta({id}).describe()
|
||||
// where processor sets ref to innerType but parent should be referenced
|
||||
const parent = zodSchema._zod.parent;
|
||||
if (parent && parent !== ref) {
|
||||
// Ensure parent is processed first so its def has inherited properties
|
||||
flattenRef(parent);
|
||||
const parentSeen = ctx.seen.get(parent);
|
||||
if (parentSeen?.schema.$ref) {
|
||||
schema.$ref = parentSeen.schema.$ref;
|
||||
// De-duplicate with parent's definition
|
||||
if (parentSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// execute overrides
|
||||
ctx.override({
|
||||
zodSchema: zodSchema,
|
||||
jsonSchema: schema,
|
||||
path: seen.path ?? [],
|
||||
});
|
||||
};
|
||||
for (const entry of [...ctx.seen.entries()].reverse()) {
|
||||
flattenRef(entry[0]);
|
||||
}
|
||||
const result = {};
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
||||
}
|
||||
else if (ctx.target === "draft-07") {
|
||||
result.$schema = "http://json-schema.org/draft-07/schema#";
|
||||
}
|
||||
else if (ctx.target === "draft-04") {
|
||||
result.$schema = "http://json-schema.org/draft-04/schema#";
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
// OpenAPI 3.0 schema objects should not include a $schema property
|
||||
}
|
||||
else {
|
||||
// Arbitrary string values are allowed but won't have a $schema property set
|
||||
}
|
||||
if (ctx.external?.uri) {
|
||||
const id = ctx.external.registry.get(schema)?.id;
|
||||
if (!id)
|
||||
throw new Error("Schema is missing an `id` property");
|
||||
result.$id = ctx.external.uri(id);
|
||||
}
|
||||
Object.assign(result, root.def ?? root.schema);
|
||||
// build defs object
|
||||
const defs = ctx.external?.defs ?? {};
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.def && seen.defId) {
|
||||
defs[seen.defId] = seen.def;
|
||||
}
|
||||
}
|
||||
// set definitions in result
|
||||
if (ctx.external) {
|
||||
}
|
||||
else {
|
||||
if (Object.keys(defs).length > 0) {
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$defs = defs;
|
||||
}
|
||||
else {
|
||||
result.definitions = defs;
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
// this "finalizes" this schema and ensures all cycles are removed
|
||||
// each call to finalize() is functionally independent
|
||||
// though the seen map is shared
|
||||
const finalized = JSON.parse(JSON.stringify(result));
|
||||
Object.defineProperty(finalized, "~standard", {
|
||||
value: {
|
||||
...schema["~standard"],
|
||||
jsonSchema: {
|
||||
input: (0, exports.createStandardJSONSchemaMethod)(schema, "input", ctx.processors),
|
||||
output: (0, exports.createStandardJSONSchemaMethod)(schema, "output", ctx.processors),
|
||||
},
|
||||
},
|
||||
enumerable: false,
|
||||
writable: false,
|
||||
});
|
||||
return finalized;
|
||||
}
|
||||
catch (_err) {
|
||||
throw new Error("Error converting schema to JSON.");
|
||||
}
|
||||
}
|
||||
function isTransforming(_schema, _ctx) {
|
||||
const ctx = _ctx ?? { seen: new Set() };
|
||||
if (ctx.seen.has(_schema))
|
||||
return false;
|
||||
ctx.seen.add(_schema);
|
||||
const def = _schema._zod.def;
|
||||
if (def.type === "transform")
|
||||
return true;
|
||||
if (def.type === "array")
|
||||
return isTransforming(def.element, ctx);
|
||||
if (def.type === "set")
|
||||
return isTransforming(def.valueType, ctx);
|
||||
if (def.type === "lazy")
|
||||
return isTransforming(def.getter(), ctx);
|
||||
if (def.type === "promise" ||
|
||||
def.type === "optional" ||
|
||||
def.type === "nonoptional" ||
|
||||
def.type === "nullable" ||
|
||||
def.type === "readonly" ||
|
||||
def.type === "default" ||
|
||||
def.type === "prefault") {
|
||||
return isTransforming(def.innerType, ctx);
|
||||
}
|
||||
if (def.type === "intersection") {
|
||||
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
||||
}
|
||||
if (def.type === "record" || def.type === "map") {
|
||||
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
||||
}
|
||||
if (def.type === "pipe") {
|
||||
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
||||
}
|
||||
if (def.type === "object") {
|
||||
for (const key in def.shape) {
|
||||
if (isTransforming(def.shape[key], ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "union") {
|
||||
for (const option of def.options) {
|
||||
if (isTransforming(option, ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "tuple") {
|
||||
for (const item of def.items) {
|
||||
if (isTransforming(item, ctx))
|
||||
return true;
|
||||
}
|
||||
if (def.rest && isTransforming(def.rest, ctx))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
|
||||
const ctx = initializeContext({ ...params, processors });
|
||||
process(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
exports.createToJSONSchemaMethod = createToJSONSchemaMethod;
|
||||
const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
|
||||
const { libraryOptions, target } = params ?? {};
|
||||
const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
|
||||
process(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
exports.createStandardJSONSchemaMethod = createStandardJSONSchemaMethod;
|
||||
114
node_modules/zod/v4/core/to-json-schema.d.cts
generated
vendored
Normal file
114
node_modules/zod/v4/core/to-json-schema.d.cts
generated
vendored
Normal file
@@ -0,0 +1,114 @@
|
||||
import type * as core from "../core/index.cjs";
|
||||
import type * as JSONSchema from "./json-schema.cjs";
|
||||
import { type $ZodRegistry } from "./registries.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from "./standard-schema.cjs";
|
||||
export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void;
|
||||
export interface JSONSchemaGeneratorParams {
|
||||
processors: Record<string, Processor>;
|
||||
/** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
|
||||
* @default globalRegistry */
|
||||
metadata?: $ZodRegistry<Record<string, any>>;
|
||||
/** The JSON Schema version to target.
|
||||
* - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
|
||||
* - `"draft-07"` — JSON Schema Draft 7
|
||||
* - `"draft-04"` — JSON Schema Draft 4
|
||||
* - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
|
||||
target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
|
||||
/** How to handle unrepresentable types.
|
||||
* - `"throw"` — Default. Unrepresentable types throw an error
|
||||
* - `"any"` — Unrepresentable types become `{}` */
|
||||
unrepresentable?: "throw" | "any";
|
||||
/** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
|
||||
override?: (ctx: {
|
||||
zodSchema: schemas.$ZodTypes;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
|
||||
* - `"output"` — Default. Convert the output schema.
|
||||
* - `"input"` — Convert the input schema. */
|
||||
io?: "input" | "output";
|
||||
cycles?: "ref" | "throw";
|
||||
reused?: "ref" | "inline";
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
/**
|
||||
* Parameters for the toJSONSchema function.
|
||||
*/
|
||||
export type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
|
||||
/**
|
||||
* Parameters for the toJSONSchema function when passing a registry.
|
||||
*/
|
||||
export interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
|
||||
uri?: (id: string) => string;
|
||||
}
|
||||
export interface ProcessParams {
|
||||
schemaPath: schemas.$ZodType[];
|
||||
path: (string | number)[];
|
||||
}
|
||||
export interface Seen {
|
||||
/** JSON Schema result for this Zod schema */
|
||||
schema: JSONSchema.BaseSchema;
|
||||
/** A cached version of the schema that doesn't get overwritten during ref resolution */
|
||||
def?: JSONSchema.BaseSchema;
|
||||
defId?: string | undefined;
|
||||
/** Number of times this schema was encountered during traversal */
|
||||
count: number;
|
||||
/** Cycle path */
|
||||
cycle?: (string | number)[] | undefined;
|
||||
isParent?: boolean | undefined;
|
||||
/** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
|
||||
ref?: schemas.$ZodType | null;
|
||||
/** JSON Schema property path for this schema */
|
||||
path?: (string | number)[] | undefined;
|
||||
}
|
||||
export interface ToJSONSchemaContext {
|
||||
processors: Record<string, Processor>;
|
||||
metadataRegistry: $ZodRegistry<Record<string, any>>;
|
||||
target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
|
||||
unrepresentable: "throw" | "any";
|
||||
override: (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
io: "input" | "output";
|
||||
counter: number;
|
||||
seen: Map<schemas.$ZodType, Seen>;
|
||||
cycles: "ref" | "throw";
|
||||
reused: "ref" | "inline";
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
export declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;
|
||||
export declare function process<T extends schemas.$ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
export declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
|
||||
export declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
|
||||
export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
|
||||
export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {
|
||||
"~standard": ZodStandardSchemaWithJSON<T>;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
export declare const createToJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
|
||||
export declare const createStandardJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, io: "input" | "output", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => JSONSchema.BaseSchema;
|
||||
export {};
|
||||
114
node_modules/zod/v4/core/to-json-schema.d.ts
generated
vendored
Normal file
114
node_modules/zod/v4/core/to-json-schema.d.ts
generated
vendored
Normal file
@@ -0,0 +1,114 @@
|
||||
import type * as core from "../core/index.js";
|
||||
import type * as JSONSchema from "./json-schema.js";
|
||||
import { type $ZodRegistry } from "./registries.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from "./standard-schema.js";
|
||||
export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void;
|
||||
export interface JSONSchemaGeneratorParams {
|
||||
processors: Record<string, Processor>;
|
||||
/** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
|
||||
* @default globalRegistry */
|
||||
metadata?: $ZodRegistry<Record<string, any>>;
|
||||
/** The JSON Schema version to target.
|
||||
* - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
|
||||
* - `"draft-07"` — JSON Schema Draft 7
|
||||
* - `"draft-04"` — JSON Schema Draft 4
|
||||
* - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
|
||||
target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
|
||||
/** How to handle unrepresentable types.
|
||||
* - `"throw"` — Default. Unrepresentable types throw an error
|
||||
* - `"any"` — Unrepresentable types become `{}` */
|
||||
unrepresentable?: "throw" | "any";
|
||||
/** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
|
||||
override?: (ctx: {
|
||||
zodSchema: schemas.$ZodTypes;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
|
||||
* - `"output"` — Default. Convert the output schema.
|
||||
* - `"input"` — Convert the input schema. */
|
||||
io?: "input" | "output";
|
||||
cycles?: "ref" | "throw";
|
||||
reused?: "ref" | "inline";
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
/**
|
||||
* Parameters for the toJSONSchema function.
|
||||
*/
|
||||
export type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
|
||||
/**
|
||||
* Parameters for the toJSONSchema function when passing a registry.
|
||||
*/
|
||||
export interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
|
||||
uri?: (id: string) => string;
|
||||
}
|
||||
export interface ProcessParams {
|
||||
schemaPath: schemas.$ZodType[];
|
||||
path: (string | number)[];
|
||||
}
|
||||
export interface Seen {
|
||||
/** JSON Schema result for this Zod schema */
|
||||
schema: JSONSchema.BaseSchema;
|
||||
/** A cached version of the schema that doesn't get overwritten during ref resolution */
|
||||
def?: JSONSchema.BaseSchema;
|
||||
defId?: string | undefined;
|
||||
/** Number of times this schema was encountered during traversal */
|
||||
count: number;
|
||||
/** Cycle path */
|
||||
cycle?: (string | number)[] | undefined;
|
||||
isParent?: boolean | undefined;
|
||||
/** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
|
||||
ref?: schemas.$ZodType | null;
|
||||
/** JSON Schema property path for this schema */
|
||||
path?: (string | number)[] | undefined;
|
||||
}
|
||||
export interface ToJSONSchemaContext {
|
||||
processors: Record<string, Processor>;
|
||||
metadataRegistry: $ZodRegistry<Record<string, any>>;
|
||||
target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
|
||||
unrepresentable: "throw" | "any";
|
||||
override: (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
io: "input" | "output";
|
||||
counter: number;
|
||||
seen: Map<schemas.$ZodType, Seen>;
|
||||
cycles: "ref" | "throw";
|
||||
reused: "ref" | "inline";
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
export declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;
|
||||
export declare function process<T extends schemas.$ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
export declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
|
||||
export declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
|
||||
export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
|
||||
export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {
|
||||
"~standard": ZodStandardSchemaWithJSON<T>;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
export declare const createToJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
|
||||
export declare const createStandardJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, io: "input" | "output", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => JSONSchema.BaseSchema;
|
||||
export {};
|
||||
437
node_modules/zod/v4/core/to-json-schema.js
generated
vendored
Normal file
437
node_modules/zod/v4/core/to-json-schema.js
generated
vendored
Normal file
@@ -0,0 +1,437 @@
|
||||
import { globalRegistry } from "./registries.js";
|
||||
// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
|
||||
// return {
|
||||
// processor: inputs.processor,
|
||||
// metadataRegistry: inputs.metadata ?? globalRegistry,
|
||||
// target: inputs.target ?? "draft-2020-12",
|
||||
// unrepresentable: inputs.unrepresentable ?? "throw",
|
||||
// };
|
||||
// }
|
||||
export function initializeContext(params) {
|
||||
// Normalize target: convert old non-hyphenated versions to hyphenated versions
|
||||
let target = params?.target ?? "draft-2020-12";
|
||||
if (target === "draft-4")
|
||||
target = "draft-04";
|
||||
if (target === "draft-7")
|
||||
target = "draft-07";
|
||||
return {
|
||||
processors: params.processors ?? {},
|
||||
metadataRegistry: params?.metadata ?? globalRegistry,
|
||||
target,
|
||||
unrepresentable: params?.unrepresentable ?? "throw",
|
||||
override: params?.override ?? (() => { }),
|
||||
io: params?.io ?? "output",
|
||||
counter: 0,
|
||||
seen: new Map(),
|
||||
cycles: params?.cycles ?? "ref",
|
||||
reused: params?.reused ?? "inline",
|
||||
external: params?.external ?? undefined,
|
||||
};
|
||||
}
|
||||
export function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
||||
var _a;
|
||||
const def = schema._zod.def;
|
||||
// check for schema in seens
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (seen) {
|
||||
seen.count++;
|
||||
// check if cycle
|
||||
const isCycle = _params.schemaPath.includes(schema);
|
||||
if (isCycle) {
|
||||
seen.cycle = _params.path;
|
||||
}
|
||||
return seen.schema;
|
||||
}
|
||||
// initialize
|
||||
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
||||
ctx.seen.set(schema, result);
|
||||
// custom method overrides default behavior
|
||||
const overrideSchema = schema._zod.toJSONSchema?.();
|
||||
if (overrideSchema) {
|
||||
result.schema = overrideSchema;
|
||||
}
|
||||
else {
|
||||
const params = {
|
||||
..._params,
|
||||
schemaPath: [..._params.schemaPath, schema],
|
||||
path: _params.path,
|
||||
};
|
||||
if (schema._zod.processJSONSchema) {
|
||||
schema._zod.processJSONSchema(ctx, result.schema, params);
|
||||
}
|
||||
else {
|
||||
const _json = result.schema;
|
||||
const processor = ctx.processors[def.type];
|
||||
if (!processor) {
|
||||
throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
|
||||
}
|
||||
processor(schema, ctx, _json, params);
|
||||
}
|
||||
const parent = schema._zod.parent;
|
||||
if (parent) {
|
||||
// Also set ref if processor didn't (for inheritance)
|
||||
if (!result.ref)
|
||||
result.ref = parent;
|
||||
process(parent, ctx, params);
|
||||
ctx.seen.get(parent).isParent = true;
|
||||
}
|
||||
}
|
||||
// metadata
|
||||
const meta = ctx.metadataRegistry.get(schema);
|
||||
if (meta)
|
||||
Object.assign(result.schema, meta);
|
||||
if (ctx.io === "input" && isTransforming(schema)) {
|
||||
// examples/defaults only apply to output type of pipe
|
||||
delete result.schema.examples;
|
||||
delete result.schema.default;
|
||||
}
|
||||
// set prefault as default
|
||||
if (ctx.io === "input" && result.schema._prefault)
|
||||
(_a = result.schema).default ?? (_a.default = result.schema._prefault);
|
||||
delete result.schema._prefault;
|
||||
// pulling fresh from ctx.seen in case it was overwritten
|
||||
const _result = ctx.seen.get(schema);
|
||||
return _result.schema;
|
||||
}
|
||||
export function extractDefs(ctx, schema
|
||||
// params: EmitParams
|
||||
) {
|
||||
// iterate over seen map;
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// Track ids to detect duplicates across different schemas
|
||||
const idToSchema = new Map();
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
const existing = idToSchema.get(id);
|
||||
if (existing && existing !== entry[0]) {
|
||||
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
|
||||
}
|
||||
idToSchema.set(id, entry[0]);
|
||||
}
|
||||
}
|
||||
// returns a ref to the schema
|
||||
// defId will be empty if the ref points to an external schema (or #)
|
||||
const makeURI = (entry) => {
|
||||
// comparing the seen objects because sometimes
|
||||
// multiple schemas map to the same seen object.
|
||||
// e.g. lazy
|
||||
// external is configured
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
if (ctx.external) {
|
||||
const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
|
||||
// check if schema is in the external registry
|
||||
const uriGenerator = ctx.external.uri ?? ((id) => id);
|
||||
if (externalId) {
|
||||
return { ref: uriGenerator(externalId) };
|
||||
}
|
||||
// otherwise, add to __shared
|
||||
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
|
||||
entry[1].defId = id; // set defId so it will be reused if needed
|
||||
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
|
||||
}
|
||||
if (entry[1] === root) {
|
||||
return { ref: "#" };
|
||||
}
|
||||
// self-contained schema
|
||||
const uriPrefix = `#`;
|
||||
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
||||
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
|
||||
return { defId, ref: defUriPrefix + defId };
|
||||
};
|
||||
// stored cached version in `def` property
|
||||
// remove all properties, set $ref
|
||||
const extractToDef = (entry) => {
|
||||
// if the schema is already a reference, do not extract it
|
||||
if (entry[1].schema.$ref) {
|
||||
return;
|
||||
}
|
||||
const seen = entry[1];
|
||||
const { ref, defId } = makeURI(entry);
|
||||
seen.def = { ...seen.schema };
|
||||
// defId won't be set if the schema is a reference to an external schema
|
||||
// or if the schema is the root schema
|
||||
if (defId)
|
||||
seen.defId = defId;
|
||||
// wipe away all properties except $ref
|
||||
const schema = seen.schema;
|
||||
for (const key in schema) {
|
||||
delete schema[key];
|
||||
}
|
||||
schema.$ref = ref;
|
||||
};
|
||||
// throw on cycles
|
||||
// break cycles
|
||||
if (ctx.cycles === "throw") {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.cycle) {
|
||||
throw new Error("Cycle detected: " +
|
||||
`#/${seen.cycle?.join("/")}/<root>` +
|
||||
'\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
||||
}
|
||||
}
|
||||
}
|
||||
// extract schemas into $defs
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
// convert root schema to # $ref
|
||||
if (schema === entry[0]) {
|
||||
extractToDef(entry); // this has special handling for the root schema
|
||||
continue;
|
||||
}
|
||||
// extract schemas that are in the external registry
|
||||
if (ctx.external) {
|
||||
const ext = ctx.external.registry.get(entry[0])?.id;
|
||||
if (schema !== entry[0] && ext) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// extract schemas with `id` meta
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// break cycles
|
||||
if (seen.cycle) {
|
||||
// any
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// extract reused schemas
|
||||
if (seen.count > 1) {
|
||||
if (ctx.reused === "ref") {
|
||||
extractToDef(entry);
|
||||
// biome-ignore lint:
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
export function finalize(ctx, schema) {
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// flatten refs - inherit properties from parent schemas
|
||||
const flattenRef = (zodSchema) => {
|
||||
const seen = ctx.seen.get(zodSchema);
|
||||
// already processed
|
||||
if (seen.ref === null)
|
||||
return;
|
||||
const schema = seen.def ?? seen.schema;
|
||||
const _cached = { ...schema };
|
||||
const ref = seen.ref;
|
||||
seen.ref = null; // prevent infinite recursion
|
||||
if (ref) {
|
||||
flattenRef(ref);
|
||||
const refSeen = ctx.seen.get(ref);
|
||||
const refSchema = refSeen.schema;
|
||||
// merge referenced schema into current
|
||||
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
|
||||
// older drafts can't combine $ref with other properties
|
||||
schema.allOf = schema.allOf ?? [];
|
||||
schema.allOf.push(refSchema);
|
||||
}
|
||||
else {
|
||||
Object.assign(schema, refSchema);
|
||||
}
|
||||
// restore child's own properties (child wins)
|
||||
Object.assign(schema, _cached);
|
||||
const isParentRef = zodSchema._zod.parent === ref;
|
||||
// For parent chain, child is a refinement - remove parent-only properties
|
||||
if (isParentRef) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (!(key in _cached)) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
// When ref was extracted to $defs, remove properties that match the definition
|
||||
if (refSchema.$ref && refSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// If parent was extracted (has $ref), propagate $ref to this schema
|
||||
// This handles cases like: readonly().meta({id}).describe()
|
||||
// where processor sets ref to innerType but parent should be referenced
|
||||
const parent = zodSchema._zod.parent;
|
||||
if (parent && parent !== ref) {
|
||||
// Ensure parent is processed first so its def has inherited properties
|
||||
flattenRef(parent);
|
||||
const parentSeen = ctx.seen.get(parent);
|
||||
if (parentSeen?.schema.$ref) {
|
||||
schema.$ref = parentSeen.schema.$ref;
|
||||
// De-duplicate with parent's definition
|
||||
if (parentSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// execute overrides
|
||||
ctx.override({
|
||||
zodSchema: zodSchema,
|
||||
jsonSchema: schema,
|
||||
path: seen.path ?? [],
|
||||
});
|
||||
};
|
||||
for (const entry of [...ctx.seen.entries()].reverse()) {
|
||||
flattenRef(entry[0]);
|
||||
}
|
||||
const result = {};
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
||||
}
|
||||
else if (ctx.target === "draft-07") {
|
||||
result.$schema = "http://json-schema.org/draft-07/schema#";
|
||||
}
|
||||
else if (ctx.target === "draft-04") {
|
||||
result.$schema = "http://json-schema.org/draft-04/schema#";
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
// OpenAPI 3.0 schema objects should not include a $schema property
|
||||
}
|
||||
else {
|
||||
// Arbitrary string values are allowed but won't have a $schema property set
|
||||
}
|
||||
if (ctx.external?.uri) {
|
||||
const id = ctx.external.registry.get(schema)?.id;
|
||||
if (!id)
|
||||
throw new Error("Schema is missing an `id` property");
|
||||
result.$id = ctx.external.uri(id);
|
||||
}
|
||||
Object.assign(result, root.def ?? root.schema);
|
||||
// build defs object
|
||||
const defs = ctx.external?.defs ?? {};
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.def && seen.defId) {
|
||||
defs[seen.defId] = seen.def;
|
||||
}
|
||||
}
|
||||
// set definitions in result
|
||||
if (ctx.external) {
|
||||
}
|
||||
else {
|
||||
if (Object.keys(defs).length > 0) {
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$defs = defs;
|
||||
}
|
||||
else {
|
||||
result.definitions = defs;
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
// this "finalizes" this schema and ensures all cycles are removed
|
||||
// each call to finalize() is functionally independent
|
||||
// though the seen map is shared
|
||||
const finalized = JSON.parse(JSON.stringify(result));
|
||||
Object.defineProperty(finalized, "~standard", {
|
||||
value: {
|
||||
...schema["~standard"],
|
||||
jsonSchema: {
|
||||
input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
|
||||
output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
|
||||
},
|
||||
},
|
||||
enumerable: false,
|
||||
writable: false,
|
||||
});
|
||||
return finalized;
|
||||
}
|
||||
catch (_err) {
|
||||
throw new Error("Error converting schema to JSON.");
|
||||
}
|
||||
}
|
||||
function isTransforming(_schema, _ctx) {
|
||||
const ctx = _ctx ?? { seen: new Set() };
|
||||
if (ctx.seen.has(_schema))
|
||||
return false;
|
||||
ctx.seen.add(_schema);
|
||||
const def = _schema._zod.def;
|
||||
if (def.type === "transform")
|
||||
return true;
|
||||
if (def.type === "array")
|
||||
return isTransforming(def.element, ctx);
|
||||
if (def.type === "set")
|
||||
return isTransforming(def.valueType, ctx);
|
||||
if (def.type === "lazy")
|
||||
return isTransforming(def.getter(), ctx);
|
||||
if (def.type === "promise" ||
|
||||
def.type === "optional" ||
|
||||
def.type === "nonoptional" ||
|
||||
def.type === "nullable" ||
|
||||
def.type === "readonly" ||
|
||||
def.type === "default" ||
|
||||
def.type === "prefault") {
|
||||
return isTransforming(def.innerType, ctx);
|
||||
}
|
||||
if (def.type === "intersection") {
|
||||
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
||||
}
|
||||
if (def.type === "record" || def.type === "map") {
|
||||
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
||||
}
|
||||
if (def.type === "pipe") {
|
||||
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
||||
}
|
||||
if (def.type === "object") {
|
||||
for (const key in def.shape) {
|
||||
if (isTransforming(def.shape[key], ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "union") {
|
||||
for (const option of def.options) {
|
||||
if (isTransforming(option, ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "tuple") {
|
||||
for (const item of def.items) {
|
||||
if (isTransforming(item, ctx))
|
||||
return true;
|
||||
}
|
||||
if (def.rest && isTransforming(def.rest, ctx))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
export const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
|
||||
const ctx = initializeContext({ ...params, processors });
|
||||
process(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
export const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
|
||||
const { libraryOptions, target } = params ?? {};
|
||||
const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
|
||||
process(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
710
node_modules/zod/v4/core/util.cjs
generated
vendored
Normal file
710
node_modules/zod/v4/core/util.cjs
generated
vendored
Normal file
@@ -0,0 +1,710 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Class = exports.BIGINT_FORMAT_RANGES = exports.NUMBER_FORMAT_RANGES = exports.primitiveTypes = exports.propertyKeyTypes = exports.getParsedType = exports.allowsEval = exports.captureStackTrace = void 0;
|
||||
exports.assertEqual = assertEqual;
|
||||
exports.assertNotEqual = assertNotEqual;
|
||||
exports.assertIs = assertIs;
|
||||
exports.assertNever = assertNever;
|
||||
exports.assert = assert;
|
||||
exports.getEnumValues = getEnumValues;
|
||||
exports.joinValues = joinValues;
|
||||
exports.jsonStringifyReplacer = jsonStringifyReplacer;
|
||||
exports.cached = cached;
|
||||
exports.nullish = nullish;
|
||||
exports.cleanRegex = cleanRegex;
|
||||
exports.floatSafeRemainder = floatSafeRemainder;
|
||||
exports.defineLazy = defineLazy;
|
||||
exports.objectClone = objectClone;
|
||||
exports.assignProp = assignProp;
|
||||
exports.mergeDefs = mergeDefs;
|
||||
exports.cloneDef = cloneDef;
|
||||
exports.getElementAtPath = getElementAtPath;
|
||||
exports.promiseAllObject = promiseAllObject;
|
||||
exports.randomString = randomString;
|
||||
exports.esc = esc;
|
||||
exports.slugify = slugify;
|
||||
exports.isObject = isObject;
|
||||
exports.isPlainObject = isPlainObject;
|
||||
exports.shallowClone = shallowClone;
|
||||
exports.numKeys = numKeys;
|
||||
exports.escapeRegex = escapeRegex;
|
||||
exports.clone = clone;
|
||||
exports.normalizeParams = normalizeParams;
|
||||
exports.createTransparentProxy = createTransparentProxy;
|
||||
exports.stringifyPrimitive = stringifyPrimitive;
|
||||
exports.optionalKeys = optionalKeys;
|
||||
exports.pick = pick;
|
||||
exports.omit = omit;
|
||||
exports.extend = extend;
|
||||
exports.safeExtend = safeExtend;
|
||||
exports.merge = merge;
|
||||
exports.partial = partial;
|
||||
exports.required = required;
|
||||
exports.aborted = aborted;
|
||||
exports.prefixIssues = prefixIssues;
|
||||
exports.unwrapMessage = unwrapMessage;
|
||||
exports.finalizeIssue = finalizeIssue;
|
||||
exports.getSizableOrigin = getSizableOrigin;
|
||||
exports.getLengthableOrigin = getLengthableOrigin;
|
||||
exports.parsedType = parsedType;
|
||||
exports.issue = issue;
|
||||
exports.cleanEnum = cleanEnum;
|
||||
exports.base64ToUint8Array = base64ToUint8Array;
|
||||
exports.uint8ArrayToBase64 = uint8ArrayToBase64;
|
||||
exports.base64urlToUint8Array = base64urlToUint8Array;
|
||||
exports.uint8ArrayToBase64url = uint8ArrayToBase64url;
|
||||
exports.hexToUint8Array = hexToUint8Array;
|
||||
exports.uint8ArrayToHex = uint8ArrayToHex;
|
||||
// functions
|
||||
function assertEqual(val) {
|
||||
return val;
|
||||
}
|
||||
function assertNotEqual(val) {
|
||||
return val;
|
||||
}
|
||||
function assertIs(_arg) { }
|
||||
function assertNever(_x) {
|
||||
throw new Error("Unexpected value in exhaustive check");
|
||||
}
|
||||
function assert(_) { }
|
||||
function getEnumValues(entries) {
|
||||
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
|
||||
const values = Object.entries(entries)
|
||||
.filter(([k, _]) => numericValues.indexOf(+k) === -1)
|
||||
.map(([_, v]) => v);
|
||||
return values;
|
||||
}
|
||||
function joinValues(array, separator = "|") {
|
||||
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
||||
}
|
||||
function jsonStringifyReplacer(_, value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString();
|
||||
return value;
|
||||
}
|
||||
function cached(getter) {
|
||||
const set = false;
|
||||
return {
|
||||
get value() {
|
||||
if (!set) {
|
||||
const value = getter();
|
||||
Object.defineProperty(this, "value", { value });
|
||||
return value;
|
||||
}
|
||||
throw new Error("cached value already set");
|
||||
},
|
||||
};
|
||||
}
|
||||
function nullish(input) {
|
||||
return input === null || input === undefined;
|
||||
}
|
||||
function cleanRegex(source) {
|
||||
const start = source.startsWith("^") ? 1 : 0;
|
||||
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
||||
return source.slice(start, end);
|
||||
}
|
||||
function floatSafeRemainder(val, step) {
|
||||
const valDecCount = (val.toString().split(".")[1] || "").length;
|
||||
const stepString = step.toString();
|
||||
let stepDecCount = (stepString.split(".")[1] || "").length;
|
||||
if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
|
||||
const match = stepString.match(/\d?e-(\d?)/);
|
||||
if (match?.[1]) {
|
||||
stepDecCount = Number.parseInt(match[1]);
|
||||
}
|
||||
}
|
||||
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
||||
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
||||
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
|
||||
return (valInt % stepInt) / 10 ** decCount;
|
||||
}
|
||||
const EVALUATING = Symbol("evaluating");
|
||||
function defineLazy(object, key, getter) {
|
||||
let value = undefined;
|
||||
Object.defineProperty(object, key, {
|
||||
get() {
|
||||
if (value === EVALUATING) {
|
||||
// Circular reference detected, return undefined to break the cycle
|
||||
return undefined;
|
||||
}
|
||||
if (value === undefined) {
|
||||
value = EVALUATING;
|
||||
value = getter();
|
||||
}
|
||||
return value;
|
||||
},
|
||||
set(v) {
|
||||
Object.defineProperty(object, key, {
|
||||
value: v,
|
||||
// configurable: true,
|
||||
});
|
||||
// object[key] = v;
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
function objectClone(obj) {
|
||||
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
||||
}
|
||||
function assignProp(target, prop, value) {
|
||||
Object.defineProperty(target, prop, {
|
||||
value,
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
function mergeDefs(...defs) {
|
||||
const mergedDescriptors = {};
|
||||
for (const def of defs) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(def);
|
||||
Object.assign(mergedDescriptors, descriptors);
|
||||
}
|
||||
return Object.defineProperties({}, mergedDescriptors);
|
||||
}
|
||||
function cloneDef(schema) {
|
||||
return mergeDefs(schema._zod.def);
|
||||
}
|
||||
function getElementAtPath(obj, path) {
|
||||
if (!path)
|
||||
return obj;
|
||||
return path.reduce((acc, key) => acc?.[key], obj);
|
||||
}
|
||||
function promiseAllObject(promisesObj) {
|
||||
const keys = Object.keys(promisesObj);
|
||||
const promises = keys.map((key) => promisesObj[key]);
|
||||
return Promise.all(promises).then((results) => {
|
||||
const resolvedObj = {};
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
resolvedObj[keys[i]] = results[i];
|
||||
}
|
||||
return resolvedObj;
|
||||
});
|
||||
}
|
||||
function randomString(length = 10) {
|
||||
const chars = "abcdefghijklmnopqrstuvwxyz";
|
||||
let str = "";
|
||||
for (let i = 0; i < length; i++) {
|
||||
str += chars[Math.floor(Math.random() * chars.length)];
|
||||
}
|
||||
return str;
|
||||
}
|
||||
function esc(str) {
|
||||
return JSON.stringify(str);
|
||||
}
|
||||
function slugify(input) {
|
||||
return input
|
||||
.toLowerCase()
|
||||
.trim()
|
||||
.replace(/[^\w\s-]/g, "")
|
||||
.replace(/[\s_-]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "");
|
||||
}
|
||||
exports.captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
|
||||
function isObject(data) {
|
||||
return typeof data === "object" && data !== null && !Array.isArray(data);
|
||||
}
|
||||
exports.allowsEval = cached(() => {
|
||||
// @ts-ignore
|
||||
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const F = Function;
|
||||
new F("");
|
||||
return true;
|
||||
}
|
||||
catch (_) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
function isPlainObject(o) {
|
||||
if (isObject(o) === false)
|
||||
return false;
|
||||
// modified constructor
|
||||
const ctor = o.constructor;
|
||||
if (ctor === undefined)
|
||||
return true;
|
||||
if (typeof ctor !== "function")
|
||||
return true;
|
||||
// modified prototype
|
||||
const prot = ctor.prototype;
|
||||
if (isObject(prot) === false)
|
||||
return false;
|
||||
// ctor doesn't have static `isPrototypeOf`
|
||||
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function shallowClone(o) {
|
||||
if (isPlainObject(o))
|
||||
return { ...o };
|
||||
if (Array.isArray(o))
|
||||
return [...o];
|
||||
return o;
|
||||
}
|
||||
function numKeys(data) {
|
||||
let keyCount = 0;
|
||||
for (const key in data) {
|
||||
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
||||
keyCount++;
|
||||
}
|
||||
}
|
||||
return keyCount;
|
||||
}
|
||||
const getParsedType = (data) => {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "undefined":
|
||||
return "undefined";
|
||||
case "string":
|
||||
return "string";
|
||||
case "number":
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
case "boolean":
|
||||
return "boolean";
|
||||
case "function":
|
||||
return "function";
|
||||
case "bigint":
|
||||
return "bigint";
|
||||
case "symbol":
|
||||
return "symbol";
|
||||
case "object":
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
||||
return "promise";
|
||||
}
|
||||
if (typeof Map !== "undefined" && data instanceof Map) {
|
||||
return "map";
|
||||
}
|
||||
if (typeof Set !== "undefined" && data instanceof Set) {
|
||||
return "set";
|
||||
}
|
||||
if (typeof Date !== "undefined" && data instanceof Date) {
|
||||
return "date";
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof File !== "undefined" && data instanceof File) {
|
||||
return "file";
|
||||
}
|
||||
return "object";
|
||||
default:
|
||||
throw new Error(`Unknown data type: ${t}`);
|
||||
}
|
||||
};
|
||||
exports.getParsedType = getParsedType;
|
||||
exports.propertyKeyTypes = new Set(["string", "number", "symbol"]);
|
||||
exports.primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
|
||||
function escapeRegex(str) {
|
||||
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
// zod-specific utils
|
||||
function clone(inst, def, params) {
|
||||
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
||||
if (!def || params?.parent)
|
||||
cl._zod.parent = inst;
|
||||
return cl;
|
||||
}
|
||||
function normalizeParams(_params) {
|
||||
const params = _params;
|
||||
if (!params)
|
||||
return {};
|
||||
if (typeof params === "string")
|
||||
return { error: () => params };
|
||||
if (params?.message !== undefined) {
|
||||
if (params?.error !== undefined)
|
||||
throw new Error("Cannot specify both `message` and `error` params");
|
||||
params.error = params.message;
|
||||
}
|
||||
delete params.message;
|
||||
if (typeof params.error === "string")
|
||||
return { ...params, error: () => params.error };
|
||||
return params;
|
||||
}
|
||||
function createTransparentProxy(getter) {
|
||||
let target;
|
||||
return new Proxy({}, {
|
||||
get(_, prop, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.get(target, prop, receiver);
|
||||
},
|
||||
set(_, prop, value, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.set(target, prop, value, receiver);
|
||||
},
|
||||
has(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.has(target, prop);
|
||||
},
|
||||
deleteProperty(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.deleteProperty(target, prop);
|
||||
},
|
||||
ownKeys(_) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.ownKeys(target);
|
||||
},
|
||||
getOwnPropertyDescriptor(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.getOwnPropertyDescriptor(target, prop);
|
||||
},
|
||||
defineProperty(_, prop, descriptor) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.defineProperty(target, prop, descriptor);
|
||||
},
|
||||
});
|
||||
}
|
||||
function stringifyPrimitive(value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString() + "n";
|
||||
if (typeof value === "string")
|
||||
return `"${value}"`;
|
||||
return `${value}`;
|
||||
}
|
||||
function optionalKeys(shape) {
|
||||
return Object.keys(shape).filter((k) => {
|
||||
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
|
||||
});
|
||||
}
|
||||
exports.NUMBER_FORMAT_RANGES = {
|
||||
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
|
||||
int32: [-2147483648, 2147483647],
|
||||
uint32: [0, 4294967295],
|
||||
float32: [-3.4028234663852886e38, 3.4028234663852886e38],
|
||||
float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
|
||||
};
|
||||
exports.BIGINT_FORMAT_RANGES = {
|
||||
int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
|
||||
uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
|
||||
};
|
||||
function pick(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const newShape = {};
|
||||
for (const key in mask) {
|
||||
if (!(key in currDef.shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
newShape[key] = currDef.shape[key];
|
||||
}
|
||||
assignProp(this, "shape", newShape); // self-caching
|
||||
return newShape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function omit(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const newShape = { ...schema._zod.def.shape };
|
||||
for (const key in mask) {
|
||||
if (!(key in currDef.shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
delete newShape[key];
|
||||
}
|
||||
assignProp(this, "shape", newShape); // self-caching
|
||||
return newShape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function extend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to extend: expected a plain object");
|
||||
}
|
||||
const checks = schema._zod.def.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
// Only throw if new shape overlaps with existing shape
|
||||
// Use getOwnPropertyDescriptor to check key existence without accessing values
|
||||
const existingShape = schema._zod.def.shape;
|
||||
for (const key in shape) {
|
||||
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
||||
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
||||
}
|
||||
}
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...schema._zod.def.shape, ...shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function safeExtend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to safeExtend: expected a plain object");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...schema._zod.def.shape, ...shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function merge(a, b) {
|
||||
const def = mergeDefs(a._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
get catchall() {
|
||||
return b._zod.def.catchall;
|
||||
},
|
||||
checks: [], // delete existing checks
|
||||
});
|
||||
return clone(a, def);
|
||||
}
|
||||
function partial(Class, schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".partial() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const oldShape = schema._zod.def.shape;
|
||||
const shape = { ...oldShape };
|
||||
if (mask) {
|
||||
for (const key in mask) {
|
||||
if (!(key in oldShape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
// if (oldShape[key]!._zod.optin === "optional") continue;
|
||||
shape[key] = Class
|
||||
? new Class({
|
||||
type: "optional",
|
||||
innerType: oldShape[key],
|
||||
})
|
||||
: oldShape[key];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (const key in oldShape) {
|
||||
// if (oldShape[key]!._zod.optin === "optional") continue;
|
||||
shape[key] = Class
|
||||
? new Class({
|
||||
type: "optional",
|
||||
innerType: oldShape[key],
|
||||
})
|
||||
: oldShape[key];
|
||||
}
|
||||
}
|
||||
assignProp(this, "shape", shape); // self-caching
|
||||
return shape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function required(Class, schema, mask) {
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const oldShape = schema._zod.def.shape;
|
||||
const shape = { ...oldShape };
|
||||
if (mask) {
|
||||
for (const key in mask) {
|
||||
if (!(key in shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
// overwrite with non-optional
|
||||
shape[key] = new Class({
|
||||
type: "nonoptional",
|
||||
innerType: oldShape[key],
|
||||
});
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (const key in oldShape) {
|
||||
// overwrite with non-optional
|
||||
shape[key] = new Class({
|
||||
type: "nonoptional",
|
||||
innerType: oldShape[key],
|
||||
});
|
||||
}
|
||||
}
|
||||
assignProp(this, "shape", shape); // self-caching
|
||||
return shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
|
||||
function aborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue !== true) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function prefixIssues(path, issues) {
|
||||
return issues.map((iss) => {
|
||||
var _a;
|
||||
(_a = iss).path ?? (_a.path = []);
|
||||
iss.path.unshift(path);
|
||||
return iss;
|
||||
});
|
||||
}
|
||||
function unwrapMessage(message) {
|
||||
return typeof message === "string" ? message : message?.message;
|
||||
}
|
||||
function finalizeIssue(iss, ctx, config) {
|
||||
const full = { ...iss, path: iss.path ?? [] };
|
||||
// for backwards compatibility
|
||||
if (!iss.message) {
|
||||
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
|
||||
unwrapMessage(ctx?.error?.(iss)) ??
|
||||
unwrapMessage(config.customError?.(iss)) ??
|
||||
unwrapMessage(config.localeError?.(iss)) ??
|
||||
"Invalid input";
|
||||
full.message = message;
|
||||
}
|
||||
// delete (full as any).def;
|
||||
delete full.inst;
|
||||
delete full.continue;
|
||||
if (!ctx?.reportInput) {
|
||||
delete full.input;
|
||||
}
|
||||
return full;
|
||||
}
|
||||
function getSizableOrigin(input) {
|
||||
if (input instanceof Set)
|
||||
return "set";
|
||||
if (input instanceof Map)
|
||||
return "map";
|
||||
// @ts-ignore
|
||||
if (input instanceof File)
|
||||
return "file";
|
||||
return "unknown";
|
||||
}
|
||||
function getLengthableOrigin(input) {
|
||||
if (Array.isArray(input))
|
||||
return "array";
|
||||
if (typeof input === "string")
|
||||
return "string";
|
||||
return "unknown";
|
||||
}
|
||||
function parsedType(data) {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "number": {
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
}
|
||||
case "object": {
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
const obj = data;
|
||||
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
||||
return obj.constructor.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
function issue(...args) {
|
||||
const [iss, input, inst] = args;
|
||||
if (typeof iss === "string") {
|
||||
return {
|
||||
message: iss,
|
||||
code: "custom",
|
||||
input,
|
||||
inst,
|
||||
};
|
||||
}
|
||||
return { ...iss };
|
||||
}
|
||||
function cleanEnum(obj) {
|
||||
return Object.entries(obj)
|
||||
.filter(([k, _]) => {
|
||||
// return true if NaN, meaning it's not a number, thus a string key
|
||||
return Number.isNaN(Number.parseInt(k, 10));
|
||||
})
|
||||
.map((el) => el[1]);
|
||||
}
|
||||
// Codec utility functions
|
||||
function base64ToUint8Array(base64) {
|
||||
const binaryString = atob(base64);
|
||||
const bytes = new Uint8Array(binaryString.length);
|
||||
for (let i = 0; i < binaryString.length; i++) {
|
||||
bytes[i] = binaryString.charCodeAt(i);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
function uint8ArrayToBase64(bytes) {
|
||||
let binaryString = "";
|
||||
for (let i = 0; i < bytes.length; i++) {
|
||||
binaryString += String.fromCharCode(bytes[i]);
|
||||
}
|
||||
return btoa(binaryString);
|
||||
}
|
||||
function base64urlToUint8Array(base64url) {
|
||||
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
||||
const padding = "=".repeat((4 - (base64.length % 4)) % 4);
|
||||
return base64ToUint8Array(base64 + padding);
|
||||
}
|
||||
function uint8ArrayToBase64url(bytes) {
|
||||
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
||||
}
|
||||
function hexToUint8Array(hex) {
|
||||
const cleanHex = hex.replace(/^0x/, "");
|
||||
if (cleanHex.length % 2 !== 0) {
|
||||
throw new Error("Invalid hex string length");
|
||||
}
|
||||
const bytes = new Uint8Array(cleanHex.length / 2);
|
||||
for (let i = 0; i < cleanHex.length; i += 2) {
|
||||
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
function uint8ArrayToHex(bytes) {
|
||||
return Array.from(bytes)
|
||||
.map((b) => b.toString(16).padStart(2, "0"))
|
||||
.join("");
|
||||
}
|
||||
// instanceof
|
||||
class Class {
|
||||
constructor(..._args) { }
|
||||
}
|
||||
exports.Class = Class;
|
||||
199
node_modules/zod/v4/core/util.d.cts
generated
vendored
Normal file
199
node_modules/zod/v4/core/util.d.cts
generated
vendored
Normal file
@@ -0,0 +1,199 @@
|
||||
import type * as checks from "./checks.cjs";
|
||||
import type { $ZodConfig } from "./core.cjs";
|
||||
import type * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
export type JSONType = string | number | boolean | null | JSONType[] | {
|
||||
[key: string]: JSONType;
|
||||
};
|
||||
export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
|
||||
export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
|
||||
export type HashEncoding = "hex" | "base64" | "base64url";
|
||||
export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
|
||||
export type IPVersion = "v4" | "v6";
|
||||
export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
|
||||
export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
|
||||
export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
|
||||
export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
|
||||
export type AssertExtends<T, U> = T extends U ? T : never;
|
||||
export type IsAny<T> = 0 extends 1 & T ? true : false;
|
||||
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
|
||||
export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
|
||||
export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
|
||||
export type NoUndefined<T> = T extends undefined ? never : T;
|
||||
export type Whatever = {} | undefined | null;
|
||||
export type LoosePartial<T extends object> = InexactPartial<T> & {
|
||||
[k: string]: unknown;
|
||||
};
|
||||
export type Mask<Keys extends PropertyKey> = {
|
||||
[K in Keys]?: true;
|
||||
};
|
||||
export type Writeable<T> = {
|
||||
-readonly [P in keyof T]: T[P];
|
||||
} & {};
|
||||
export type InexactPartial<T> = {
|
||||
[P in keyof T]?: T[P] | undefined;
|
||||
};
|
||||
export type EmptyObject = Record<string, never>;
|
||||
export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
|
||||
readonly [Symbol.toStringTag]: string;
|
||||
} | Date | Error | Generator | Promise<unknown> | RegExp;
|
||||
export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
|
||||
export type SomeObject = Record<PropertyKey, any>;
|
||||
export type Identity<T> = T;
|
||||
export type Flatten<T> = Identity<{
|
||||
[k in keyof T]: T[k];
|
||||
}>;
|
||||
export type Mapped<T> = {
|
||||
[k in keyof T]: T[k];
|
||||
};
|
||||
export type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
export type NoNeverKeys<T> = {
|
||||
[k in keyof T]: [T[k]] extends [never] ? never : k;
|
||||
}[keyof T];
|
||||
export type NoNever<T> = Identity<{
|
||||
[k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
|
||||
}>;
|
||||
export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
|
||||
[K in keyof A as K extends keyof B ? never : K]: A[K];
|
||||
} & {
|
||||
[K in keyof B]: B[K];
|
||||
}>;
|
||||
export type TupleItems = ReadonlyArray<schemas.SomeType>;
|
||||
export type AnyFunc = (...args: any[]) => any;
|
||||
export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
|
||||
export type MaybeAsync<T> = T | Promise<T>;
|
||||
export type KeyOf<T> = keyof OmitIndexSignature<T>;
|
||||
export type OmitIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
|
||||
};
|
||||
export type ExtractIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
|
||||
};
|
||||
export type Keys<T extends object> = keyof OmitIndexSignature<T>;
|
||||
export type SchemaClass<T extends schemas.SomeType> = {
|
||||
new (def: T["_zod"]["def"]): T;
|
||||
};
|
||||
export type EnumValue = string | number;
|
||||
export type EnumLike = Readonly<Record<string, EnumValue>>;
|
||||
export type ToEnum<T extends EnumValue> = Flatten<{
|
||||
[k in T]: k;
|
||||
}>;
|
||||
export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
|
||||
export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
|
||||
export type Literal = string | number | bigint | boolean | null | undefined;
|
||||
export type LiteralArray = Array<Literal>;
|
||||
export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
|
||||
export type PrimitiveArray = Array<Primitive>;
|
||||
export type HasSize = {
|
||||
size: number;
|
||||
};
|
||||
export type HasLength = {
|
||||
length: number;
|
||||
};
|
||||
export type Numeric = number | bigint | Date;
|
||||
export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
|
||||
export type SafeParseSuccess<T> = {
|
||||
success: true;
|
||||
data: T;
|
||||
error?: never;
|
||||
};
|
||||
export type SafeParseError<T> = {
|
||||
success: false;
|
||||
data?: never;
|
||||
error: errors.$ZodError<T>;
|
||||
};
|
||||
export type PropValues = Record<string, Set<Primitive>>;
|
||||
export type PrimitiveSet = Set<Primitive>;
|
||||
export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
|
||||
export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
|
||||
export declare function assertIs<T>(_arg: T): void;
|
||||
export declare function assertNever(_x: never): never;
|
||||
export declare function assert<T>(_: any): asserts _ is T;
|
||||
export declare function getEnumValues(entries: EnumLike): EnumValue[];
|
||||
export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
|
||||
export declare function jsonStringifyReplacer(_: string, value: any): any;
|
||||
export declare function cached<T>(getter: () => T): {
|
||||
value: T;
|
||||
};
|
||||
export declare function nullish(input: any): boolean;
|
||||
export declare function cleanRegex(source: string): string;
|
||||
export declare function floatSafeRemainder(val: number, step: number): number;
|
||||
export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
|
||||
export declare function objectClone(obj: object): any;
|
||||
export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
|
||||
export declare function mergeDefs(...defs: Record<string, any>[]): any;
|
||||
export declare function cloneDef(schema: schemas.$ZodType): any;
|
||||
export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
|
||||
export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
|
||||
[k in keyof T]: Awaited<T[k]>;
|
||||
}>;
|
||||
export declare function randomString(length?: number): string;
|
||||
export declare function esc(str: string): string;
|
||||
export declare function slugify(input: string): string;
|
||||
export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
|
||||
export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
|
||||
export declare const allowsEval: {
|
||||
value: boolean;
|
||||
};
|
||||
export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
|
||||
export declare function shallowClone(o: any): any;
|
||||
export declare function numKeys(data: any): number;
|
||||
export declare const getParsedType: (data: any) => ParsedTypes;
|
||||
export declare const propertyKeyTypes: Set<string>;
|
||||
export declare const primitiveTypes: Set<string>;
|
||||
export declare function escapeRegex(str: string): string;
|
||||
export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
|
||||
parent: boolean;
|
||||
}): T;
|
||||
export type EmptyToNever<T> = keyof T extends never ? never : T;
|
||||
export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
|
||||
[k in keyof Omit<T, "error" | "message">]: T[k];
|
||||
} & ("error" extends keyof T ? {
|
||||
error?: Exclude<T["error"], string>;
|
||||
} : unknown)> : never;
|
||||
export declare function normalizeParams<T>(_params: T): Normalize<T>;
|
||||
export declare function createTransparentProxy<T extends object>(getter: () => T): T;
|
||||
export declare function stringifyPrimitive(value: any): string;
|
||||
export declare function optionalKeys(shape: schemas.$ZodShape): string[];
|
||||
export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
|
||||
export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
|
||||
};
|
||||
export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
|
||||
};
|
||||
export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
|
||||
export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
|
||||
export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
|
||||
export declare function omit(schema: schemas.$ZodObject, mask: object): any;
|
||||
export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
|
||||
export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;
|
||||
export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
|
||||
export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
|
||||
export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
|
||||
export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
|
||||
export declare function unwrapMessage(message: string | {
|
||||
message: string;
|
||||
} | undefined | null): string | undefined;
|
||||
export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
|
||||
export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
|
||||
export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
|
||||
export declare function parsedType(data: unknown): errors.$ZodInvalidTypeExpected;
|
||||
export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
|
||||
export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
|
||||
export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
|
||||
export declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
|
||||
export declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
|
||||
export declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToHex(bytes: Uint8Array): string;
|
||||
export declare abstract class Class {
|
||||
constructor(..._args: any[]);
|
||||
}
|
||||
199
node_modules/zod/v4/core/util.d.ts
generated
vendored
Normal file
199
node_modules/zod/v4/core/util.d.ts
generated
vendored
Normal file
@@ -0,0 +1,199 @@
|
||||
import type * as checks from "./checks.js";
|
||||
import type { $ZodConfig } from "./core.js";
|
||||
import type * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
export type JSONType = string | number | boolean | null | JSONType[] | {
|
||||
[key: string]: JSONType;
|
||||
};
|
||||
export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
|
||||
export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
|
||||
export type HashEncoding = "hex" | "base64" | "base64url";
|
||||
export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
|
||||
export type IPVersion = "v4" | "v6";
|
||||
export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
|
||||
export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
|
||||
export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
|
||||
export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
|
||||
export type AssertExtends<T, U> = T extends U ? T : never;
|
||||
export type IsAny<T> = 0 extends 1 & T ? true : false;
|
||||
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
|
||||
export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
|
||||
export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
|
||||
export type NoUndefined<T> = T extends undefined ? never : T;
|
||||
export type Whatever = {} | undefined | null;
|
||||
export type LoosePartial<T extends object> = InexactPartial<T> & {
|
||||
[k: string]: unknown;
|
||||
};
|
||||
export type Mask<Keys extends PropertyKey> = {
|
||||
[K in Keys]?: true;
|
||||
};
|
||||
export type Writeable<T> = {
|
||||
-readonly [P in keyof T]: T[P];
|
||||
} & {};
|
||||
export type InexactPartial<T> = {
|
||||
[P in keyof T]?: T[P] | undefined;
|
||||
};
|
||||
export type EmptyObject = Record<string, never>;
|
||||
export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
|
||||
readonly [Symbol.toStringTag]: string;
|
||||
} | Date | Error | Generator | Promise<unknown> | RegExp;
|
||||
export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
|
||||
export type SomeObject = Record<PropertyKey, any>;
|
||||
export type Identity<T> = T;
|
||||
export type Flatten<T> = Identity<{
|
||||
[k in keyof T]: T[k];
|
||||
}>;
|
||||
export type Mapped<T> = {
|
||||
[k in keyof T]: T[k];
|
||||
};
|
||||
export type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
export type NoNeverKeys<T> = {
|
||||
[k in keyof T]: [T[k]] extends [never] ? never : k;
|
||||
}[keyof T];
|
||||
export type NoNever<T> = Identity<{
|
||||
[k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
|
||||
}>;
|
||||
export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
|
||||
[K in keyof A as K extends keyof B ? never : K]: A[K];
|
||||
} & {
|
||||
[K in keyof B]: B[K];
|
||||
}>;
|
||||
export type TupleItems = ReadonlyArray<schemas.SomeType>;
|
||||
export type AnyFunc = (...args: any[]) => any;
|
||||
export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
|
||||
export type MaybeAsync<T> = T | Promise<T>;
|
||||
export type KeyOf<T> = keyof OmitIndexSignature<T>;
|
||||
export type OmitIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
|
||||
};
|
||||
export type ExtractIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
|
||||
};
|
||||
export type Keys<T extends object> = keyof OmitIndexSignature<T>;
|
||||
export type SchemaClass<T extends schemas.SomeType> = {
|
||||
new (def: T["_zod"]["def"]): T;
|
||||
};
|
||||
export type EnumValue = string | number;
|
||||
export type EnumLike = Readonly<Record<string, EnumValue>>;
|
||||
export type ToEnum<T extends EnumValue> = Flatten<{
|
||||
[k in T]: k;
|
||||
}>;
|
||||
export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
|
||||
export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
|
||||
export type Literal = string | number | bigint | boolean | null | undefined;
|
||||
export type LiteralArray = Array<Literal>;
|
||||
export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
|
||||
export type PrimitiveArray = Array<Primitive>;
|
||||
export type HasSize = {
|
||||
size: number;
|
||||
};
|
||||
export type HasLength = {
|
||||
length: number;
|
||||
};
|
||||
export type Numeric = number | bigint | Date;
|
||||
export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
|
||||
export type SafeParseSuccess<T> = {
|
||||
success: true;
|
||||
data: T;
|
||||
error?: never;
|
||||
};
|
||||
export type SafeParseError<T> = {
|
||||
success: false;
|
||||
data?: never;
|
||||
error: errors.$ZodError<T>;
|
||||
};
|
||||
export type PropValues = Record<string, Set<Primitive>>;
|
||||
export type PrimitiveSet = Set<Primitive>;
|
||||
export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
|
||||
export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
|
||||
export declare function assertIs<T>(_arg: T): void;
|
||||
export declare function assertNever(_x: never): never;
|
||||
export declare function assert<T>(_: any): asserts _ is T;
|
||||
export declare function getEnumValues(entries: EnumLike): EnumValue[];
|
||||
export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
|
||||
export declare function jsonStringifyReplacer(_: string, value: any): any;
|
||||
export declare function cached<T>(getter: () => T): {
|
||||
value: T;
|
||||
};
|
||||
export declare function nullish(input: any): boolean;
|
||||
export declare function cleanRegex(source: string): string;
|
||||
export declare function floatSafeRemainder(val: number, step: number): number;
|
||||
export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
|
||||
export declare function objectClone(obj: object): any;
|
||||
export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
|
||||
export declare function mergeDefs(...defs: Record<string, any>[]): any;
|
||||
export declare function cloneDef(schema: schemas.$ZodType): any;
|
||||
export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
|
||||
export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
|
||||
[k in keyof T]: Awaited<T[k]>;
|
||||
}>;
|
||||
export declare function randomString(length?: number): string;
|
||||
export declare function esc(str: string): string;
|
||||
export declare function slugify(input: string): string;
|
||||
export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
|
||||
export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
|
||||
export declare const allowsEval: {
|
||||
value: boolean;
|
||||
};
|
||||
export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
|
||||
export declare function shallowClone(o: any): any;
|
||||
export declare function numKeys(data: any): number;
|
||||
export declare const getParsedType: (data: any) => ParsedTypes;
|
||||
export declare const propertyKeyTypes: Set<string>;
|
||||
export declare const primitiveTypes: Set<string>;
|
||||
export declare function escapeRegex(str: string): string;
|
||||
export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
|
||||
parent: boolean;
|
||||
}): T;
|
||||
export type EmptyToNever<T> = keyof T extends never ? never : T;
|
||||
export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
|
||||
[k in keyof Omit<T, "error" | "message">]: T[k];
|
||||
} & ("error" extends keyof T ? {
|
||||
error?: Exclude<T["error"], string>;
|
||||
} : unknown)> : never;
|
||||
export declare function normalizeParams<T>(_params: T): Normalize<T>;
|
||||
export declare function createTransparentProxy<T extends object>(getter: () => T): T;
|
||||
export declare function stringifyPrimitive(value: any): string;
|
||||
export declare function optionalKeys(shape: schemas.$ZodShape): string[];
|
||||
export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
|
||||
export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
|
||||
};
|
||||
export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
|
||||
};
|
||||
export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
|
||||
export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
|
||||
export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
|
||||
export declare function omit(schema: schemas.$ZodObject, mask: object): any;
|
||||
export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
|
||||
export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;
|
||||
export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
|
||||
export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
|
||||
export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
|
||||
export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
|
||||
export declare function unwrapMessage(message: string | {
|
||||
message: string;
|
||||
} | undefined | null): string | undefined;
|
||||
export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
|
||||
export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
|
||||
export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
|
||||
export declare function parsedType(data: unknown): errors.$ZodInvalidTypeExpected;
|
||||
export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
|
||||
export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
|
||||
export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
|
||||
export declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
|
||||
export declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
|
||||
export declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToHex(bytes: Uint8Array): string;
|
||||
export declare abstract class Class {
|
||||
constructor(..._args: any[]);
|
||||
}
|
||||
651
node_modules/zod/v4/core/util.js
generated
vendored
Normal file
651
node_modules/zod/v4/core/util.js
generated
vendored
Normal file
@@ -0,0 +1,651 @@
|
||||
// functions
|
||||
export function assertEqual(val) {
|
||||
return val;
|
||||
}
|
||||
export function assertNotEqual(val) {
|
||||
return val;
|
||||
}
|
||||
export function assertIs(_arg) { }
|
||||
export function assertNever(_x) {
|
||||
throw new Error("Unexpected value in exhaustive check");
|
||||
}
|
||||
export function assert(_) { }
|
||||
export function getEnumValues(entries) {
|
||||
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
|
||||
const values = Object.entries(entries)
|
||||
.filter(([k, _]) => numericValues.indexOf(+k) === -1)
|
||||
.map(([_, v]) => v);
|
||||
return values;
|
||||
}
|
||||
export function joinValues(array, separator = "|") {
|
||||
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
||||
}
|
||||
export function jsonStringifyReplacer(_, value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString();
|
||||
return value;
|
||||
}
|
||||
export function cached(getter) {
|
||||
const set = false;
|
||||
return {
|
||||
get value() {
|
||||
if (!set) {
|
||||
const value = getter();
|
||||
Object.defineProperty(this, "value", { value });
|
||||
return value;
|
||||
}
|
||||
throw new Error("cached value already set");
|
||||
},
|
||||
};
|
||||
}
|
||||
export function nullish(input) {
|
||||
return input === null || input === undefined;
|
||||
}
|
||||
export function cleanRegex(source) {
|
||||
const start = source.startsWith("^") ? 1 : 0;
|
||||
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
||||
return source.slice(start, end);
|
||||
}
|
||||
export function floatSafeRemainder(val, step) {
|
||||
const valDecCount = (val.toString().split(".")[1] || "").length;
|
||||
const stepString = step.toString();
|
||||
let stepDecCount = (stepString.split(".")[1] || "").length;
|
||||
if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
|
||||
const match = stepString.match(/\d?e-(\d?)/);
|
||||
if (match?.[1]) {
|
||||
stepDecCount = Number.parseInt(match[1]);
|
||||
}
|
||||
}
|
||||
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
||||
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
||||
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
|
||||
return (valInt % stepInt) / 10 ** decCount;
|
||||
}
|
||||
const EVALUATING = Symbol("evaluating");
|
||||
export function defineLazy(object, key, getter) {
|
||||
let value = undefined;
|
||||
Object.defineProperty(object, key, {
|
||||
get() {
|
||||
if (value === EVALUATING) {
|
||||
// Circular reference detected, return undefined to break the cycle
|
||||
return undefined;
|
||||
}
|
||||
if (value === undefined) {
|
||||
value = EVALUATING;
|
||||
value = getter();
|
||||
}
|
||||
return value;
|
||||
},
|
||||
set(v) {
|
||||
Object.defineProperty(object, key, {
|
||||
value: v,
|
||||
// configurable: true,
|
||||
});
|
||||
// object[key] = v;
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
export function objectClone(obj) {
|
||||
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
||||
}
|
||||
export function assignProp(target, prop, value) {
|
||||
Object.defineProperty(target, prop, {
|
||||
value,
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
export function mergeDefs(...defs) {
|
||||
const mergedDescriptors = {};
|
||||
for (const def of defs) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(def);
|
||||
Object.assign(mergedDescriptors, descriptors);
|
||||
}
|
||||
return Object.defineProperties({}, mergedDescriptors);
|
||||
}
|
||||
export function cloneDef(schema) {
|
||||
return mergeDefs(schema._zod.def);
|
||||
}
|
||||
export function getElementAtPath(obj, path) {
|
||||
if (!path)
|
||||
return obj;
|
||||
return path.reduce((acc, key) => acc?.[key], obj);
|
||||
}
|
||||
export function promiseAllObject(promisesObj) {
|
||||
const keys = Object.keys(promisesObj);
|
||||
const promises = keys.map((key) => promisesObj[key]);
|
||||
return Promise.all(promises).then((results) => {
|
||||
const resolvedObj = {};
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
resolvedObj[keys[i]] = results[i];
|
||||
}
|
||||
return resolvedObj;
|
||||
});
|
||||
}
|
||||
export function randomString(length = 10) {
|
||||
const chars = "abcdefghijklmnopqrstuvwxyz";
|
||||
let str = "";
|
||||
for (let i = 0; i < length; i++) {
|
||||
str += chars[Math.floor(Math.random() * chars.length)];
|
||||
}
|
||||
return str;
|
||||
}
|
||||
export function esc(str) {
|
||||
return JSON.stringify(str);
|
||||
}
|
||||
export function slugify(input) {
|
||||
return input
|
||||
.toLowerCase()
|
||||
.trim()
|
||||
.replace(/[^\w\s-]/g, "")
|
||||
.replace(/[\s_-]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "");
|
||||
}
|
||||
export const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
|
||||
export function isObject(data) {
|
||||
return typeof data === "object" && data !== null && !Array.isArray(data);
|
||||
}
|
||||
export const allowsEval = cached(() => {
|
||||
// @ts-ignore
|
||||
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const F = Function;
|
||||
new F("");
|
||||
return true;
|
||||
}
|
||||
catch (_) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
export function isPlainObject(o) {
|
||||
if (isObject(o) === false)
|
||||
return false;
|
||||
// modified constructor
|
||||
const ctor = o.constructor;
|
||||
if (ctor === undefined)
|
||||
return true;
|
||||
if (typeof ctor !== "function")
|
||||
return true;
|
||||
// modified prototype
|
||||
const prot = ctor.prototype;
|
||||
if (isObject(prot) === false)
|
||||
return false;
|
||||
// ctor doesn't have static `isPrototypeOf`
|
||||
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
export function shallowClone(o) {
|
||||
if (isPlainObject(o))
|
||||
return { ...o };
|
||||
if (Array.isArray(o))
|
||||
return [...o];
|
||||
return o;
|
||||
}
|
||||
export function numKeys(data) {
|
||||
let keyCount = 0;
|
||||
for (const key in data) {
|
||||
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
||||
keyCount++;
|
||||
}
|
||||
}
|
||||
return keyCount;
|
||||
}
|
||||
export const getParsedType = (data) => {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "undefined":
|
||||
return "undefined";
|
||||
case "string":
|
||||
return "string";
|
||||
case "number":
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
case "boolean":
|
||||
return "boolean";
|
||||
case "function":
|
||||
return "function";
|
||||
case "bigint":
|
||||
return "bigint";
|
||||
case "symbol":
|
||||
return "symbol";
|
||||
case "object":
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
||||
return "promise";
|
||||
}
|
||||
if (typeof Map !== "undefined" && data instanceof Map) {
|
||||
return "map";
|
||||
}
|
||||
if (typeof Set !== "undefined" && data instanceof Set) {
|
||||
return "set";
|
||||
}
|
||||
if (typeof Date !== "undefined" && data instanceof Date) {
|
||||
return "date";
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof File !== "undefined" && data instanceof File) {
|
||||
return "file";
|
||||
}
|
||||
return "object";
|
||||
default:
|
||||
throw new Error(`Unknown data type: ${t}`);
|
||||
}
|
||||
};
|
||||
export const propertyKeyTypes = new Set(["string", "number", "symbol"]);
|
||||
export const primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
|
||||
export function escapeRegex(str) {
|
||||
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
// zod-specific utils
|
||||
export function clone(inst, def, params) {
|
||||
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
||||
if (!def || params?.parent)
|
||||
cl._zod.parent = inst;
|
||||
return cl;
|
||||
}
|
||||
export function normalizeParams(_params) {
|
||||
const params = _params;
|
||||
if (!params)
|
||||
return {};
|
||||
if (typeof params === "string")
|
||||
return { error: () => params };
|
||||
if (params?.message !== undefined) {
|
||||
if (params?.error !== undefined)
|
||||
throw new Error("Cannot specify both `message` and `error` params");
|
||||
params.error = params.message;
|
||||
}
|
||||
delete params.message;
|
||||
if (typeof params.error === "string")
|
||||
return { ...params, error: () => params.error };
|
||||
return params;
|
||||
}
|
||||
export function createTransparentProxy(getter) {
|
||||
let target;
|
||||
return new Proxy({}, {
|
||||
get(_, prop, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.get(target, prop, receiver);
|
||||
},
|
||||
set(_, prop, value, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.set(target, prop, value, receiver);
|
||||
},
|
||||
has(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.has(target, prop);
|
||||
},
|
||||
deleteProperty(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.deleteProperty(target, prop);
|
||||
},
|
||||
ownKeys(_) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.ownKeys(target);
|
||||
},
|
||||
getOwnPropertyDescriptor(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.getOwnPropertyDescriptor(target, prop);
|
||||
},
|
||||
defineProperty(_, prop, descriptor) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.defineProperty(target, prop, descriptor);
|
||||
},
|
||||
});
|
||||
}
|
||||
export function stringifyPrimitive(value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString() + "n";
|
||||
if (typeof value === "string")
|
||||
return `"${value}"`;
|
||||
return `${value}`;
|
||||
}
|
||||
export function optionalKeys(shape) {
|
||||
return Object.keys(shape).filter((k) => {
|
||||
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
|
||||
});
|
||||
}
|
||||
export const NUMBER_FORMAT_RANGES = {
|
||||
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
|
||||
int32: [-2147483648, 2147483647],
|
||||
uint32: [0, 4294967295],
|
||||
float32: [-3.4028234663852886e38, 3.4028234663852886e38],
|
||||
float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
|
||||
};
|
||||
export const BIGINT_FORMAT_RANGES = {
|
||||
int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
|
||||
uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
|
||||
};
|
||||
export function pick(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const newShape = {};
|
||||
for (const key in mask) {
|
||||
if (!(key in currDef.shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
newShape[key] = currDef.shape[key];
|
||||
}
|
||||
assignProp(this, "shape", newShape); // self-caching
|
||||
return newShape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
export function omit(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const newShape = { ...schema._zod.def.shape };
|
||||
for (const key in mask) {
|
||||
if (!(key in currDef.shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
delete newShape[key];
|
||||
}
|
||||
assignProp(this, "shape", newShape); // self-caching
|
||||
return newShape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
export function extend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to extend: expected a plain object");
|
||||
}
|
||||
const checks = schema._zod.def.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
// Only throw if new shape overlaps with existing shape
|
||||
// Use getOwnPropertyDescriptor to check key existence without accessing values
|
||||
const existingShape = schema._zod.def.shape;
|
||||
for (const key in shape) {
|
||||
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
||||
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
||||
}
|
||||
}
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...schema._zod.def.shape, ...shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
export function safeExtend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to safeExtend: expected a plain object");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...schema._zod.def.shape, ...shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
export function merge(a, b) {
|
||||
const def = mergeDefs(a._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
get catchall() {
|
||||
return b._zod.def.catchall;
|
||||
},
|
||||
checks: [], // delete existing checks
|
||||
});
|
||||
return clone(a, def);
|
||||
}
|
||||
export function partial(Class, schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".partial() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const oldShape = schema._zod.def.shape;
|
||||
const shape = { ...oldShape };
|
||||
if (mask) {
|
||||
for (const key in mask) {
|
||||
if (!(key in oldShape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
// if (oldShape[key]!._zod.optin === "optional") continue;
|
||||
shape[key] = Class
|
||||
? new Class({
|
||||
type: "optional",
|
||||
innerType: oldShape[key],
|
||||
})
|
||||
: oldShape[key];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (const key in oldShape) {
|
||||
// if (oldShape[key]!._zod.optin === "optional") continue;
|
||||
shape[key] = Class
|
||||
? new Class({
|
||||
type: "optional",
|
||||
innerType: oldShape[key],
|
||||
})
|
||||
: oldShape[key];
|
||||
}
|
||||
}
|
||||
assignProp(this, "shape", shape); // self-caching
|
||||
return shape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
export function required(Class, schema, mask) {
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const oldShape = schema._zod.def.shape;
|
||||
const shape = { ...oldShape };
|
||||
if (mask) {
|
||||
for (const key in mask) {
|
||||
if (!(key in shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
// overwrite with non-optional
|
||||
shape[key] = new Class({
|
||||
type: "nonoptional",
|
||||
innerType: oldShape[key],
|
||||
});
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (const key in oldShape) {
|
||||
// overwrite with non-optional
|
||||
shape[key] = new Class({
|
||||
type: "nonoptional",
|
||||
innerType: oldShape[key],
|
||||
});
|
||||
}
|
||||
}
|
||||
assignProp(this, "shape", shape); // self-caching
|
||||
return shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
|
||||
export function aborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue !== true) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function prefixIssues(path, issues) {
|
||||
return issues.map((iss) => {
|
||||
var _a;
|
||||
(_a = iss).path ?? (_a.path = []);
|
||||
iss.path.unshift(path);
|
||||
return iss;
|
||||
});
|
||||
}
|
||||
export function unwrapMessage(message) {
|
||||
return typeof message === "string" ? message : message?.message;
|
||||
}
|
||||
export function finalizeIssue(iss, ctx, config) {
|
||||
const full = { ...iss, path: iss.path ?? [] };
|
||||
// for backwards compatibility
|
||||
if (!iss.message) {
|
||||
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
|
||||
unwrapMessage(ctx?.error?.(iss)) ??
|
||||
unwrapMessage(config.customError?.(iss)) ??
|
||||
unwrapMessage(config.localeError?.(iss)) ??
|
||||
"Invalid input";
|
||||
full.message = message;
|
||||
}
|
||||
// delete (full as any).def;
|
||||
delete full.inst;
|
||||
delete full.continue;
|
||||
if (!ctx?.reportInput) {
|
||||
delete full.input;
|
||||
}
|
||||
return full;
|
||||
}
|
||||
export function getSizableOrigin(input) {
|
||||
if (input instanceof Set)
|
||||
return "set";
|
||||
if (input instanceof Map)
|
||||
return "map";
|
||||
// @ts-ignore
|
||||
if (input instanceof File)
|
||||
return "file";
|
||||
return "unknown";
|
||||
}
|
||||
export function getLengthableOrigin(input) {
|
||||
if (Array.isArray(input))
|
||||
return "array";
|
||||
if (typeof input === "string")
|
||||
return "string";
|
||||
return "unknown";
|
||||
}
|
||||
export function parsedType(data) {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "number": {
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
}
|
||||
case "object": {
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
const obj = data;
|
||||
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
||||
return obj.constructor.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
export function issue(...args) {
|
||||
const [iss, input, inst] = args;
|
||||
if (typeof iss === "string") {
|
||||
return {
|
||||
message: iss,
|
||||
code: "custom",
|
||||
input,
|
||||
inst,
|
||||
};
|
||||
}
|
||||
return { ...iss };
|
||||
}
|
||||
export function cleanEnum(obj) {
|
||||
return Object.entries(obj)
|
||||
.filter(([k, _]) => {
|
||||
// return true if NaN, meaning it's not a number, thus a string key
|
||||
return Number.isNaN(Number.parseInt(k, 10));
|
||||
})
|
||||
.map((el) => el[1]);
|
||||
}
|
||||
// Codec utility functions
|
||||
export function base64ToUint8Array(base64) {
|
||||
const binaryString = atob(base64);
|
||||
const bytes = new Uint8Array(binaryString.length);
|
||||
for (let i = 0; i < binaryString.length; i++) {
|
||||
bytes[i] = binaryString.charCodeAt(i);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
export function uint8ArrayToBase64(bytes) {
|
||||
let binaryString = "";
|
||||
for (let i = 0; i < bytes.length; i++) {
|
||||
binaryString += String.fromCharCode(bytes[i]);
|
||||
}
|
||||
return btoa(binaryString);
|
||||
}
|
||||
export function base64urlToUint8Array(base64url) {
|
||||
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
||||
const padding = "=".repeat((4 - (base64.length % 4)) % 4);
|
||||
return base64ToUint8Array(base64 + padding);
|
||||
}
|
||||
export function uint8ArrayToBase64url(bytes) {
|
||||
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
||||
}
|
||||
export function hexToUint8Array(hex) {
|
||||
const cleanHex = hex.replace(/^0x/, "");
|
||||
if (cleanHex.length % 2 !== 0) {
|
||||
throw new Error("Invalid hex string length");
|
||||
}
|
||||
const bytes = new Uint8Array(cleanHex.length / 2);
|
||||
for (let i = 0; i < cleanHex.length; i += 2) {
|
||||
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
export function uint8ArrayToHex(bytes) {
|
||||
return Array.from(bytes)
|
||||
.map((b) => b.toString(16).padStart(2, "0"))
|
||||
.join("");
|
||||
}
|
||||
// instanceof
|
||||
export class Class {
|
||||
constructor(..._args) { }
|
||||
}
|
||||
8
node_modules/zod/v4/core/versions.cjs
generated
vendored
Normal file
8
node_modules/zod/v4/core/versions.cjs
generated
vendored
Normal file
@@ -0,0 +1,8 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.version = void 0;
|
||||
exports.version = {
|
||||
major: 4,
|
||||
minor: 3,
|
||||
patch: 6,
|
||||
};
|
||||
5
node_modules/zod/v4/core/versions.d.cts
generated
vendored
Normal file
5
node_modules/zod/v4/core/versions.d.cts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
export declare const version: {
|
||||
readonly major: 4;
|
||||
readonly minor: 3;
|
||||
readonly patch: number;
|
||||
};
|
||||
5
node_modules/zod/v4/core/versions.d.ts
generated
vendored
Normal file
5
node_modules/zod/v4/core/versions.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
export declare const version: {
|
||||
readonly major: 4;
|
||||
readonly minor: 3;
|
||||
readonly patch: number;
|
||||
};
|
||||
5
node_modules/zod/v4/core/versions.js
generated
vendored
Normal file
5
node_modules/zod/v4/core/versions.js
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
export const version = {
|
||||
major: 4,
|
||||
minor: 3,
|
||||
patch: 6,
|
||||
};
|
||||
Reference in New Issue
Block a user