@cossistant/core 0.0.24 → 0.0.26

package/visitor-name.d.ts

@@ -0,0 +1,36 @@
+//#region src/visitor-name.d.ts
+/**
+ * Visitor Name Generator
+ *
+ * Generates consistent, deterministic names for anonymous visitors
+ * based on their visitor ID. The same ID will always produce the same name.
+ *
+ * This module is shared between frontend and backend to ensure consistency.
+ */
+/**
+ * Generate a deterministic visitor name from a seed (typically visitor ID)
+ * The same seed will always produce the same name.
+ *
+ * @param seed - A string to use as seed (typically visitor ID)
+ * @returns A name like "Happy Panda" or "Cosmic Eagle"
+ */
+declare function generateVisitorName(seed: string): string;
+/**
+ * Get a display name for a visitor, with fallbacks:
+ * 1. Contact name (if available)
+ * 2. Email username (if available)
+ * 3. Generated name from visitor ID
+ *
+ * @param visitor - Visitor object with optional contact info and required ID
+ * @returns A display name for the visitor
+ */
+declare function getVisitorNameWithFallback(visitor: {
+  contact?: {
+    name?: string | null;
+    email?: string | null;
+  } | null;
+  id: string;
+}): string;
+//#endregion
+export { generateVisitorName, getVisitorNameWithFallback };
+//# sourceMappingURL=visitor-name.d.ts.map

package/visitor-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor-name.d.ts","names":[],"sources":["../src/visitor-name.ts"],"sourcesContent":[],"mappings":";;AAgQA;AAsBA;;;;;;;;;;;;;iBAtBgB,mBAAA;;;;;;;;;;iBAsBA,0BAAA"}

package/visitor-name.js

@@ -0,0 +1,271 @@
+//#region src/visitor-name.ts
+/**
+* Visitor Name Generator
+*
+* Generates consistent, deterministic names for anonymous visitors
+* based on their visitor ID. The same ID will always produce the same name.
+*
+* This module is shared between frontend and backend to ensure consistency.
+*/
+const ADJECTIVES = [
+	"happy",
+	"sunny",
+	"cosmic",
+	"stellar",
+	"swift",
+	"mighty",
+	"clever",
+	"brave",
+	"gentle",
+	"noble",
+	"quick",
+	"bright",
+	"silver",
+	"golden",
+	"crystal",
+	"mystic",
+	"ancient",
+	"modern",
+	"electric",
+	"magnetic",
+	"dynamic",
+	"static",
+	"flying",
+	"dancing",
+	"singing",
+	"laughing",
+	"smiling",
+	"glowing",
+	"shining",
+	"sparkling",
+	"dazzling",
+	"radiant",
+	"peaceful",
+	"serene",
+	"tranquil",
+	"vibrant",
+	"energetic",
+	"lively",
+	"spirited",
+	"bold",
+	"fearless",
+	"curious",
+	"wise",
+	"witty",
+	"charming",
+	"elegant",
+	"graceful",
+	"agile",
+	"nimble",
+	"speedy",
+	"zippy",
+	"bouncy",
+	"jolly",
+	"merry",
+	"cheerful",
+	"playful",
+	"friendly",
+	"loyal",
+	"honest",
+	"kind",
+	"warm",
+	"cool",
+	"chill",
+	"awesome",
+	"amazing",
+	"wonderful",
+	"fantastic",
+	"magnificent",
+	"marvelous",
+	"splendid",
+	"brilliant",
+	"genius",
+	"super",
+	"mega",
+	"ultra",
+	"hyper",
+	"turbo",
+	"quantum",
+	"nano",
+	"micro",
+	"macro",
+	"epic",
+	"legendary",
+	"mythic",
+	"heroic",
+	"royal",
+	"imperial",
+	"majestic"
+];
+const NOUNS = [
+	"panda",
+	"dolphin",
+	"eagle",
+	"falcon",
+	"hawk",
+	"owl",
+	"raven",
+	"phoenix",
+	"dragon",
+	"unicorn",
+	"griffin",
+	"pegasus",
+	"lion",
+	"tiger",
+	"leopard",
+	"cheetah",
+	"panther",
+	"wolf",
+	"fox",
+	"bear",
+	"koala",
+	"kangaroo",
+	"rabbit",
+	"squirrel",
+	"hedgehog",
+	"otter",
+	"seal",
+	"whale",
+	"shark",
+	"octopus",
+	"jellyfish",
+	"starfish",
+	"butterfly",
+	"dragonfly",
+	"firefly",
+	"bee",
+	"hummingbird",
+	"peacock",
+	"flamingo",
+	"penguin",
+	"mountain",
+	"valley",
+	"river",
+	"ocean",
+	"forest",
+	"desert",
+	"glacier",
+	"volcano",
+	"canyon",
+	"meadow",
+	"prairie",
+	"savanna",
+	"tundra",
+	"rainforest",
+	"waterfall",
+	"geyser",
+	"aurora",
+	"comet",
+	"meteor",
+	"planet",
+	"galaxy",
+	"nebula",
+	"constellation",
+	"star",
+	"moon",
+	"sun",
+	"eclipse",
+	"horizon",
+	"sunrise",
+	"sunset",
+	"rainbow",
+	"thunder",
+	"lightning",
+	"storm",
+	"breeze",
+	"wind",
+	"tornado",
+	"hurricane",
+	"blizzard",
+	"avalanche",
+	"rocket",
+	"satellite",
+	"spaceship",
+	"explorer",
+	"pioneer",
+	"voyager",
+	"wanderer",
+	"nomad",
+	"knight",
+	"samurai",
+	"ninja",
+	"wizard",
+	"sage",
+	"oracle",
+	"prophet",
+	"champion",
+	"guardian",
+	"sentinel",
+	"watcher",
+	"keeper",
+	"protector",
+	"defender",
+	"warrior",
+	"hero",
+	"artist",
+	"painter",
+	"sculptor",
+	"musician",
+	"composer",
+	"poet",
+	"writer",
+	"dreamer",
+	"thinker",
+	"scholar",
+	"scientist",
+	"inventor",
+	"creator",
+	"builder",
+	"architect",
+	"engineer"
+];
+/**
+* Simple hash function to convert string to number
+* Used for deterministic visitor name generation
+*/
+function hashString(str) {
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash &= hash;
+	}
+	return Math.abs(hash);
+}
+/**
+* Capitalize the first letter of a string
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Generate a deterministic visitor name from a seed (typically visitor ID)
+* The same seed will always produce the same name.
+*
+* @param seed - A string to use as seed (typically visitor ID)
+* @returns A name like "Happy Panda" or "Cosmic Eagle"
+*/
+function generateVisitorName(seed) {
+	const hash = hashString(seed);
+	const adjectiveIndex = hash % ADJECTIVES.length;
+	const nounIndex = (hash >> 8) % NOUNS.length;
+	const adjective = ADJECTIVES[adjectiveIndex] ?? "anonymous";
+	const noun = NOUNS[nounIndex] ?? "visitor";
+	return `${capitalize(adjective)} ${capitalize(noun)}`;
+}
+/**
+* Get a display name for a visitor, with fallbacks:
+* 1. Contact name (if available)
+* 2. Email username (if available)
+* 3. Generated name from visitor ID
+*
+* @param visitor - Visitor object with optional contact info and required ID
+* @returns A display name for the visitor
+*/
+function getVisitorNameWithFallback(visitor) {
+	return visitor?.contact?.name || visitor?.contact?.email?.split("@")[0] || generateVisitorName(visitor.id);
+}
+
+//#endregion
+export { generateVisitorName, getVisitorNameWithFallback };
+//# sourceMappingURL=visitor-name.js.map

package/visitor-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor-name.js","names":[],"sources":["../src/visitor-name.ts"],"sourcesContent":["/**\n * Visitor Name Generator\n *\n * Generates consistent, deterministic names for anonymous visitors\n * based on their visitor ID. The same ID will always produce the same name.\n *\n * This module is shared between frontend and backend to ensure consistency.\n */\n\n// Adjectives - descriptors for the visitor name\nconst ADJECTIVES = [\n\t\"happy\",\n\t\"sunny\",\n\t\"cosmic\",\n\t\"stellar\",\n\t\"swift\",\n\t\"mighty\",\n\t\"clever\",\n\t\"brave\",\n\t\"gentle\",\n\t\"noble\",\n\t\"quick\",\n\t\"bright\",\n\t\"silver\",\n\t\"golden\",\n\t\"crystal\",\n\t\"mystic\",\n\t\"ancient\",\n\t\"modern\",\n\t\"electric\",\n\t\"magnetic\",\n\t\"dynamic\",\n\t\"static\",\n\t\"flying\",\n\t\"dancing\",\n\t\"singing\",\n\t\"laughing\",\n\t\"smiling\",\n\t\"glowing\",\n\t\"shining\",\n\t\"sparkling\",\n\t\"dazzling\",\n\t\"radiant\",\n\t\"peaceful\",\n\t\"serene\",\n\t\"tranquil\",\n\t\"vibrant\",\n\t\"energetic\",\n\t\"lively\",\n\t\"spirited\",\n\t\"bold\",\n\t\"fearless\",\n\t\"curious\",\n\t\"wise\",\n\t\"witty\",\n\t\"charming\",\n\t\"elegant\",\n\t\"graceful\",\n\t\"agile\",\n\t\"nimble\",\n\t\"speedy\",\n\t\"zippy\",\n\t\"bouncy\",\n\t\"jolly\",\n\t\"merry\",\n\t\"cheerful\",\n\t\"playful\",\n\t\"friendly\",\n\t\"loyal\",\n\t\"honest\",\n\t\"kind\",\n\t\"warm\",\n\t\"cool\",\n\t\"chill\",\n\t\"awesome\",\n\t\"amazing\",\n\t\"wonderful\",\n\t\"fantastic\",\n\t\"magnificent\",\n\t\"marvelous\",\n\t\"splendid\",\n\t\"brilliant\",\n\t\"genius\",\n\t\"super\",\n\t\"mega\",\n\t\"ultra\",\n\t\"hyper\",\n\t\"turbo\",\n\t\"quantum\",\n\t\"nano\",\n\t\"micro\",\n\t\"macro\",\n\t\"epic\",\n\t\"legendary\",\n\t\"mythic\",\n\t\"heroic\",\n\t\"royal\",\n\t\"imperial\",\n\t\"majestic\",\n] as const;\n\n// Nouns - animals, objects, nature elements\nconst NOUNS = [\n\t// Animals\n\t\"panda\",\n\t\"dolphin\",\n\t\"eagle\",\n\t\"falcon\",\n\t\"hawk\",\n\t\"owl\",\n\t\"raven\",\n\t\"phoenix\",\n\t\"dragon\",\n\t\"unicorn\",\n\t\"griffin\",\n\t\"pegasus\",\n\t\"lion\",\n\t\"tiger\",\n\t\"leopard\",\n\t\"cheetah\",\n\t\"panther\",\n\t\"wolf\",\n\t\"fox\",\n\t\"bear\",\n\t\"koala\",\n\t\"kangaroo\",\n\t\"rabbit\",\n\t\"squirrel\",\n\t\"hedgehog\",\n\t\"otter\",\n\t\"seal\",\n\t\"whale\",\n\t\"shark\",\n\t\"octopus\",\n\t\"jellyfish\",\n\t\"starfish\",\n\t\"butterfly\",\n\t\"dragonfly\",\n\t\"firefly\",\n\t\"bee\",\n\t\"hummingbird\",\n\t\"peacock\",\n\t\"flamingo\",\n\t\"penguin\",\n\t// Nature elements\n\t\"mountain\",\n\t\"valley\",\n\t\"river\",\n\t\"ocean\",\n\t\"forest\",\n\t\"desert\",\n\t\"glacier\",\n\t\"volcano\",\n\t\"canyon\",\n\t\"meadow\",\n\t\"prairie\",\n\t\"savanna\",\n\t\"tundra\",\n\t\"rainforest\",\n\t\"waterfall\",\n\t\"geyser\",\n\t\"aurora\",\n\t\"comet\",\n\t\"meteor\",\n\t\"planet\",\n\t\"galaxy\",\n\t\"nebula\",\n\t\"constellation\",\n\t\"star\",\n\t\"moon\",\n\t\"sun\",\n\t\"eclipse\",\n\t\"horizon\",\n\t\"sunrise\",\n\t\"sunset\",\n\t\"rainbow\",\n\t\"thunder\",\n\t\"lightning\",\n\t\"storm\",\n\t\"breeze\",\n\t\"wind\",\n\t\"tornado\",\n\t\"hurricane\",\n\t\"blizzard\",\n\t\"avalanche\",\n\t// Cool objects and concepts\n\t\"rocket\",\n\t\"satellite\",\n\t\"spaceship\",\n\t\"explorer\",\n\t\"pioneer\",\n\t\"voyager\",\n\t\"wanderer\",\n\t\"nomad\",\n\t\"knight\",\n\t\"samurai\",\n\t\"ninja\",\n\t\"wizard\",\n\t\"sage\",\n\t\"oracle\",\n\t\"prophet\",\n\t\"champion\",\n\t\"guardian\",\n\t\"sentinel\",\n\t\"watcher\",\n\t\"keeper\",\n\t\"protector\",\n\t\"defender\",\n\t\"warrior\",\n\t\"hero\",\n\t\"artist\",\n\t\"painter\",\n\t\"sculptor\",\n\t\"musician\",\n\t\"composer\",\n\t\"poet\",\n\t\"writer\",\n\t\"dreamer\",\n\t\"thinker\",\n\t\"scholar\",\n\t\"scientist\",\n\t\"inventor\",\n\t\"creator\",\n\t\"builder\",\n\t\"architect\",\n\t\"engineer\",\n] as const;\n\n/**\n * Simple hash function to convert string to number\n * Used for deterministic visitor name generation\n */\nfunction hashString(str: string): number {\n\tlet hash = 0;\n\tfor (let i = 0; i < str.length; i++) {\n\t\tconst char = str.charCodeAt(i);\n\t\thash = (hash << 5) - hash + char;\n\t\thash &= hash; // Convert to 32-bit integer\n\t}\n\treturn Math.abs(hash);\n}\n\n/**\n * Capitalize the first letter of a string\n */\nfunction capitalize(str: string): string {\n\treturn str.charAt(0).toUpperCase() + str.slice(1);\n}\n\n/**\n * Generate a deterministic visitor name from a seed (typically visitor ID)\n * The same seed will always produce the same name.\n *\n * @param seed - A string to use as seed (typically visitor ID)\n * @returns A name like \"Happy Panda\" or \"Cosmic Eagle\"\n */\nexport function generateVisitorName(seed: string): string {\n\tconst hash = hashString(seed);\n\n\t// Use different parts of the hash for each word selection\n\tconst adjectiveIndex = hash % ADJECTIVES.length;\n\tconst nounIndex = (hash >> 8) % NOUNS.length;\n\n\tconst adjective = ADJECTIVES[adjectiveIndex] ?? \"anonymous\";\n\tconst noun = NOUNS[nounIndex] ?? \"visitor\";\n\n\treturn `${capitalize(adjective)} ${capitalize(noun)}`;\n}\n\n/**\n * Get a display name for a visitor, with fallbacks:\n * 1. Contact name (if available)\n * 2. Email username (if available)\n * 3. Generated name from visitor ID\n *\n * @param visitor - Visitor object with optional contact info and required ID\n * @returns A display name for the visitor\n */\nexport function getVisitorNameWithFallback(visitor: {\n\tcontact?: {\n\t\tname?: string | null;\n\t\temail?: string | null;\n\t} | null;\n\tid: string;\n}): string {\n\treturn (\n\t\tvisitor?.contact?.name ||\n\t\tvisitor?.contact?.email?.split(\"@\")[0] ||\n\t\tgenerateVisitorName(visitor.id)\n\t);\n}\n"],"mappings":";;;;;;;;;AAUA,MAAM,aAAa;CAClB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAGD,MAAM,QAAQ;CAEb;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;AAMD,SAAS,WAAW,KAAqB;CACxC,IAAI,OAAO;AACX,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACpC,MAAM,OAAO,IAAI,WAAW,EAAE;AAC9B,UAAQ,QAAQ,KAAK,OAAO;AAC5B,UAAQ;;AAET,QAAO,KAAK,IAAI,KAAK;;;;;AAMtB,SAAS,WAAW,KAAqB;AACxC,QAAO,IAAI,OAAO,EAAE,CAAC,aAAa,GAAG,IAAI,MAAM,EAAE;;;;;;;;;AAUlD,SAAgB,oBAAoB,MAAsB;CACzD,MAAM,OAAO,WAAW,KAAK;CAG7B,MAAM,iBAAiB,OAAO,WAAW;CACzC,MAAM,aAAa,QAAQ,KAAK,MAAM;CAEtC,MAAM,YAAY,WAAW,mBAAmB;CAChD,MAAM,OAAO,MAAM,cAAc;AAEjC,QAAO,GAAG,WAAW,UAAU,CAAC,GAAG,WAAW,KAAK;;;;;;;;;;;AAYpD,SAAgB,2BAA2B,SAMhC;AACV,QACC,SAAS,SAAS,QAClB,SAAS,SAAS,OAAO,MAAM,IAAI,CAAC,MACpC,oBAAoB,QAAQ,GAAG"}

package/api.d.ts

@@ -1,71 +0,0 @@
-import { EmptyToNever, Flatten, MakePartial } from "./util.js";
-import { $ZodBase64, $ZodBase64URL, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2, $ZodCustom, $ZodE164, $ZodEmail, $ZodEmoji, $ZodEnum, $ZodGUID, $ZodIPv4, $ZodIPv6, $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime, $ZodJWT, $ZodKSUID, $ZodNanoID, $ZodNonOptional, $ZodStringFormat, $ZodType, $ZodULID, $ZodURL, $ZodUUID, $ZodXID, ParsePayload } from "./schemas.js";
-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/.bun/zod@4.1.12/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. */
-  message?: string | undefined;
-})>>>;
-type TypeParams<T extends $ZodType = $ZodType & {
-  _isst: never;
-}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
-type CheckParams<T extends $ZodCheck = $ZodCheck,
-// & { _issc: never },
-AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
-type CheckStringFormatParams<T extends $ZodStringFormat = $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>;
-type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $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>;
-type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
-type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
-type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
-type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
-type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
-type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when">;
-type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
-type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
-type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
-type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
-type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
-type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
-type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
-type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
-type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
-type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
-type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
-type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
-type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
-type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
-type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
-type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
-type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
-type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
-type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
-type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
-type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
-type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
-type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
-type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
-type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
-type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
-type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
-type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
-type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
-type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
-type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
-type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
-type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
-type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
-  /** The schema or check that originated this issue. */
-  readonly inst?: $ZodType | $ZodCheck;
-  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
-  readonly continue?: boolean | undefined;
-} & Record<string, unknown>> : never;
-interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
-  addIssue(arg: string | $ZodSuperRefineIssue): void;
-}
-//#endregion
-export { $RefinementCtx, $ZodCheckBase64Params, $ZodCheckBase64URLParams, $ZodCheckCIDRv4Params, $ZodCheckCIDRv6Params, $ZodCheckCUID2Params, $ZodCheckCUIDParams, $ZodCheckE164Params, $ZodCheckEmailParams, $ZodCheckEmojiParams, $ZodCheckEndsWithParams, $ZodCheckGUIDParams, $ZodCheckGreaterThanParams, $ZodCheckIPv4Params, $ZodCheckIPv6Params, $ZodCheckISODateParams, $ZodCheckISODateTimeParams, $ZodCheckISODurationParams, $ZodCheckISOTimeParams, $ZodCheckIncludesParams, $ZodCheckJWTParams, $ZodCheckKSUIDParams, $ZodCheckLengthEqualsParams, $ZodCheckLessThanParams, $ZodCheckLowerCaseParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCheckMultipleOfParams, $ZodCheckNanoIDParams, $ZodCheckNumberFormatParams, $ZodCheckRegexParams, $ZodCheckStartsWithParams, $ZodCheckULIDParams, $ZodCheckURLParams, $ZodCheckUUIDParams, $ZodCheckUpperCaseParams, $ZodCheckXIDParams, $ZodCustomParams, $ZodEnumParams, $ZodNonOptionalParams };
-//# sourceMappingURL=api.d.ts.map

package/api.d.ts.map

@@ -1 +0,0 @@
-{"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/.bun/zod@4.1.12/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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"}