@cossistant/react 0.0.28 → 0.0.29

package/README.md

@@ -2,7 +2,7 @@
 
 Build fully featured customer support experiences in React with the official `@cossistant/react` package. The SDK wraps the REST and WebSocket APIs, comes with a prebuilt widget, hooks, and UI primitives so you can ship your support quickly and customize later.
 
-> 📚 **New to Cossistant?** Follow the [Quickstart guide](https://cossistant/docs/quickstart) in our official documentation.
+> 📚 **New to Cossistant?** Follow the [Quickstart guide](https://cossistant.com/docs/quickstart) in our official documentation.
 
 ## Installation
 

package/api.d.ts

@@ -3,7 +3,7 @@ import { $ZodBase64, $ZodBase64URL, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2,
 import { $ZodCheck, $ZodCheckEndsWith, $ZodCheckGreaterThan, $ZodCheckIncludes, $ZodCheckLengthEquals, $ZodCheckLessThan, $ZodCheckLowerCase, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckRegex, $ZodCheckStartsWith, $ZodCheckUpperCase } from "./checks.js";
 import { $ZodErrorMap, $ZodIssue, $ZodIssueBase } from "./errors.js";
 
-//#region ../../node_modules/zod/v4/core/api.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/api.d.cts
 type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
   error?: string | $ZodErrorMap<IssueTypes> | undefined;
   /** @deprecated This parameter is deprecated. Use `error` instead. */

package/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","names":["checks","core","errors","schemas","util","Params","T","IssueTypes","OmitKeys","$ZodType","$ZodCheck","$ZodIssueBase","Omit","$ZodErrorMap","EmptyToNever","Partial","Flatten","TypeParams","AlsoOmit","Exclude","NonNullable","CheckParams","StringFormatParams","$ZodStringFormat","CheckStringFormatParams","CheckTypeParams","$ZodStringParams","$ZodString","_string","SchemaClass","_coercedString","$ZodStringFormatParams","$ZodCheckStringFormatParams","$ZodCheckStringFormat","$ZodEmailParams","$ZodEmail","$ZodCheckEmailParams","_email","$ZodGUIDParams","$ZodGUID","$ZodCheckGUIDParams","_guid","$ZodUUIDParams","$ZodUUID","$ZodCheckUUIDParams","_uuid","$ZodUUIDv4Params","$ZodCheckUUIDv4Params","_uuidv4","$ZodUUIDv6Params","$ZodCheckUUIDv6Params","_uuidv6","$ZodUUIDv7Params","$ZodCheckUUIDv7Params","_uuidv7","$ZodURLParams","$ZodURL","$ZodCheckURLParams","_url","$ZodEmojiParams","$ZodEmoji","$ZodCheckEmojiParams","_emoji","$ZodNanoIDParams","$ZodNanoID","$ZodCheckNanoIDParams","_nanoid","$ZodCUIDParams","$ZodCUID","$ZodCheckCUIDParams","_cuid","$ZodCUID2Params","$ZodCUID2","$ZodCheckCUID2Params","_cuid2","$ZodULIDParams","$ZodULID","$ZodCheckULIDParams","_ulid","$ZodXIDParams","$ZodXID","$ZodCheckXIDParams","_xid","$ZodKSUIDParams","$ZodKSUID","$ZodCheckKSUIDParams","_ksuid","$ZodIPv4Params","$ZodIPv4","$ZodCheckIPv4Params","_ipv4","$ZodIPv6Params","$ZodIPv6","$ZodCheckIPv6Params","_ipv6","$ZodCIDRv4Params","$ZodCIDRv4","$ZodCheckCIDRv4Params","_cidrv4","$ZodCIDRv6Params","$ZodCIDRv6","$ZodCheckCIDRv6Params","_cidrv6","$ZodBase64Params","$ZodBase64","$ZodCheckBase64Params","_base64","$ZodBase64URLParams","$ZodBase64URL","$ZodCheckBase64URLParams","_base64url","$ZodE164Params","$ZodE164","$ZodCheckE164Params","_e164","$ZodJWTParams","$ZodJWT","$ZodCheckJWTParams","_jwt","TimePrecision","$ZodISODateTimeParams","$ZodISODateTime","$ZodCheckISODateTimeParams","_isoDateTime","$ZodISODateParams","$ZodISODate","$ZodCheckISODateParams","_isoDate","$ZodISOTimeParams","$ZodISOTime","$ZodCheckISOTimeParams","_isoTime","$ZodISODurationParams","$ZodISODuration","$ZodCheckISODurationParams","_isoDuration","$ZodNumberParams","$ZodNumber","$ZodNumberFormatParams","$ZodNumberFormat","$ZodCheckNumberFormatParams","$ZodCheckNumberFormat","_number","_coercedNumber","_int","_float32","_float64","_int32","_uint32","$ZodBooleanParams","$ZodBoolean","_boolean","_coercedBoolean","$ZodBigIntParams","$ZodBigInt","$ZodBigIntFormatParams","$ZodBigIntFormat","$ZodCheckBigIntFormatParams","$ZodCheckBigIntFormat","_bigint","_coercedBigint","_int64","_uint64","$ZodSymbolParams","$ZodSymbol","_symbol","$ZodUndefinedParams","$ZodUndefined","_undefined","$ZodNullParams","$ZodNull","_null","$ZodAnyParams","$ZodAny","_any","$ZodUnknownParams","$ZodUnknown","_unknown","$ZodNeverParams","$ZodNever","_never","$ZodVoidParams","$ZodVoid","_void","$ZodDateParams","$ZodDate","_date","_coercedDate","$ZodNaNParams","$ZodNaN","_nan","$ZodCheckLessThanParams","$ZodCheckLessThan","_lt","Numeric","_lte","_max","$ZodCheckGreaterThanParams","$ZodCheckGreaterThan","_gt","_gte","_min","_positive","_negative","_nonpositive","_nonnegative","$ZodCheckMultipleOfParams","$ZodCheckMultipleOf","_multipleOf","$ZodCheckMaxSizeParams","$ZodCheckMaxSize","_maxSize","HasSize","$ZodCheckMinSizeParams","$ZodCheckMinSize","_minSize","$ZodCheckSizeEqualsParams","$ZodCheckSizeEquals","_size","$ZodCheckMaxLengthParams","$ZodCheckMaxLength","_maxLength","HasLength","$ZodCheckMinLengthParams","$ZodCheckMinLength","_minLength","$ZodCheckLengthEqualsParams","$ZodCheckLengthEquals","_length","$ZodCheckRegexParams","$ZodCheckRegex","_regex","RegExp","$ZodCheckLowerCaseParams","$ZodCheckLowerCase","_lowercase","$ZodCheckUpperCaseParams","$ZodCheckUpperCase","_uppercase","$ZodCheckIncludesParams","$ZodCheckIncludes","_includes","$ZodCheckStartsWithParams","$ZodCheckStartsWith","_startsWith","$ZodCheckEndsWithParams","$ZodCheckEndsWith","_endsWith","$ZodCheckPropertyParams","$ZodCheckProperty","_property","K","output","$ZodCheckMimeTypeParams","$ZodCheckMimeType","_mime","MimeTypes","_overwrite","$ZodCheckOverwrite","_normalize","_trim","_toLowerCase","_toUpperCase","$ZodArrayParams","$ZodArray","_array","$ZodObjectParams","$ZodObject","$ZodUnionParams","$ZodUnion","_union","$ZodTypeDiscriminableInternals","PropValues","$ZodTypeInternals","$ZodTypeDiscriminable","$ZodDiscriminatedUnionParams","$ZodDiscriminatedUnion","_discriminatedUnion","Types","Disc","$ZodIntersectionParams","$ZodIntersection","_intersection","U","$ZodTupleParams","$ZodTuple","_tuple","Rest","$ZodRecordParams","$ZodRecord","_record","Key","Value","$ZodRecordKey","$ZodMapParams","$ZodMap","_map","$ZodSetParams","$ZodSet","_set","$ZodEnumParams","$ZodEnum","_enum","ToEnum","EnumLike","_nativeEnum","$ZodLiteralParams","$ZodLiteral","_literal","Literal","Array","$ZodFileParams","$ZodFile","_file","$ZodTransformParams","$ZodTransform","_transform","I","O","ParsePayload","Awaited","$ZodOptionalParams","$ZodOptional","_optional","$ZodNullableParams","$ZodNullable","_nullable","$ZodDefaultParams","$ZodDefault","_default","NoUndefined","$ZodNonOptionalParams","$ZodNonOptional","_nonoptional","$ZodSuccessParams","$ZodSuccess","_success","$ZodCatchParams","$ZodCatch","_catch","$ZodCatchCtx","$ZodPipeParams","$ZodPipe","_pipe","A","B","$ZodReadonlyParams","$ZodReadonly","_readonly","$ZodTemplateLiteralParams","$ZodTemplateLiteral","_templateLiteral","Parts","$ZodTemplateLiteralPart","$PartsToTemplateLiteral","$ZodLazyParams","$ZodLazy","_lazy","$ZodPromiseParams","$ZodPromise","_promise","$ZodCustomParams","$ZodCustom","_custom","_refine","$ZodSuperRefineIssue","$ZodIssue","RawIssue","MakePartial","Record","$RefinementCtx","_superRefine","Promise","_check","CheckFn","$ZodStringBoolParams","_stringbool","$ZodCodec","_stringFormat","Format","$ZodCustomStringFormat","MaybeAsync"],"sources":["../../../node_modules/zod/v4/core/api.d.cts"],"sourcesContent":["import * as checks from \"./checks.cjs\";\nimport type * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport 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] ? {} : {\n    error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;\n    /** @deprecated This parameter is deprecated. Use `error` instead. */\n    message?: string | undefined;\n})>>>;\nexport type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {\n    _isst: never;\n}, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"]>, \"type\" | \"checks\" | \"error\" | AlsoOmit>;\nexport type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },\nAlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"check\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"check\" | \"error\" | AlsoOmit>;\nexport 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>;\nexport 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>;\nexport 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>;\nexport type $ZodStringParams = TypeParams<schemas.$ZodString<string>, \"coerce\">;\nexport declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, \"format\" | \"coerce\" | \"when\" | \"pattern\">;\nexport type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, \"format\">;\nexport type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, \"when\">;\nexport type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, \"when\">;\nexport declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;\nexport type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;\nexport type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;\nexport type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;\nexport type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;\nexport type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;\nexport type $ZodURLParams = StringFormatParams<schemas.$ZodURL, \"when\">;\nexport type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, \"when\">;\nexport declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;\nexport type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;\nexport type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;\nexport type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, \"when\">;\nexport type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, \"when\">;\nexport declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;\nexport type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;\nexport type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, \"when\">;\nexport type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, \"when\">;\nexport declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;\nexport type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, \"when\">;\nexport type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, \"when\">;\nexport declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;\nexport type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;\nexport type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;\nexport type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;\nexport type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;\nexport type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;\nexport type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;\nexport type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;\nexport type $ZodE164Params = StringFormatParams<schemas.$ZodE164, \"when\">;\nexport type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, \"when\">;\nexport declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;\nexport type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;\nexport declare const TimePrecision: {\n    readonly Any: null;\n    readonly Minute: -1;\n    readonly Second: 0;\n    readonly Millisecond: 3;\n    readonly Microsecond: 6;\n};\nexport type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;\nexport type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;\nexport type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;\nexport type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;\nexport type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, \"coerce\">;\nexport type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, \"format\" | \"when\">;\nexport declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, \"coerce\">;\nexport declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;\nexport type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, \"format\" | \"when\">;\nexport declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;\nexport declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;\nexport type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;\nexport declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;\nexport type $ZodNullParams = TypeParams<schemas.$ZodNull>;\nexport declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;\nexport type $ZodAnyParams = TypeParams<schemas.$ZodAny>;\nexport declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;\nexport type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;\nexport declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;\nexport type $ZodNeverParams = TypeParams<schemas.$ZodNever>;\nexport declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;\nexport type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;\nexport declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;\nexport type $ZodDateParams = TypeParams<schemas.$ZodDate, \"coerce\">;\nexport declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;\nexport declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;\nexport type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\nexport type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\nexport declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, \"value\" | \"when\">;\nexport declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;\nexport type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, \"maximum\" | \"when\">;\nexport declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;\nexport type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, \"minimum\" | \"when\">;\nexport declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;\nexport type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, \"size\" | \"when\">;\nexport declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;\nexport type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, \"maximum\" | \"when\">;\nexport declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;\nexport type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, \"minimum\" | \"when\">;\nexport declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;\nexport type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, \"length\" | \"when\">;\nexport declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;\nexport type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, \"format\" | \"pattern\" | \"when\">;\nexport declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;\nexport type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, \"format\" | \"when\">;\nexport declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;\nexport type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, \"format\" | \"when\">;\nexport declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;\nexport type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, \"includes\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;\nexport type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, \"prefix\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;\nexport type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, \"suffix\" | \"format\" | \"pattern\" | \"when\">;\nexport declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;\nexport type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, \"property\" | \"schema\" | \"when\">;\nexport declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{\n    [k in K]: core.output<T>;\n}>;\nexport type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, \"mime\" | \"when\">;\nexport declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;\nexport declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;\nexport declare function _normalize(form?: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" | (string & {})): checks.$ZodCheckOverwrite<string>;\nexport declare function _trim(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;\nexport type $ZodArrayParams = TypeParams<schemas.$ZodArray, \"element\">;\nexport declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;\nexport type $ZodObjectParams = TypeParams<schemas.$ZodObject, \"shape\" | \"catchall\">;\nexport type $ZodUnionParams = TypeParams<schemas.$ZodUnion, \"options\">;\nexport declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;\nexport interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {\n    propValues: util.PropValues;\n}\nexport interface $ZodTypeDiscriminable extends schemas.$ZodType {\n    _zod: $ZodTypeDiscriminableInternals;\n}\nexport type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, \"options\" | \"discriminator\">;\nexport 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>;\nexport type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, \"left\" | \"right\">;\nexport declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;\nexport type $ZodTupleParams = TypeParams<schemas.$ZodTuple, \"items\" | \"rest\">;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;\nexport 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>;\nexport type $ZodRecordParams = TypeParams<schemas.$ZodRecord, \"keyType\" | \"valueType\">;\nexport 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>;\nexport type $ZodMapParams = TypeParams<schemas.$ZodMap, \"keyType\" | \"valueType\">;\nexport 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>;\nexport type $ZodSetParams = TypeParams<schemas.$ZodSet, \"valueType\">;\nexport declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;\nexport type $ZodEnumParams = TypeParams<schemas.$ZodEnum, \"entries\">;\nexport declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;\nexport declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\nexport type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, \"values\">;\nexport declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;\nexport declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;\nexport type $ZodFileParams = TypeParams<schemas.$ZodFile>;\nexport declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;\nexport type $ZodTransformParams = TypeParams<schemas.$ZodTransform, \"transform\">;\nexport declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;\nexport type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, \"innerType\">;\nexport declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;\nexport type $ZodNullableParams = TypeParams<schemas.$ZodNullable, \"innerType\">;\nexport declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;\nexport type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, \"innerType\" | \"defaultValue\">;\nexport 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>;\nexport type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, \"innerType\">;\nexport declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;\nexport type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, \"innerType\">;\nexport declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;\nexport type $ZodCatchParams = TypeParams<schemas.$ZodCatch, \"innerType\" | \"catchValue\">;\nexport 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>;\nexport type $ZodPipeParams = TypeParams<schemas.$ZodPipe, \"in\" | \"out\">;\nexport 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>;\nexport type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, \"innerType\">;\nexport declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;\nexport type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, \"parts\">;\nexport declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;\nexport type $ZodLazyParams = TypeParams<schemas.$ZodLazy, \"getter\">;\nexport declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;\nexport type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, \"innerType\">;\nexport declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;\nexport type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, \"fn\">;\nexport declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The schema or check that originated this issue. */\n    readonly inst?: schemas.$ZodType | checks.$ZodCheck;\n    /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {\n    addIssue(arg: string | $ZodSuperRefineIssue): void;\n}\nexport declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;\nexport declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;\nexport interface $ZodStringBoolParams extends TypeParams {\n    truthy?: string[];\n    falsy?: string[];\n    /**\n     * Options: `\"sensitive\"`, `\"insensitive\"`\n     *\n     * @default `\"insensitive\"`\n     */\n    case?: \"sensitive\" | \"insensitive\" | undefined;\n}\nexport declare function _stringbool(Classes: {\n    Codec?: typeof schemas.$ZodCodec;\n    Boolean?: typeof schemas.$ZodBoolean;\n    String?: typeof schemas.$ZodString;\n}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;\nexport 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>;\n"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"api.d.ts","names":["checks","core","errors","registries","schemas","util","Params","T","IssueTypes","OmitKeys","$ZodType","$ZodCheck","$ZodIssueBase","Omit","$ZodErrorMap","EmptyToNever","Partial","Flatten","TypeParams","AlsoOmit","Exclude","NonNullable","CheckParams","StringFormatParams","$ZodStringFormat","CheckStringFormatParams","CheckTypeParams","$ZodStringParams","$ZodString","_string","SchemaClass","_coercedString","$ZodStringFormatParams","$ZodCheckStringFormatParams","$ZodCheckStringFormat","$ZodEmailParams","$ZodEmail","$ZodCheckEmailParams","_email","$ZodGUIDParams","$ZodGUID","$ZodCheckGUIDParams","_guid","$ZodUUIDParams","$ZodUUID","$ZodCheckUUIDParams","_uuid","$ZodUUIDv4Params","$ZodCheckUUIDv4Params","_uuidv4","$ZodUUIDv6Params","$ZodCheckUUIDv6Params","_uuidv6","$ZodUUIDv7Params","$ZodCheckUUIDv7Params","_uuidv7","$ZodURLParams","$ZodURL","$ZodCheckURLParams","_url","$ZodEmojiParams","$ZodEmoji","$ZodCheckEmojiParams","_emoji","$ZodNanoIDParams","$ZodNanoID","$ZodCheckNanoIDParams","_nanoid","$ZodCUIDParams","$ZodCUID","$ZodCheckCUIDParams","_cuid","$ZodCUID2Params","$ZodCUID2","$ZodCheckCUID2Params","_cuid2","$ZodULIDParams","$ZodULID","$ZodCheckULIDParams","_ulid","$ZodXIDParams","$ZodXID","$ZodCheckXIDParams","_xid","$ZodKSUIDParams","$ZodKSUID","$ZodCheckKSUIDParams","_ksuid","$ZodIPv4Params","$ZodIPv4","$ZodCheckIPv4Params","_ipv4","$ZodIPv6Params","$ZodIPv6","$ZodCheckIPv6Params","_ipv6","$ZodMACParams","$ZodMAC","$ZodCheckMACParams","_mac","$ZodCIDRv4Params","$ZodCIDRv4","$ZodCheckCIDRv4Params","_cidrv4","$ZodCIDRv6Params","$ZodCIDRv6","$ZodCheckCIDRv6Params","_cidrv6","$ZodBase64Params","$ZodBase64","$ZodCheckBase64Params","_base64","$ZodBase64URLParams","$ZodBase64URL","$ZodCheckBase64URLParams","_base64url","$ZodE164Params","$ZodE164","$ZodCheckE164Params","_e164","$ZodJWTParams","$ZodJWT","$ZodCheckJWTParams","_jwt","TimePrecision","$ZodISODateTimeParams","$ZodISODateTime","$ZodCheckISODateTimeParams","_isoDateTime","$ZodISODateParams","$ZodISODate","$ZodCheckISODateParams","_isoDate","$ZodISOTimeParams","$ZodISOTime","$ZodCheckISOTimeParams","_isoTime","$ZodISODurationParams","$ZodISODuration","$ZodCheckISODurationParams","_isoDuration","$ZodNumberParams","$ZodNumber","$ZodNumberFormatParams","$ZodNumberFormat","$ZodCheckNumberFormatParams","$ZodCheckNumberFormat","_number","_coercedNumber","_int","_float32","_float64","_int32","_uint32","$ZodBooleanParams","$ZodBoolean","_boolean","_coercedBoolean","$ZodBigIntParams","$ZodBigInt","$ZodBigIntFormatParams","$ZodBigIntFormat","$ZodCheckBigIntFormatParams","$ZodCheckBigIntFormat","_bigint","_coercedBigint","_int64","_uint64","$ZodSymbolParams","$ZodSymbol","_symbol","$ZodUndefinedParams","$ZodUndefined","_undefined","$ZodNullParams","$ZodNull","_null","$ZodAnyParams","$ZodAny","_any","$ZodUnknownParams","$ZodUnknown","_unknown","$ZodNeverParams","$ZodNever","_never","$ZodVoidParams","$ZodVoid","_void","$ZodDateParams","$ZodDate","_date","_coercedDate","$ZodNaNParams","$ZodNaN","_nan","$ZodCheckLessThanParams","$ZodCheckLessThan","_lt","Numeric","_lte","_max","$ZodCheckGreaterThanParams","$ZodCheckGreaterThan","_gt","_gte","_min","_positive","_negative","_nonpositive","_nonnegative","$ZodCheckMultipleOfParams","$ZodCheckMultipleOf","_multipleOf","$ZodCheckMaxSizeParams","$ZodCheckMaxSize","_maxSize","HasSize","$ZodCheckMinSizeParams","$ZodCheckMinSize","_minSize","$ZodCheckSizeEqualsParams","$ZodCheckSizeEquals","_size","$ZodCheckMaxLengthParams","$ZodCheckMaxLength","_maxLength","HasLength","$ZodCheckMinLengthParams","$ZodCheckMinLength","_minLength","$ZodCheckLengthEqualsParams","$ZodCheckLengthEquals","_length","$ZodCheckRegexParams","$ZodCheckRegex","_regex","RegExp","$ZodCheckLowerCaseParams","$ZodCheckLowerCase","_lowercase","$ZodCheckUpperCaseParams","$ZodCheckUpperCase","_uppercase","$ZodCheckIncludesParams","$ZodCheckIncludes","_includes","$ZodCheckStartsWithParams","$ZodCheckStartsWith","_startsWith","$ZodCheckEndsWithParams","$ZodCheckEndsWith","_endsWith","$ZodCheckPropertyParams","$ZodCheckProperty","_property","K","output","$ZodCheckMimeTypeParams","$ZodCheckMimeType","_mime","MimeTypes","_overwrite","$ZodCheckOverwrite","_normalize","_trim","_toLowerCase","_toUpperCase","_slugify","$ZodArrayParams","$ZodArray","_array","$ZodObjectParams","$ZodObject","$ZodUnionParams","$ZodUnion","_union","$ZodXorParams","$ZodXor","_xor","$ZodTypeDiscriminableInternals","PropValues","$ZodTypeInternals","$ZodTypeDiscriminable","$ZodDiscriminatedUnionParams","$ZodDiscriminatedUnion","_discriminatedUnion","Types","Disc","$ZodIntersectionParams","$ZodIntersection","_intersection","U","$ZodTupleParams","$ZodTuple","_tuple","Rest","$ZodRecordParams","$ZodRecord","_record","Key","Value","$ZodRecordKey","$ZodMapParams","$ZodMap","_map","$ZodSetParams","$ZodSet","_set","$ZodEnumParams","$ZodEnum","_enum","ToEnum","EnumLike","_nativeEnum","$ZodLiteralParams","$ZodLiteral","_literal","Literal","Array","$ZodFileParams","$ZodFile","_file","$ZodTransformParams","$ZodTransform","_transform","I","O","ParsePayload","Awaited","$ZodOptionalParams","$ZodOptional","_optional","$ZodNullableParams","$ZodNullable","_nullable","$ZodDefaultParams","$ZodDefault","_default","NoUndefined","$ZodNonOptionalParams","$ZodNonOptional","_nonoptional","$ZodSuccessParams","$ZodSuccess","_success","$ZodCatchParams","$ZodCatch","_catch","$ZodCatchCtx","$ZodPipeParams","$ZodPipe","_pipe","A","B","$ZodReadonlyParams","$ZodReadonly","_readonly","$ZodTemplateLiteralParams","$ZodTemplateLiteral","_templateLiteral","Parts","$ZodTemplateLiteralPart","$PartsToTemplateLiteral","$ZodLazyParams","$ZodLazy","_lazy","$ZodPromiseParams","$ZodPromise","_promise","$ZodCustomParams","$ZodCustom","_custom","_refine","$ZodSuperRefineIssue","$ZodIssue","RawIssue","MakePartial","Record","$RefinementCtx","_superRefine","Promise","_check","CheckFn","describe","meta","GlobalMeta","$ZodStringBoolParams","_stringbool","$ZodCodec","_stringFormat","Format","$ZodCustomStringFormat","MaybeAsync"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/api.d.cts"],"sourcesContent":["import * as checks from \"./checks.cjs\";\nimport type * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport * as registries from \"./registries.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport 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] ? {} : {\n    error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;\n    /** @deprecated This parameter is deprecated. Use `error` instead. */\n    message?: string | undefined;\n})>>>;\nexport type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {\n    _isst: never;\n}, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"]>, \"type\" | \"checks\" | \"error\" | AlsoOmit>;\nexport type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },\nAlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"check\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"check\" | \"error\" | AlsoOmit>;\nexport 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>;\nexport 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>;\nexport 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>;\nexport type $ZodStringParams = TypeParams<schemas.$ZodString<string>, \"coerce\">;\nexport declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, \"format\" | \"coerce\" | \"when\" | \"pattern\">;\nexport type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, \"format\">;\nexport type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, \"when\">;\nexport type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, \"when\">;\nexport declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;\nexport type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;\nexport type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;\nexport type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;\nexport type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;\nexport type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;\nexport type $ZodURLParams = StringFormatParams<schemas.$ZodURL, \"when\">;\nexport type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, \"when\">;\nexport declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;\nexport type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;\nexport type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;\nexport type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, \"when\">;\nexport type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, \"when\">;\nexport declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;\nexport type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;\nexport type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, \"when\">;\nexport type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, \"when\">;\nexport declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;\nexport type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, \"when\">;\nexport type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, \"when\">;\nexport declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;\nexport type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;\nexport type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;\nexport type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;\nexport type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, \"pattern\" | \"when\">;\nexport type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, \"pattern\" | \"when\">;\nexport declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;\nexport type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;\nexport type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;\nexport type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;\nexport type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;\nexport type $ZodE164Params = StringFormatParams<schemas.$ZodE164, \"when\">;\nexport type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, \"when\">;\nexport declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;\nexport type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;\nexport declare const TimePrecision: {\n    readonly Any: null;\n    readonly Minute: -1;\n    readonly Second: 0;\n    readonly Millisecond: 3;\n    readonly Microsecond: 6;\n};\nexport type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;\nexport type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;\nexport type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;\nexport type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;\nexport type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, \"coerce\">;\nexport type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, \"format\" | \"when\">;\nexport declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, \"coerce\">;\nexport declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;\nexport type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, \"format\" | \"when\">;\nexport declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;\nexport declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;\nexport type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;\nexport declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;\nexport type $ZodNullParams = TypeParams<schemas.$ZodNull>;\nexport declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;\nexport type $ZodAnyParams = TypeParams<schemas.$ZodAny>;\nexport declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;\nexport type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;\nexport declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;\nexport type $ZodNeverParams = TypeParams<schemas.$ZodNever>;\nexport declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;\nexport type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;\nexport declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;\nexport type $ZodDateParams = TypeParams<schemas.$ZodDate, \"coerce\">;\nexport declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;\nexport declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;\nexport type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\nexport type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\nexport declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, \"value\" | \"when\">;\nexport declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;\nexport type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, \"maximum\" | \"when\">;\nexport declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;\nexport type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, \"minimum\" | \"when\">;\nexport declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;\nexport type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, \"size\" | \"when\">;\nexport declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;\nexport type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, \"maximum\" | \"when\">;\nexport declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;\nexport type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, \"minimum\" | \"when\">;\nexport declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;\nexport type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, \"length\" | \"when\">;\nexport declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;\nexport type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, \"format\" | \"pattern\" | \"when\">;\nexport declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;\nexport type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, \"format\" | \"when\">;\nexport declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;\nexport type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, \"format\" | \"when\">;\nexport declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;\nexport type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, \"includes\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;\nexport type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, \"prefix\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;\nexport type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, \"suffix\" | \"format\" | \"pattern\" | \"when\">;\nexport declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;\nexport type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, \"property\" | \"schema\" | \"when\">;\nexport declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{\n    [k in K]: core.output<T>;\n}>;\nexport type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, \"mime\" | \"when\">;\nexport declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;\nexport declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;\nexport declare function _normalize(form?: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" | (string & {})): checks.$ZodCheckOverwrite<string>;\nexport declare function _trim(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _slugify(): checks.$ZodCheckOverwrite<string>;\nexport type $ZodArrayParams = TypeParams<schemas.$ZodArray, \"element\">;\nexport declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;\nexport type $ZodObjectParams = TypeParams<schemas.$ZodObject, \"shape\" | \"catchall\">;\nexport type $ZodUnionParams = TypeParams<schemas.$ZodUnion, \"options\">;\nexport declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;\nexport type $ZodXorParams = TypeParams<schemas.$ZodXor, \"options\">;\nexport declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;\nexport interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {\n    propValues: util.PropValues;\n}\nexport interface $ZodTypeDiscriminable extends schemas.$ZodType {\n    _zod: $ZodTypeDiscriminableInternals;\n}\nexport type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, \"options\" | \"discriminator\">;\nexport 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>;\nexport type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, \"left\" | \"right\">;\nexport declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;\nexport type $ZodTupleParams = TypeParams<schemas.$ZodTuple, \"items\" | \"rest\">;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;\nexport 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>;\nexport type $ZodRecordParams = TypeParams<schemas.$ZodRecord, \"keyType\" | \"valueType\">;\nexport 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>;\nexport type $ZodMapParams = TypeParams<schemas.$ZodMap, \"keyType\" | \"valueType\">;\nexport 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>;\nexport type $ZodSetParams = TypeParams<schemas.$ZodSet, \"valueType\">;\nexport declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;\nexport type $ZodEnumParams = TypeParams<schemas.$ZodEnum, \"entries\">;\nexport declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;\nexport declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\nexport type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, \"values\">;\nexport declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;\nexport declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;\nexport type $ZodFileParams = TypeParams<schemas.$ZodFile>;\nexport declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;\nexport type $ZodTransformParams = TypeParams<schemas.$ZodTransform, \"transform\">;\nexport declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;\nexport type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, \"innerType\">;\nexport declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;\nexport type $ZodNullableParams = TypeParams<schemas.$ZodNullable, \"innerType\">;\nexport declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;\nexport type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, \"innerType\" | \"defaultValue\">;\nexport 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>;\nexport type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, \"innerType\">;\nexport declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;\nexport type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, \"innerType\">;\nexport declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;\nexport type $ZodCatchParams = TypeParams<schemas.$ZodCatch, \"innerType\" | \"catchValue\">;\nexport 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>;\nexport type $ZodPipeParams = TypeParams<schemas.$ZodPipe, \"in\" | \"out\">;\nexport 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>;\nexport type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, \"innerType\">;\nexport declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;\nexport type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, \"parts\">;\nexport declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;\nexport type $ZodLazyParams = TypeParams<schemas.$ZodLazy, \"getter\">;\nexport declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;\nexport type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, \"innerType\">;\nexport declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;\nexport type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, \"fn\">;\nexport declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The schema or check that originated this issue. */\n    readonly inst?: schemas.$ZodType | checks.$ZodCheck;\n    /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {\n    addIssue(arg: string | $ZodSuperRefineIssue): void;\n}\nexport declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;\nexport declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;\nexport declare function describe<T>(description: string): checks.$ZodCheck<T>;\nexport declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;\nexport interface $ZodStringBoolParams extends TypeParams {\n    truthy?: string[];\n    falsy?: string[];\n    /**\n     * Options: `\"sensitive\"`, `\"insensitive\"`\n     *\n     * @default `\"insensitive\"`\n     */\n    case?: \"sensitive\" | \"insensitive\" | undefined;\n}\nexport declare function _stringbool(Classes: {\n    Codec?: typeof schemas.$ZodCodec;\n    Boolean?: typeof schemas.$ZodBoolean;\n    String?: typeof schemas.$ZodString;\n}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;\nexport 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>;\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/checks.d.ts

@@ -3,7 +3,7 @@ import { $ZodType, ParsePayload } from "./schemas.js";
 import { $ZodErrorMap, $ZodIssueBase, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueNotMultipleOf, $ZodIssueTooBig, $ZodIssueTooSmall } from "./errors.js";
 import { $constructor } from "./core.js";
 
-//#region ../../node_modules/zod/v4/core/checks.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/checks.d.cts
 interface $ZodCheckDef {
   check: string;
   error?: $ZodErrorMap<never> | undefined;

package/checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checks.d.ts","names":["core","errors","schemas","util","$ZodCheckDef","$ZodErrorMap","ParsePayload","$ZodCheckInternals","T","$ZodIssueBase","MaybeAsync","$ZodType","$ZodCheck","$constructor","$ZodCheckLessThanDef","Numeric","$ZodCheckLessThanInternals","$ZodIssueTooBig","$ZodCheckLessThan","$ZodCheckGreaterThanDef","$ZodCheckGreaterThanInternals","$ZodIssueTooSmall","$ZodCheckGreaterThan","$ZodCheckMultipleOfDef","$ZodCheckMultipleOfInternals","$ZodIssueNotMultipleOf","$ZodCheckMultipleOf","$ZodNumberFormats","$ZodCheckNumberFormatDef","$ZodCheckNumberFormatInternals","$ZodIssueInvalidType","$ZodCheckNumberFormat","$ZodBigIntFormats","$ZodCheckBigIntFormatDef","$ZodCheckBigIntFormatInternals","$ZodCheckBigIntFormat","$ZodCheckMaxSizeDef","$ZodCheckMaxSizeInternals","HasSize","$ZodCheckMaxSize","$ZodCheckMinSizeDef","$ZodCheckMinSizeInternals","$ZodCheckMinSize","$ZodCheckSizeEqualsDef","$ZodCheckSizeEqualsInternals","$ZodCheckSizeEquals","$ZodCheckMaxLengthDef","$ZodCheckMaxLengthInternals","HasLength","$ZodCheckMaxLength","$ZodCheckMinLengthDef","$ZodCheckMinLengthInternals","$ZodCheckMinLength","$ZodCheckLengthEqualsDef","$ZodCheckLengthEqualsInternals","$ZodCheckLengthEquals","$ZodStringFormats","$ZodCheckStringFormatDef","Format","RegExp","$ZodCheckStringFormatInternals","$ZodIssueInvalidStringFormat","$ZodCheckStringFormat","$ZodCheckRegexDef","$ZodCheckRegexInternals","$ZodCheckRegex","$ZodCheckLowerCaseDef","$ZodCheckLowerCaseInternals","$ZodCheckLowerCase","$ZodCheckUpperCaseDef","$ZodCheckUpperCaseInternals","$ZodCheckUpperCase","$ZodCheckIncludesDef","$ZodCheckIncludesInternals","$ZodCheckIncludes","$ZodCheckStartsWithDef","$ZodCheckStartsWithInternals","$ZodCheckStartsWith","$ZodCheckEndsWithDef","$ZodCheckEndsWithInternals","$ZodCheckEndsWith","$ZodCheckPropertyDef","$ZodCheckPropertyInternals","$ZodIssue","$ZodCheckProperty","$ZodCheckMimeTypeDef","MimeTypes","$ZodCheckMimeTypeInternals","File","$ZodIssueInvalidValue","$ZodCheckMimeType","$ZodCheckOverwriteDef","$ZodCheckOverwriteInternals","$ZodCheckOverwrite","$ZodChecks","$ZodStringFormatChecks","$ZodStringFormatTypes"],"sources":["../../../node_modules/zod/v4/core/checks.d.cts"],"sourcesContent":["import * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport type * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport interface $ZodCheckDef {\n    check: string;\n    error?: errors.$ZodErrorMap<never> | undefined;\n    /** If true, no later checks will be executed if this check fails. Default `false`. */\n    abort?: boolean | undefined;\n    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */\n    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;\n}\nexport interface $ZodCheckInternals<T> {\n    def: $ZodCheckDef;\n    /** The set of issues this check might throw. */\n    issc?: errors.$ZodIssueBase;\n    check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;\n    onattach: ((schema: schemas.$ZodType) => void)[];\n}\nexport interface $ZodCheck<in T = never> {\n    _zod: $ZodCheckInternals<T>;\n}\nexport declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;\nexport interface $ZodCheckLessThanDef extends $ZodCheckDef {\n    check: \"less_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLessThanDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckLessThanInternals<T>;\n}\nexport declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;\nexport interface $ZodCheckGreaterThanDef extends $ZodCheckDef {\n    check: \"greater_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckGreaterThanDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckGreaterThanInternals<T>;\n}\nexport declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;\nexport interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {\n    check: \"multiple_of\";\n    value: T;\n}\nexport interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMultipleOfDef<T>;\n    issc: errors.$ZodIssueNotMultipleOf;\n}\nexport interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {\n    _zod: $ZodCheckMultipleOfInternals<T>;\n}\nexport declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;\nexport type $ZodNumberFormats = \"int32\" | \"uint32\" | \"float32\" | \"float64\" | \"safeint\";\nexport interface $ZodCheckNumberFormatDef extends $ZodCheckDef {\n    check: \"number_format\";\n    format: $ZodNumberFormats;\n}\nexport interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {\n    def: $ZodCheckNumberFormatDef;\n    issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<\"number\"> | errors.$ZodIssueTooSmall<\"number\">;\n}\nexport interface $ZodCheckNumberFormat extends $ZodCheck<number> {\n    _zod: $ZodCheckNumberFormatInternals;\n}\nexport declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;\nexport type $ZodBigIntFormats = \"int64\" | \"uint64\";\nexport interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {\n    check: \"bigint_format\";\n    format: $ZodBigIntFormats | undefined;\n}\nexport interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {\n    def: $ZodCheckBigIntFormatDef;\n    issc: errors.$ZodIssueTooBig<\"bigint\"> | errors.$ZodIssueTooSmall<\"bigint\">;\n}\nexport interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {\n    _zod: $ZodCheckBigIntFormatInternals;\n}\nexport declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;\nexport interface $ZodCheckMaxSizeDef extends $ZodCheckDef {\n    check: \"max_size\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxSizeDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxSizeInternals<T>;\n}\nexport declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;\nexport interface $ZodCheckMinSizeDef extends $ZodCheckDef {\n    check: \"min_size\";\n    minimum: number;\n}\nexport interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinSizeDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinSizeInternals<T>;\n}\nexport declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;\nexport interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {\n    check: \"size_equals\";\n    size: number;\n}\nexport interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckSizeEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckSizeEqualsInternals<T>;\n}\nexport declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;\nexport interface $ZodCheckMaxLengthDef extends $ZodCheckDef {\n    check: \"max_length\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxLengthDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxLengthInternals<T>;\n}\nexport declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;\nexport interface $ZodCheckMinLengthDef extends $ZodCheckDef {\n    check: \"min_length\";\n    minimum: number;\n}\nexport interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinLengthDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinLengthInternals<T>;\n}\nexport declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;\nexport interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {\n    check: \"length_equals\";\n    length: number;\n}\nexport interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLengthEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckLengthEqualsInternals<T>;\n}\nexport declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;\nexport 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\";\nexport interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {\n    check: \"string_format\";\n    format: Format;\n    pattern?: RegExp | undefined;\n}\nexport interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStringFormatDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStringFormat extends $ZodCheck<string> {\n    _zod: $ZodCheckStringFormatInternals;\n}\nexport declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;\nexport interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {\n    format: \"regex\";\n    pattern: RegExp;\n}\nexport interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckRegexDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckRegex extends $ZodCheck<string> {\n    _zod: $ZodCheckRegexInternals;\n}\nexport declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;\nexport interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<\"lowercase\"> {\n}\nexport interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckLowerCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckLowerCase extends $ZodCheck<string> {\n    _zod: $ZodCheckLowerCaseInternals;\n}\nexport declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;\nexport interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<\"uppercase\"> {\n}\nexport interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckUpperCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckUpperCase extends $ZodCheck<string> {\n    _zod: $ZodCheckUpperCaseInternals;\n}\nexport declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;\nexport interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<\"includes\"> {\n    includes: string;\n    position?: number | undefined;\n}\nexport interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckIncludesDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckIncludes extends $ZodCheck<string> {\n    _zod: $ZodCheckIncludesInternals;\n}\nexport declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;\nexport interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<\"starts_with\"> {\n    prefix: string;\n}\nexport interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStartsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStartsWith extends $ZodCheck<string> {\n    _zod: $ZodCheckStartsWithInternals;\n}\nexport declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;\nexport interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<\"ends_with\"> {\n    suffix: string;\n}\nexport interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckEndsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {\n    _zod: $ZodCheckEndsWithInternals;\n}\nexport declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;\nexport interface $ZodCheckPropertyDef extends $ZodCheckDef {\n    check: \"property\";\n    property: string;\n    schema: schemas.$ZodType;\n}\nexport interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {\n    def: $ZodCheckPropertyDef;\n    issc: errors.$ZodIssue;\n}\nexport interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {\n    _zod: $ZodCheckPropertyInternals<T>;\n}\nexport declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;\nexport interface $ZodCheckMimeTypeDef extends $ZodCheckDef {\n    check: \"mime_type\";\n    mime: util.MimeTypes[];\n}\nexport interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMimeTypeDef;\n    issc: errors.$ZodIssueInvalidValue;\n}\nexport interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {\n    _zod: $ZodCheckMimeTypeInternals<T>;\n}\nexport declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;\nexport interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {\n    check: \"overwrite\";\n    tx(value: T): T;\n}\nexport interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {\n    def: $ZodCheckOverwriteDef<T>;\n    issc: never;\n}\nexport interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {\n    _zod: $ZodCheckOverwriteInternals<T>;\n}\nexport declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;\nexport type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;\nexport type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;\n"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"checks.d.ts","names":["core","errors","schemas","util","$ZodCheckDef","$ZodErrorMap","ParsePayload","$ZodCheckInternals","T","$ZodIssueBase","MaybeAsync","$ZodType","$ZodCheck","$constructor","$ZodCheckLessThanDef","Numeric","$ZodCheckLessThanInternals","$ZodIssueTooBig","$ZodCheckLessThan","$ZodCheckGreaterThanDef","$ZodCheckGreaterThanInternals","$ZodIssueTooSmall","$ZodCheckGreaterThan","$ZodCheckMultipleOfDef","$ZodCheckMultipleOfInternals","$ZodIssueNotMultipleOf","$ZodCheckMultipleOf","$ZodNumberFormats","$ZodCheckNumberFormatDef","$ZodCheckNumberFormatInternals","$ZodIssueInvalidType","$ZodCheckNumberFormat","$ZodBigIntFormats","$ZodCheckBigIntFormatDef","$ZodCheckBigIntFormatInternals","$ZodCheckBigIntFormat","$ZodCheckMaxSizeDef","$ZodCheckMaxSizeInternals","HasSize","$ZodCheckMaxSize","$ZodCheckMinSizeDef","$ZodCheckMinSizeInternals","$ZodCheckMinSize","$ZodCheckSizeEqualsDef","$ZodCheckSizeEqualsInternals","$ZodCheckSizeEquals","$ZodCheckMaxLengthDef","$ZodCheckMaxLengthInternals","HasLength","$ZodCheckMaxLength","$ZodCheckMinLengthDef","$ZodCheckMinLengthInternals","$ZodCheckMinLength","$ZodCheckLengthEqualsDef","$ZodCheckLengthEqualsInternals","$ZodCheckLengthEquals","$ZodStringFormats","$ZodCheckStringFormatDef","Format","RegExp","$ZodCheckStringFormatInternals","$ZodIssueInvalidStringFormat","$ZodCheckStringFormat","$ZodCheckRegexDef","$ZodCheckRegexInternals","$ZodCheckRegex","$ZodCheckLowerCaseDef","$ZodCheckLowerCaseInternals","$ZodCheckLowerCase","$ZodCheckUpperCaseDef","$ZodCheckUpperCaseInternals","$ZodCheckUpperCase","$ZodCheckIncludesDef","$ZodCheckIncludesInternals","$ZodCheckIncludes","$ZodCheckStartsWithDef","$ZodCheckStartsWithInternals","$ZodCheckStartsWith","$ZodCheckEndsWithDef","$ZodCheckEndsWithInternals","$ZodCheckEndsWith","$ZodCheckPropertyDef","$ZodCheckPropertyInternals","$ZodIssue","$ZodCheckProperty","$ZodCheckMimeTypeDef","MimeTypes","$ZodCheckMimeTypeInternals","File","$ZodIssueInvalidValue","$ZodCheckMimeType","$ZodCheckOverwriteDef","$ZodCheckOverwriteInternals","$ZodCheckOverwrite","$ZodChecks","$ZodStringFormatChecks","$ZodStringFormatTypes"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/checks.d.cts"],"sourcesContent":["import * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport type * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport interface $ZodCheckDef {\n    check: string;\n    error?: errors.$ZodErrorMap<never> | undefined;\n    /** If true, no later checks will be executed if this check fails. Default `false`. */\n    abort?: boolean | undefined;\n    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */\n    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;\n}\nexport interface $ZodCheckInternals<T> {\n    def: $ZodCheckDef;\n    /** The set of issues this check might throw. */\n    issc?: errors.$ZodIssueBase;\n    check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;\n    onattach: ((schema: schemas.$ZodType) => void)[];\n}\nexport interface $ZodCheck<in T = never> {\n    _zod: $ZodCheckInternals<T>;\n}\nexport declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;\nexport interface $ZodCheckLessThanDef extends $ZodCheckDef {\n    check: \"less_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLessThanDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckLessThanInternals<T>;\n}\nexport declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;\nexport interface $ZodCheckGreaterThanDef extends $ZodCheckDef {\n    check: \"greater_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckGreaterThanDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckGreaterThanInternals<T>;\n}\nexport declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;\nexport interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {\n    check: \"multiple_of\";\n    value: T;\n}\nexport interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMultipleOfDef<T>;\n    issc: errors.$ZodIssueNotMultipleOf;\n}\nexport interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {\n    _zod: $ZodCheckMultipleOfInternals<T>;\n}\nexport declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;\nexport type $ZodNumberFormats = \"int32\" | \"uint32\" | \"float32\" | \"float64\" | \"safeint\";\nexport interface $ZodCheckNumberFormatDef extends $ZodCheckDef {\n    check: \"number_format\";\n    format: $ZodNumberFormats;\n}\nexport interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {\n    def: $ZodCheckNumberFormatDef;\n    issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<\"number\"> | errors.$ZodIssueTooSmall<\"number\">;\n}\nexport interface $ZodCheckNumberFormat extends $ZodCheck<number> {\n    _zod: $ZodCheckNumberFormatInternals;\n}\nexport declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;\nexport type $ZodBigIntFormats = \"int64\" | \"uint64\";\nexport interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {\n    check: \"bigint_format\";\n    format: $ZodBigIntFormats | undefined;\n}\nexport interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {\n    def: $ZodCheckBigIntFormatDef;\n    issc: errors.$ZodIssueTooBig<\"bigint\"> | errors.$ZodIssueTooSmall<\"bigint\">;\n}\nexport interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {\n    _zod: $ZodCheckBigIntFormatInternals;\n}\nexport declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;\nexport interface $ZodCheckMaxSizeDef extends $ZodCheckDef {\n    check: \"max_size\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxSizeDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxSizeInternals<T>;\n}\nexport declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;\nexport interface $ZodCheckMinSizeDef extends $ZodCheckDef {\n    check: \"min_size\";\n    minimum: number;\n}\nexport interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinSizeDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinSizeInternals<T>;\n}\nexport declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;\nexport interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {\n    check: \"size_equals\";\n    size: number;\n}\nexport interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckSizeEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckSizeEqualsInternals<T>;\n}\nexport declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;\nexport interface $ZodCheckMaxLengthDef extends $ZodCheckDef {\n    check: \"max_length\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxLengthDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxLengthInternals<T>;\n}\nexport declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;\nexport interface $ZodCheckMinLengthDef extends $ZodCheckDef {\n    check: \"min_length\";\n    minimum: number;\n}\nexport interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinLengthDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinLengthInternals<T>;\n}\nexport declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;\nexport interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {\n    check: \"length_equals\";\n    length: number;\n}\nexport interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLengthEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckLengthEqualsInternals<T>;\n}\nexport declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;\nexport 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\";\nexport interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {\n    check: \"string_format\";\n    format: Format;\n    pattern?: RegExp | undefined;\n}\nexport interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStringFormatDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStringFormat extends $ZodCheck<string> {\n    _zod: $ZodCheckStringFormatInternals;\n}\nexport declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;\nexport interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {\n    format: \"regex\";\n    pattern: RegExp;\n}\nexport interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckRegexDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckRegex extends $ZodCheck<string> {\n    _zod: $ZodCheckRegexInternals;\n}\nexport declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;\nexport interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<\"lowercase\"> {\n}\nexport interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckLowerCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckLowerCase extends $ZodCheck<string> {\n    _zod: $ZodCheckLowerCaseInternals;\n}\nexport declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;\nexport interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<\"uppercase\"> {\n}\nexport interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckUpperCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckUpperCase extends $ZodCheck<string> {\n    _zod: $ZodCheckUpperCaseInternals;\n}\nexport declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;\nexport interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<\"includes\"> {\n    includes: string;\n    position?: number | undefined;\n}\nexport interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckIncludesDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckIncludes extends $ZodCheck<string> {\n    _zod: $ZodCheckIncludesInternals;\n}\nexport declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;\nexport interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<\"starts_with\"> {\n    prefix: string;\n}\nexport interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStartsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStartsWith extends $ZodCheck<string> {\n    _zod: $ZodCheckStartsWithInternals;\n}\nexport declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;\nexport interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<\"ends_with\"> {\n    suffix: string;\n}\nexport interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckEndsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {\n    _zod: $ZodCheckEndsWithInternals;\n}\nexport declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;\nexport interface $ZodCheckPropertyDef extends $ZodCheckDef {\n    check: \"property\";\n    property: string;\n    schema: schemas.$ZodType;\n}\nexport interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {\n    def: $ZodCheckPropertyDef;\n    issc: errors.$ZodIssue;\n}\nexport interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {\n    _zod: $ZodCheckPropertyInternals<T>;\n}\nexport declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;\nexport interface $ZodCheckMimeTypeDef extends $ZodCheckDef {\n    check: \"mime_type\";\n    mime: util.MimeTypes[];\n}\nexport interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMimeTypeDef;\n    issc: errors.$ZodIssueInvalidValue;\n}\nexport interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {\n    _zod: $ZodCheckMimeTypeInternals<T>;\n}\nexport declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;\nexport interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {\n    check: \"overwrite\";\n    tx(value: T): T;\n}\nexport interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {\n    def: $ZodCheckOverwriteDef<T>;\n    issc: never;\n}\nexport interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {\n    _zod: $ZodCheckOverwriteInternals<T>;\n}\nexport declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;\nexport type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;\nexport type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/clsx.d.ts

@@ -1,4 +1,4 @@
-//#region ../../node_modules/clsx/clsx.d.mts
+//#region ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/clsx.d.mts
 type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
 type ClassDictionary = Record<string, any>;
 type ClassArray = ClassValue[];

package/clsx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clsx.d.ts","names":["ClassValue","ClassArray","ClassDictionary","Record","clsx","default"],"sources":["../../../node_modules/clsx/clsx.d.mts"],"sourcesContent":["export type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;\nexport type ClassDictionary = Record<string, any>;\nexport type ClassArray = ClassValue[];\n\nexport function clsx(...inputs: ClassValue[]): string;\nexport default clsx;\n"],"x_google_ignoreList":[0],"mappings":";KAAYA,UAAAA,GAAaC,aAAaC;AAA1BF,KACAE,eAAAA,GAAkBC,MADLF,CAAAA,MAAaC,EAAAA,GAAAA,CAAAA;AAC1BA,KACAD,UAAAA,GAAaD,UADKG,EAAAA"}
+{"version":3,"file":"clsx.d.ts","names":["ClassValue","ClassArray","ClassDictionary","Record","clsx","default"],"sources":["../../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/clsx.d.mts"],"sourcesContent":["export type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;\nexport type ClassDictionary = Record<string, any>;\nexport type ClassArray = ClassValue[];\n\nexport function clsx(...inputs: ClassValue[]): string;\nexport default clsx;\n"],"x_google_ignoreList":[0],"mappings":";KAAYA,UAAAA,GAAaC,aAAaC;AAA1BF,KACAE,eAAAA,GAAkBC,MADLF,CAAAA,MAAaC,EAAAA,GAAAA,CAAAA;AAC1BA,KACAD,UAAAA,GAAaD,UADKG,EAAAA"}

package/coerce.d.ts

@@ -1,7 +1,7 @@
 import { $ZodNumberInternals } from "./schemas.js";
 import { _ZodNumber } from "./schemas2.js";
 
-//#region ../../node_modules/zod/v4/classic/coerce.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/classic/coerce.d.cts
 
 interface ZodCoercedNumber<T = unknown> extends _ZodNumber<$ZodNumberInternals<T>> {}
 //#endregion

package/coerce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coerce.d.ts","names":["core","schemas","ZodCoercedString","T","$ZodStringInternals","_ZodString","string","$ZodStringParams","ZodCoercedNumber","$ZodNumberInternals","_ZodNumber","number","$ZodNumberParams","ZodCoercedBoolean","$ZodBooleanInternals","_ZodBoolean","boolean","$ZodBooleanParams","ZodCoercedBigInt","$ZodBigIntInternals","_ZodBigInt","bigint","$ZodBigIntParams","ZodCoercedDate","$ZodDateInternals","_ZodDate","date","$ZodDateParams"],"sources":["../../../node_modules/zod/v4/classic/coerce.d.cts"],"sourcesContent":["import * as core from \"../core/index.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nexport interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {\n}\nexport declare function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;\nexport interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {\n}\nexport declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;\nexport interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {\n}\nexport declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;\nexport interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {\n}\nexport declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;\nexport interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {\n}\nexport declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAKmGG,UAAlFK,gBAAkFL,CAAAA,IAAAA,OAAAA,CAAAA,SAA5CF,UAA4CE,CAAzBH,mBAAyBG,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA"}
+{"version":3,"file":"coerce.d.ts","names":["core","schemas","ZodCoercedString","T","$ZodStringInternals","_ZodString","string","$ZodStringParams","ZodCoercedNumber","$ZodNumberInternals","_ZodNumber","number","$ZodNumberParams","ZodCoercedBoolean","$ZodBooleanInternals","_ZodBoolean","boolean","$ZodBooleanParams","ZodCoercedBigInt","$ZodBigIntInternals","_ZodBigInt","bigint","$ZodBigIntParams","ZodCoercedDate","$ZodDateInternals","_ZodDate","date","$ZodDateParams"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/classic/coerce.d.cts"],"sourcesContent":["import * as core from \"../core/index.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nexport interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {\n}\nexport declare function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;\nexport interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {\n}\nexport declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;\nexport interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {\n}\nexport declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;\nexport interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {\n}\nexport declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;\nexport interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {\n}\nexport declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAKmGG,UAAlFK,gBAAkFL,CAAAA,IAAAA,OAAAA,CAAAA,SAA5CF,UAA4CE,CAAzBH,mBAAyBG,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA"}

package/conversation.d.ts

@@ -84,8 +84,8 @@ declare const createConversationResponseSchema: ZodObject<{
     visitorId: ZodString;
     websiteId: ZodString;
     status: ZodDefault<ZodEnum<{
-      resolved: "resolved";
       open: "open";
+      resolved: "resolved";
       spam: "spam";
     }>>;
     deletedAt: ZodDefault<ZodNullable<ZodString>>;
@@ -189,8 +189,8 @@ declare const listConversationsResponseSchema: ZodObject<{
     visitorId: ZodString;
     websiteId: ZodString;
     status: ZodDefault<ZodEnum<{
-      resolved: "resolved";
       open: "open";
+      resolved: "resolved";
       spam: "spam";
     }>>;
     deletedAt: ZodDefault<ZodNullable<ZodString>>;
@@ -287,8 +287,8 @@ declare const getConversationResponseSchema: ZodObject<{
     visitorId: ZodString;
     websiteId: ZodString;
     status: ZodDefault<ZodEnum<{
-      resolved: "resolved";
       open: "open";
+      resolved: "resolved";
       spam: "spam";
     }>>;
     deletedAt: ZodDefault<ZodNullable<ZodString>>;

package/core.d.ts

@@ -1,7 +1,7 @@
 import { Class } from "./util.js";
 import { SomeType } from "./schemas.js";
 
-//#region ../../node_modules/zod/v4/core/core.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/core.d.cts
 type ZodTrait = {
   _zod: {
     def: any;

package/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","names":["errors","schemas","Class","ZodTrait","$constructor","T","D","NEVER","$brand","$ZodBranded","Brand","SomeType","output","Record","$ZodAsyncError","Error","$ZodEncodeError","input","infer","$ZodConfig","$ZodErrorMap","globalConfig","config","Partial"],"sources":["../../../node_modules/zod/v4/core/core.d.cts"],"sourcesContent":["import type * as errors from \"./errors.cjs\";\nimport type * as schemas from \"./schemas.cjs\";\nimport type { Class } from \"./util.cjs\";\ntype ZodTrait = {\n    _zod: {\n        def: any;\n        [k: string]: any;\n    };\n};\nexport interface $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]> {\n    new (def: D): T;\n    init(inst: T, def: D): asserts inst is T;\n}\n/** A special constant with type `never` */\nexport declare const NEVER: never;\nexport declare function $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]>(name: string, initializer: (inst: T, def: D) => void, params?: {\n    Parent?: typeof Class;\n}): $constructor<T, D>;\nexport declare const $brand: unique symbol;\nexport type $brand<T extends string | number | symbol = string | number | symbol> = {\n    [$brand]: {\n        [k in T]: true;\n    };\n};\nexport type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<\"_zod\", Record<\"output\", output<T> & $brand<Brand>>>;\nexport declare class $ZodAsyncError extends Error {\n    constructor();\n}\nexport declare class $ZodEncodeError extends Error {\n    constructor(name: string);\n}\nexport type input<T> = T extends {\n    _zod: {\n        input: any;\n    };\n} ? T[\"_zod\"][\"input\"] : unknown;\nexport type output<T> = T extends {\n    _zod: {\n        output: any;\n    };\n} ? T[\"_zod\"][\"output\"] : unknown;\nexport type { output as infer };\nexport interface $ZodConfig {\n    /** Custom error map. Overrides `config().localeError`. */\n    customError?: errors.$ZodErrorMap | undefined;\n    /** Localized error map. Lowest priority. */\n    localeError?: errors.$ZodErrorMap | undefined;\n    /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */\n    jitless?: boolean | undefined;\n}\nexport declare const globalConfig: $ZodConfig;\nexport declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;\n"],"x_google_ignoreList":[0],"mappings":";;;;KAGKG,QAAAA;EAAAA,IAAAA,EAAAA;IAMYC,GAAAA,EAAAA,GAAAA;IAAuBD,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,GAAAA;EAAcE,CAAAA;CACxCC;AAAID,UADDD,YACCC,CAAAA,UADsBF,QACtBE,EAAAA,IADoCA,CACpCA,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,CAAAA,CAAAA;EACHA,KAAAA,GAAAA,EADDC,CACCD,CAAAA,EADGA,CACHA;EAAQC,IAAAA,CAAAA,IAAAA,EAARD,CAAQC,EAAAA,GAAAA,EAAAA,CAAAA,CAAAA,EAAAA,QAAAA,IAAAA,IAAoBD,CAApBC;;AAIwBH,iBAAvBC,YAAuBD,CAAAA,UAAAA,QAAAA,EAAAA,IAAcE,CAAdF,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,CAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,CAAAA,IAAAA,EAAkEE,CAAlEF,EAAAA,GAAAA,EAA0EG,CAA1EH,EAAAA,GAAAA,IAAAA,EAAAA,MAAkEE,CAAlEF,EAAAA;EAAcE,MAAAA,CAAAA,EAAAA,OACzCH,KADyCG;CAAoDA,CAAAA,EAE7GD,YAF6GC,CAEhGA,CAFgGA,EAE7FC,CAF6FD,CAAAA;AAAQC,cAGpGE,MAHoGF,EAAAA,OAAAA,MAAAA;AACrGJ,KAGRM,MAHQN,CAAAA,UAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,CAAAA,GAAAA;EACHG,CAGZG,MAAAA,CAHYH,EAAAA,QAIHA,CAJMC,GAAAA,IAAAA,EAAhBF;CAAY;AACKI,KAMTC,WAN8B,CAAA,UAMRR,QANQ,EAAA,cAAA,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,GAMoDI,CANpD,GAMwDQ,MANxD,CAAA,MAAA,EAMuEA,MANvE,CAAA,QAAA,EAMwFD,MANxF,CAM+FP,CAN/F,CAAA,GAMoGG,MANpG,CAM2GE,KAN3G,CAAA,CAAA,CAAA;AAM2GA,KAOzIO,KAPyIP,CAAAA,CAAAA,CAAAA,GAO9HL,CAP8HK,SAAAA;EAAPF,IAAAA,EAAAA;IAA7BK,KAAAA,EAAAA,GAAAA;EAAfA,CAAAA;CAAM,GAWpGR,CAXoG,CAAA,MAAA,CAAA,CAAA,OAAA,CAAA,GAAA,OAAA;AAO5FY,KAKAL,MALK,CAAA,CAAAP,CAAAA,GAKOA,CALPA,SAIZ;EACOO,IAAAA,EAAAA;;;IAIRP"}
+{"version":3,"file":"core.d.ts","names":["errors","schemas","Class","ZodTrait","$constructor","T","D","NEVER","$brand","$ZodBranded","Brand","SomeType","output","Record","$ZodAsyncError","Error","$ZodEncodeError","input","infer","$ZodConfig","$ZodErrorMap","globalConfig","config","Partial"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/core.d.cts"],"sourcesContent":["import type * as errors from \"./errors.cjs\";\nimport type * as schemas from \"./schemas.cjs\";\nimport type { Class } from \"./util.cjs\";\ntype ZodTrait = {\n    _zod: {\n        def: any;\n        [k: string]: any;\n    };\n};\nexport interface $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]> {\n    new (def: D): T;\n    init(inst: T, def: D): asserts inst is T;\n}\n/** A special constant with type `never` */\nexport declare const NEVER: never;\nexport declare function $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]>(name: string, initializer: (inst: T, def: D) => void, params?: {\n    Parent?: typeof Class;\n}): $constructor<T, D>;\nexport declare const $brand: unique symbol;\nexport type $brand<T extends string | number | symbol = string | number | symbol> = {\n    [$brand]: {\n        [k in T]: true;\n    };\n};\nexport type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<\"_zod\", Record<\"output\", output<T> & $brand<Brand>>>;\nexport declare class $ZodAsyncError extends Error {\n    constructor();\n}\nexport declare class $ZodEncodeError extends Error {\n    constructor(name: string);\n}\nexport type input<T> = T extends {\n    _zod: {\n        input: any;\n    };\n} ? T[\"_zod\"][\"input\"] : unknown;\nexport type output<T> = T extends {\n    _zod: {\n        output: any;\n    };\n} ? T[\"_zod\"][\"output\"] : unknown;\nexport type { output as infer };\nexport interface $ZodConfig {\n    /** Custom error map. Overrides `config().localeError`. */\n    customError?: errors.$ZodErrorMap | undefined;\n    /** Localized error map. Lowest priority. */\n    localeError?: errors.$ZodErrorMap | undefined;\n    /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */\n    jitless?: boolean | undefined;\n}\nexport declare const globalConfig: $ZodConfig;\nexport declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;\n"],"x_google_ignoreList":[0],"mappings":";;;;KAGKG,QAAAA;EAAAA,IAAAA,EAAAA;IAMYC,GAAAA,EAAAA,GAAAA;IAAuBD,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,GAAAA;EAAcE,CAAAA;CACxCC;AAAID,UADDD,YACCC,CAAAA,UADsBF,QACtBE,EAAAA,IADoCA,CACpCA,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,CAAAA,CAAAA;EACHA,KAAAA,GAAAA,EADDC,CACCD,CAAAA,EADGA,CACHA;EAAQC,IAAAA,CAAAA,IAAAA,EAARD,CAAQC,EAAAA,GAAAA,EAAAA,CAAAA,CAAAA,EAAAA,QAAAA,IAAAA,IAAoBD,CAApBC;;AAIwBH,iBAAvBC,YAAuBD,CAAAA,UAAAA,QAAAA,EAAAA,IAAcE,CAAdF,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,CAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,CAAAA,IAAAA,EAAkEE,CAAlEF,EAAAA,GAAAA,EAA0EG,CAA1EH,EAAAA,GAAAA,IAAAA,EAAAA,MAAkEE,CAAlEF,EAAAA;EAAcE,MAAAA,CAAAA,EAAAA,OACzCH,KADyCG;CAAoDA,CAAAA,EAE7GD,YAF6GC,CAEhGA,CAFgGA,EAE7FC,CAF6FD,CAAAA;AAAQC,cAGpGE,MAHoGF,EAAAA,OAAAA,MAAAA;AACrGJ,KAGRM,MAHQN,CAAAA,UAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,CAAAA,GAAAA;EACHG,CAGZG,MAAAA,CAHYH,EAAAA,QAIHA,CAJMC,GAAAA,IAAAA,EAAhBF;CAAY;AACKI,KAMTC,WAN8B,CAAA,UAMRR,QANQ,EAAA,cAAA,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,GAMoDI,CANpD,GAMwDQ,MANxD,CAAA,MAAA,EAMuEA,MANvE,CAAA,QAAA,EAMwFD,MANxF,CAM+FP,CAN/F,CAAA,GAMoGG,MANpG,CAM2GE,KAN3G,CAAA,CAAA,CAAA;AAM2GA,KAOzIO,KAPyIP,CAAAA,CAAAA,CAAAA,GAO9HL,CAP8HK,SAAAA;EAAPF,IAAAA,EAAAA;IAA7BK,KAAAA,EAAAA,GAAAA;EAAfA,CAAAA;CAAM,GAWpGR,CAXoG,CAAA,MAAA,CAAA,CAAA,OAAA,CAAA,GAAA,OAAA;AAO5FY,KAKAL,MALK,CAAA,CAAAP,CAAAA,GAKOA,CALPA,SAIZ;EACOO,IAAAA,EAAAA;;;IAIRP"}

package/errors.d.ts

@@ -3,7 +3,7 @@ import { $ZodType } from "./schemas.js";
 import { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 
-//#region ../../node_modules/zod/v4/core/errors.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/errors.d.cts
 interface $ZodIssueBase {
   readonly code?: string;
   readonly input?: unknown;
@@ -49,12 +49,21 @@ interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
   readonly keys: string[];
   readonly input?: Record<string, unknown>;
 }
-interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+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;
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
 interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_key";
   readonly origin: "map" | "record";
@@ -117,5 +126,5 @@ type $ZodFormattedError<T, U = string> = {
   _errors: U[];
 } & Flatten<_ZodFormattedError<T, U>>;
 //#endregion
-export { $ZodError, $ZodErrorMap, $ZodFlattenedError, $ZodFormattedError, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidKey, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodRawIssue };
+export { $ZodError, $ZodErrorMap, $ZodFlattenedError, $ZodFormattedError, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidElement, $ZodIssueInvalidKey, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodRawIssue };
 //# sourceMappingURL=errors.d.ts.map