@suveren/gateway 0.39.0 → 0.41.0

package/node_modules/zod/src/v4/core/api.ts

@@ -1,6 +1,7 @@
 import * as checks from "./checks.js";
 import type * as core from "./core.js";
 import type * as errors from "./errors.js";
+import * as registries from "./registries.js";
 import * as schemas from "./schemas.js";
 import * as util from "./util.js";
 
@@ -57,35 +58,41 @@ export type CheckTypeParams<
 > = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
 
 // String
-export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
+export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce"> & {
+  checks?: readonly checks.$ZodCheck<string>[];
+};
+
+function snapshotChecks<T extends { checks?: readonly checks.$ZodCheck<never>[] }>(def: T) {
+  if (def.checks) def.checks = [...def.checks];
+  return def as T & { checks?: NonNullable<T["checks"]>[number][] };
+}
+// @__NO_SIDE_EFFECTS__
 export function _string<T extends schemas.$ZodString>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodStringParams
 ): T {
-  return new Class({
-    type: "string",
-    ...util.normalizeParams(params),
-  });
+  return new Class(snapshotChecks({ type: "string" as const, ...util.normalizeParams(params) }));
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _coercedString<T extends schemas.$ZodString>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodStringParams
 ): T {
-  return new Class({
-    type: "string",
-    coerce: true,
-    ...util.normalizeParams(params),
-  });
+  return new Class(snapshotChecks({ type: "string" as const, coerce: true, ...util.normalizeParams(params) }));
 }
 
-export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce">;
+export type $ZodStringFormatParams = CheckTypeParams<
+  schemas.$ZodStringFormat,
+  "format" | "coerce" | "when" | "pattern"
+>;
 export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
 // custom format
 
 // Email
-export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail>;
-export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail>;
+export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
+export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _email<T extends schemas.$ZodEmail>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodEmailParams | $ZodCheckEmailParams
@@ -100,8 +107,9 @@ export function _email<T extends schemas.$ZodEmail>(
 }
 
 // GUID
-export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern">;
-export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern">;
+export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
+export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _guid<T extends schemas.$ZodGUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodGUIDParams | $ZodCheckGUIDParams
@@ -116,8 +124,9 @@ export function _guid<T extends schemas.$ZodGUID>(
 }
 
 // UUID
-export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern">;
-export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _uuid<T extends schemas.$ZodUUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodUUIDParams | $ZodCheckUUIDParams
@@ -132,8 +141,9 @@ export function _uuid<T extends schemas.$ZodUUID>(
 }
 
 // UUIDv4
-export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
-export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _uuidv4<T extends schemas.$ZodUUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params
@@ -149,8 +159,9 @@ export function _uuidv4<T extends schemas.$ZodUUID>(
 }
 
 // UUIDv6
-export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
-export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _uuidv6<T extends schemas.$ZodUUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params
@@ -166,8 +177,9 @@ export function _uuidv6<T extends schemas.$ZodUUID>(
 }
 
 // UUIDv7
-export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
-export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _uuidv7<T extends schemas.$ZodUUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params
@@ -183,8 +195,9 @@ export function _uuidv7<T extends schemas.$ZodUUID>(
 }
 
 // URL
-export type $ZodURLParams = StringFormatParams<schemas.$ZodURL>;
-export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL>;
+export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
+export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _url<T extends schemas.$ZodURL>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodURLParams | $ZodCheckURLParams
@@ -199,8 +212,9 @@ export function _url<T extends schemas.$ZodURL>(
 }
 
 // Emoji
-export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji>;
-export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji>;
+export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
+export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _emoji<T extends schemas.$ZodEmoji>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodEmojiParams | $ZodCheckEmojiParams
@@ -215,8 +229,9 @@ export function _emoji<T extends schemas.$ZodEmoji>(
 }
 
 // NanoID
-export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID>;
-export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID>;
+export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
+export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
+// @__NO_SIDE_EFFECTS__
 export function _nanoid<T extends schemas.$ZodNanoID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams
@@ -231,8 +246,24 @@ export function _nanoid<T extends schemas.$ZodNanoID>(
 }
 
 // CUID
-export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID>;
-export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID>;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+// @__NO_SIDE_EFFECTS__
 export function _cuid<T extends schemas.$ZodCUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCUIDParams | $ZodCheckCUIDParams
@@ -247,8 +278,9 @@ export function _cuid<T extends schemas.$ZodCUID>(
 }
 
 // CUID2
-export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2>;
-export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2>;
+export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
+export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _cuid2<T extends schemas.$ZodCUID2>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCUID2Params | $ZodCheckCUID2Params
@@ -263,8 +295,9 @@ export function _cuid2<T extends schemas.$ZodCUID2>(
 }
 
 // ULID
-export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID>;
-export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID>;
+export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
+export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _ulid<T extends schemas.$ZodULID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodULIDParams | $ZodCheckULIDParams
@@ -279,8 +312,9 @@ export function _ulid<T extends schemas.$ZodULID>(
 }
 
 // XID
-export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID>;
-export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID>;
+export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
+export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _xid<T extends schemas.$ZodXID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodXIDParams | $ZodCheckXIDParams
@@ -295,8 +329,9 @@ export function _xid<T extends schemas.$ZodXID>(
 }
 
 // KSUID
-export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID>;
-export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID>;
+export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
+export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _ksuid<T extends schemas.$ZodKSUID>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams
@@ -310,25 +345,10 @@ export function _ksuid<T extends schemas.$ZodKSUID>(
   });
 }
 
-// IP
-// export type $ZodIPParams = StringFormatParams<schemas.$ZodIP, "pattern">;
-// export type $ZodCheckIPParams = CheckStringFormatParams<schemas.$ZodIP, "pattern">;
-// export function _ip<T extends schemas.$ZodIP>(
-//   Class: util.SchemaClass<T>,
-//   params?: string | $ZodIPParams | $ZodCheckIPParams
-// ): T {
-//   return new Class({
-//     type: "string",
-//     format: "ip",
-//     check: "string_format",
-//     abort: false,
-//     ...util.normalizeParams(params),
-//   });
-// }
-
 // IPv4
-export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern">;
-export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern">;
+export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
+export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
+// @__NO_SIDE_EFFECTS__
 export function _ipv4<T extends schemas.$ZodIPv4>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodIPv4Params | $ZodCheckIPv4Params
@@ -343,8 +363,9 @@ export function _ipv4<T extends schemas.$ZodIPv4>(
 }
 
 // IPv6
-export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern">;
-export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern">;
+export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
+export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
+// @__NO_SIDE_EFFECTS__
 export function _ipv6<T extends schemas.$ZodIPv6>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodIPv6Params | $ZodCheckIPv6Params
@@ -358,9 +379,27 @@ export function _ipv6<T extends schemas.$ZodIPv6>(
   });
 }
 
+// MAC
+export type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
+export type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _mac<T extends schemas.$ZodMAC>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodMACParams | $ZodCheckMACParams
+): T {
+  return new Class({
+    type: "string",
+    format: "mac",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
 // CIDRv4
-export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern">;
-export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern">;
+export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
+export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _cidrv4<T extends schemas.$ZodCIDRv4>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params
@@ -375,8 +414,9 @@ export function _cidrv4<T extends schemas.$ZodCIDRv4>(
 }
 
 // CIDRv6
-export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern">;
-export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern">;
+export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
+export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _cidrv6<T extends schemas.$ZodCIDRv6>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params
@@ -391,8 +431,9 @@ export function _cidrv6<T extends schemas.$ZodCIDRv6>(
 }
 
 // Base64
-export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern">;
-export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern">;
+export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
+export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _base64<T extends schemas.$ZodBase64>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBase64Params | $ZodCheckBase64Params
@@ -407,8 +448,9 @@ export function _base64<T extends schemas.$ZodBase64>(
 }
 
 // base64url
-export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern">;
-export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern">;
+export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
+export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _base64url<T extends schemas.$ZodBase64URL>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams
@@ -423,8 +465,9 @@ export function _base64url<T extends schemas.$ZodBase64URL>(
 }
 
 // E164
-export type $ZodE164Params = StringFormatParams<schemas.$ZodE164>;
-export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164>;
+export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
+export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _e164<T extends schemas.$ZodE164>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodE164Params | $ZodCheckE164Params
@@ -438,9 +481,44 @@ export function _e164<T extends schemas.$ZodE164>(
   });
 }
 
+// CreditCard
+export type $ZodCreditCardParams = StringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
+export type $ZodCheckCreditCardParams = CheckStringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _creditCard<T extends schemas.$ZodCreditCard>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams
+): T {
+  return new Class({
+    type: "string",
+    format: "credit_card",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
+// IBAN
+export type $ZodIBANParams = StringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
+export type $ZodCheckIBANParams = CheckStringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _iban<T extends schemas.$ZodIBAN>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodIBANParams | $ZodCheckIBANParams
+): T {
+  return new Class({
+    type: "string",
+    format: "iban",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
 // JWT
-export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern">;
-export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern">;
+export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
+export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _jwt<T extends schemas.$ZodJWT>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodJWTParams | $ZodCheckJWTParams
@@ -462,8 +540,9 @@ export const TimePrecision = {
   Microsecond: 6,
 } as const;
 // ISODateTime
-export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern">;
-export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern">;
+export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
+export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _isoDateTime<T extends schemas.$ZodISODateTime>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams
@@ -480,8 +559,9 @@ export function _isoDateTime<T extends schemas.$ZodISODateTime>(
 }
 
 // ISODate
-export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern">;
-export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern">;
+export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
+export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _isoDate<T extends schemas.$ZodISODate>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodISODateParams | $ZodCheckISODateParams
@@ -495,8 +575,9 @@ export function _isoDate<T extends schemas.$ZodISODate>(
 }
 
 // ISOTime
-export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern">;
-export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern">;
+export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
+export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _isoTime<T extends schemas.$ZodISOTime>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams
@@ -511,8 +592,9 @@ export function _isoTime<T extends schemas.$ZodISOTime>(
 }
 
 // ISODuration
-export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration>;
-export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration>;
+export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
+export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
+// @__NO_SIDE_EFFECTS__
 export function _isoDuration<T extends schemas.$ZodISODuration>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodISODurationParams | $ZodCheckISODurationParams
@@ -526,32 +608,30 @@ export function _isoDuration<T extends schemas.$ZodISODuration>(
 }
 
 // Number
-export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
+export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce"> & {
+  checks?: readonly checks.$ZodCheck<number>[];
+};
 export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
-export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format">;
+export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _number<T extends schemas.$ZodNumber>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodNumberParams
 ): T {
-  return new Class({
-    type: "number",
-    checks: [],
-    ...util.normalizeParams(params),
-  });
+  return new Class(snapshotChecks({ type: "number" as const, checks: [], ...util.normalizeParams(params) }));
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _coercedNumber<T extends schemas.$ZodNumber>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodNumberParams
 ): T {
-  return new Class({
-    type: "number",
-    coerce: true,
-    checks: [],
-    ...util.normalizeParams(params),
-  });
+  return new Class(
+    snapshotChecks({ type: "number" as const, coerce: true, checks: [], ...util.normalizeParams(params) })
+  );
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _int<T extends schemas.$ZodNumberFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCheckNumberFormatParams
@@ -564,6 +644,7 @@ export function _int<T extends schemas.$ZodNumberFormat>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _float32<T extends schemas.$ZodNumberFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCheckNumberFormatParams
@@ -576,6 +657,7 @@ export function _float32<T extends schemas.$ZodNumberFormat>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _float64<T extends schemas.$ZodNumberFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCheckNumberFormatParams
@@ -588,6 +670,7 @@ export function _float64<T extends schemas.$ZodNumberFormat>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _int32<T extends schemas.$ZodNumberFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCheckNumberFormatParams
@@ -600,6 +683,7 @@ export function _int32<T extends schemas.$ZodNumberFormat>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _uint32<T extends schemas.$ZodNumberFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodCheckNumberFormatParams
@@ -615,6 +699,7 @@ export function _uint32<T extends schemas.$ZodNumberFormat>(
 
 // Boolean
 export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
+// @__NO_SIDE_EFFECTS__
 export function _boolean<T extends schemas.$ZodBoolean>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBooleanParams
@@ -624,6 +709,7 @@ export function _boolean<T extends schemas.$ZodBoolean>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _coercedBoolean<T extends schemas.$ZodBoolean>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBooleanParams
@@ -638,7 +724,8 @@ export function _coercedBoolean<T extends schemas.$ZodBoolean>(
 // BigInt
 export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
 export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
-export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format">;
+export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _bigint<T extends schemas.$ZodBigInt>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBigIntParams
@@ -648,6 +735,7 @@ export function _bigint<T extends schemas.$ZodBigInt>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _coercedBigint<T extends schemas.$ZodBigInt>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBigIntParams
@@ -659,6 +747,7 @@ export function _coercedBigint<T extends schemas.$ZodBigInt>(
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _int64<T extends schemas.$ZodBigIntFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBigIntFormatParams
@@ -671,6 +760,7 @@ export function _int64<T extends schemas.$ZodBigIntFormat>(
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _uint64<T extends schemas.$ZodBigIntFormat>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodBigIntFormatParams
@@ -686,6 +776,7 @@ export function _uint64<T extends schemas.$ZodBigIntFormat>(
 
 // Symbol
 export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
+// @__NO_SIDE_EFFECTS__
 export function _symbol<T extends schemas.$ZodSymbol>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodSymbolParams
@@ -698,6 +789,7 @@ export function _symbol<T extends schemas.$ZodSymbol>(
 
 // Undefined
 export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
+// @__NO_SIDE_EFFECTS__
 export function _undefined<T extends schemas.$ZodUndefined>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodUndefinedParams
@@ -710,6 +802,7 @@ export function _undefined<T extends schemas.$ZodUndefined>(
 
 // Null
 export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
+// @__NO_SIDE_EFFECTS__
 export function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T {
   return new Class({
     type: "null",
@@ -719,6 +812,7 @@ export function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, pa
 
 // Any
 export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
+// @__NO_SIDE_EFFECTS__
 export function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T {
   return new Class({
     type: "any",
@@ -727,6 +821,7 @@ export function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T {
 
 // Unknown
 export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
+// @__NO_SIDE_EFFECTS__
 export function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T {
   return new Class({
     type: "unknown",
@@ -735,6 +830,7 @@ export function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<
 
 // Never
 export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
+// @__NO_SIDE_EFFECTS__
 export function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T {
   return new Class({
     type: "never",
@@ -744,6 +840,7 @@ export function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>,
 
 // Void
 export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
+// @__NO_SIDE_EFFECTS__
 export function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T {
   return new Class({
     type: "void",
@@ -753,12 +850,14 @@ export function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, pa
 
 // Date
 export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
+// @__NO_SIDE_EFFECTS__
 export function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T {
   return new Class({
     type: "date",
     ...util.normalizeParams(params),
   });
 }
+// @__NO_SIDE_EFFECTS__
 export function _coercedDate<T extends schemas.$ZodDate>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodDateParams
@@ -772,6 +871,7 @@ export function _coercedDate<T extends schemas.$ZodDate>(
 
 // NaN
 export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
+// @__NO_SIDE_EFFECTS__
 export function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T {
   return new Class({
     type: "nan",
@@ -779,9 +879,10 @@ export function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, para
   });
 }
 
-// export type $ZodCheckParams = CheckParams<checks.$ZodCheck, "abort">;
+// export type $ZodCheckParams = CheckParams<checks.$ZodCheck, "abort" | "when">;
 
-export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value">;
+export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _lt(
   value: util.Numeric,
   params?: string | $ZodCheckLessThanParams
@@ -794,6 +895,7 @@ export function _lt(
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _lte(
   value: util.Numeric,
   params?: string | $ZodCheckLessThanParams
@@ -812,7 +914,8 @@ export {
 };
 
 // ZodCheckGreaterThan
-export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value">;
+export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
   return new checks.$ZodCheckGreaterThan({
     check: "greater_than",
@@ -823,6 +926,7 @@ export function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanP
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
   return new checks.$ZodCheckGreaterThan({
     check: "greater_than",
@@ -837,26 +941,31 @@ export {
   _gte as _min,
 };
 
+// @__NO_SIDE_EFFECTS__
 export function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
   return _gt(0, params);
 }
 
 // negative
+// @__NO_SIDE_EFFECTS__
 export function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan {
   return _lt(0, params);
 }
 
 // nonpositive
+// @__NO_SIDE_EFFECTS__
 export function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan {
   return _lte(0, params);
 }
 
 // nonnegative
+// @__NO_SIDE_EFFECTS__
 export function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan {
   return _gte(0, params);
 }
 
-export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value">;
+export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _multipleOf(
   value: number | bigint,
   params?: string | $ZodCheckMultipleOfParams
@@ -868,7 +977,8 @@ export function _multipleOf(
   });
 }
 
-export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum">;
+export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _maxSize(
   maximum: number,
   params?: string | $ZodCheckMaxSizeParams
@@ -880,7 +990,8 @@ export function _maxSize(
   });
 }
 
-export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum">;
+export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _minSize(
   minimum: number,
   params?: string | $ZodCheckMinSizeParams
@@ -892,7 +1003,8 @@ export function _minSize(
   });
 }
 
-export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size">;
+export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _size(
   size: number,
   params?: string | $ZodCheckSizeEqualsParams
@@ -904,7 +1016,8 @@ export function _size(
   });
 }
 
-export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum">;
+export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _maxLength(
   maximum: number,
   params?: string | $ZodCheckMaxLengthParams
@@ -917,7 +1030,8 @@ export function _maxLength(
   return ch;
 }
 
-export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum">;
+export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _minLength(
   minimum: number,
   params?: string | $ZodCheckMinLengthParams
@@ -929,7 +1043,8 @@ export function _minLength(
   });
 }
 
-export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length">;
+export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _length(
   length: number,
   params?: string | $ZodCheckLengthEqualsParams
@@ -941,7 +1056,8 @@ export function _length(
   });
 }
 
-export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern">;
+export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex {
   return new checks.$ZodCheckRegex({
     check: "string_format",
@@ -951,7 +1067,8 @@ export function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams):
   });
 }
 
-export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format">;
+export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase {
   return new checks.$ZodCheckLowerCase({
     check: "string_format",
@@ -960,8 +1077,9 @@ export function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$
   });
 }
 
-export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format">;
+export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
 
+// @__NO_SIDE_EFFECTS__
 export function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase {
   return new checks.$ZodCheckUpperCase({
     check: "string_format",
@@ -970,7 +1088,8 @@ export function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$
   });
 }
 
-export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "pattern">;
+export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+// @__NO_SIDE_EFFECTS__
 export function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes {
   return new checks.$ZodCheckIncludes({
     check: "string_format",
@@ -979,7 +1098,11 @@ export function _includes(includes: string, params?: string | $ZodCheckIncludesP
     includes,
   });
 }
-export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
+export type $ZodCheckStartsWithParams = CheckParams<
+  checks.$ZodCheckStartsWith,
+  "prefix" | "format" | "when" | "pattern"
+>;
+// @__NO_SIDE_EFFECTS__
 export function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith {
   return new checks.$ZodCheckStartsWith({
     check: "string_format",
@@ -989,8 +1112,9 @@ export function _startsWith(prefix: string, params?: string | $ZodCheckStartsWit
   });
 }
 
-export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
+export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
 
+// @__NO_SIDE_EFFECTS__
 export function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith {
   return new checks.$ZodCheckEndsWith({
     check: "string_format",
@@ -1000,12 +1124,13 @@ export function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithPar
   });
 }
 
-export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema">;
+export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _property<K extends string, T extends schemas.$ZodType>(
   property: K,
   schema: T,
   params?: string | $ZodCheckPropertyParams
-): checks.$ZodCheckProperty<{ [k in K]: core.output<T> }> {
+): checks.$ZodCheckProperty<{ [k in K]: util.Widen<core.input<T>> }> {
   return new checks.$ZodCheckProperty({
     check: "property",
     property,
@@ -1014,7 +1139,21 @@ export function _property<K extends string, T extends schemas.$ZodType>(
   });
 }
 
-export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime">;
+export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _properties<Shape extends schemas.$ZodShape>(
+  shape: Shape,
+  params?: string | $ZodCheckPropertiesParams
+): checks.$ZodCheckProperties<Shape> {
+  return new checks.$ZodCheckProperties({
+    check: "properties",
+    shape,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
+export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
+// @__NO_SIDE_EFFECTS__
 export function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType {
   return new checks.$ZodCheckMimeType({
     check: "mime_type",
@@ -1023,6 +1162,7 @@ export function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTy
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T> {
   return new checks.$ZodCheckOverwrite({
     check: "overwrite",
@@ -1030,27 +1170,37 @@ export function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>
   }) as checks.$ZodCheckOverwrite<T>;
 }
 // normalize
+// @__NO_SIDE_EFFECTS__
 export function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string> {
   return _overwrite((input) => input.normalize(form));
 }
 
 // trim
+// @__NO_SIDE_EFFECTS__
 export function _trim(): checks.$ZodCheckOverwrite<string> {
   return _overwrite((input) => input.trim());
 }
 // toLowerCase
+// @__NO_SIDE_EFFECTS__
 export function _toLowerCase(): checks.$ZodCheckOverwrite<string> {
   return _overwrite((input) => input.toLowerCase());
 }
 // toUpperCase
+// @__NO_SIDE_EFFECTS__
 export function _toUpperCase(): checks.$ZodCheckOverwrite<string> {
   return _overwrite((input) => input.toUpperCase());
 }
+// slugify
+// @__NO_SIDE_EFFECTS__
+export function _slugify(): checks.$ZodCheckOverwrite<string> {
+  return _overwrite((input) => util.slugify(input));
+}
 
 ///////  collections   ///////
 
 // Array
 export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
+// @__NO_SIDE_EFFECTS__
 export function _array<T extends schemas.$ZodType>(
   Class: util.SchemaClass<schemas.$ZodArray>,
   element: T,
@@ -1070,6 +1220,7 @@ export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchal
 
 // ZodUnion
 export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
+// @__NO_SIDE_EFFECTS__
 export function _union<const T extends readonly schemas.$ZodObject[]>(
   Class: util.SchemaClass<schemas.$ZodUnion>,
   options: T,
@@ -1082,24 +1233,52 @@ export function _union<const T extends readonly schemas.$ZodObject[]>(
   }) as any;
 }
 
+// ZodXor
+export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
+export function _xor<const T extends readonly schemas.$ZodObject[]>(
+  Class: util.SchemaClass<schemas.$ZodXor>,
+  options: T,
+  params?: string | $ZodXorParams
+): schemas.$ZodXor<T> {
+  return new Class({
+    type: "union",
+    options,
+    inclusive: false,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
 // ZodDiscriminatedUnion
-export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
+
+// The bound stops at `propValues`; it deliberately does not check that the option carries the discriminator. Any such check has to name the option's `input`, and constraining `input` in argument position forces TypeScript to resolve it while checking the call — circular for an option whose input references the union, which collapses the whole union to `any`. `$ZodDiscriminatedUnion` validates the discriminator lazily instead, when it builds its lookup map.
+//
+// Validating eagerly through `propValues` is not available: reading it runs the option's shape getters, and for a recursive option that getter references the union whose initializer is still running, so it throws `ReferenceError: Cannot access '...' before initialization`.
+//
+// `Object.keys` on the shape is recursion-safe by contrast — it lists the keys without invoking them — so an eager check is reachable. It was tried and reverted: a key list derived from the shape cannot be kept in agreement with `shape` itself, which resolves lazily over the object the caller passed and then freezes to a copy, and it charged every object schema construction time and memory for a check only this one type reads.
+//
+// `_Disc` is unused and retained only so `$ZodTypeDiscriminable<"kind">` keeps compiling for external callers.
+export interface $ZodTypeDiscriminableInternals<_Disc extends string = string> extends schemas._$ZodTypeInternals {
   propValues: util.PropValues;
 }
 
-export interface $ZodTypeDiscriminable extends schemas.$ZodType {
+export interface $ZodTypeDiscriminable<_Disc extends string = string> extends schemas.SomeType {
   _zod: $ZodTypeDiscriminableInternals;
 }
+
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
-export function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]]>(
+// @__NO_SIDE_EFFECTS__
+export function _discriminatedUnion<
+  Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]],
+  Disc extends string,
+>(
   Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>,
-  discriminator: string,
+  discriminator: Disc,
   options: Types,
   params?: string | $ZodDiscriminatedUnionParams
-): schemas.$ZodDiscriminatedUnion<Types> {
+): schemas.$ZodDiscriminatedUnion<Types, Disc> {
   return new Class({
     type: "union",
-    options,
+    options: options as any as schemas.$ZodType[],
     discriminator,
     ...util.normalizeParams(params),
   }) as any;
@@ -1107,6 +1286,7 @@ export function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$Zo
 
 // ZodIntersection
 export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
+// @__NO_SIDE_EFFECTS__
 export function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodIntersection>,
   left: T,
@@ -1121,11 +1301,13 @@ export function _intersection<T extends schemas.$ZodObject, U extends schemas.$Z
 
 // ZodTuple
 export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
+// @__NO_SIDE_EFFECTS__
 export function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(
   Class: util.SchemaClass<schemas.$ZodTuple>,
   items: T,
   params?: string | $ZodTupleParams
 ): schemas.$ZodTuple<T, null>;
+// @__NO_SIDE_EFFECTS__
 export function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(
   Class: util.SchemaClass<schemas.$ZodTuple>,
   items: T,
@@ -1137,6 +1319,7 @@ export function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType
 //   items: [],
 //   params?: string | $ZodTupleParams
 // ): schemas.$ZodTuple<[], null>;
+// @__NO_SIDE_EFFECTS__
 export function _tuple(
   Class: util.SchemaClass<schemas.$ZodTuple>,
   items: schemas.$ZodType[],
@@ -1155,7 +1338,8 @@ export function _tuple(
 }
 
 // ZodRecord
-export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
+export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType" | "partial">;
+// @__NO_SIDE_EFFECTS__
 export function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodRecord>,
   keyType: Key,
@@ -1172,6 +1356,7 @@ export function _record<Key extends schemas.$ZodRecordKey, Value extends schemas
 
 // ZodMap
 export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
+// @__NO_SIDE_EFFECTS__
 export function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodMap>,
   keyType: Key,
@@ -1188,6 +1373,7 @@ export function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodO
 
 // ZodSet
 export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
+// @__NO_SIDE_EFFECTS__
 export function _set<Value extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodSet>,
   valueType: Value,
@@ -1202,16 +1388,19 @@ export function _set<Value extends schemas.$ZodObject>(
 
 // ZodEnum
 export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
+// @__NO_SIDE_EFFECTS__
 export function _enum<const T extends string[]>(
   Class: util.SchemaClass<schemas.$ZodEnum>,
   values: T,
   params?: string | $ZodEnumParams
 ): schemas.$ZodEnum<util.ToEnum<T[number]>>;
+// @__NO_SIDE_EFFECTS__
 export function _enum<T extends util.EnumLike>(
   Class: util.SchemaClass<schemas.$ZodEnum>,
   entries: T,
   params?: string | $ZodEnumParams
 ): schemas.$ZodEnum<T>;
+// @__NO_SIDE_EFFECTS__
 export function _enum(Class: util.SchemaClass<schemas.$ZodEnum>, values: any, params?: string | $ZodEnumParams) {
   const entries: any = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
   // if (Array.isArray(values)) {
@@ -1233,6 +1422,7 @@ export function _enum(Class: util.SchemaClass<schemas.$ZodEnum>, values: any, pa
   }) as any;
 }
 
+// @__NO_SIDE_EFFECTS__
 /** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
  *
  * ```ts
@@ -1264,6 +1454,7 @@ export function _literal<const T extends util.Literal>(
   value: T,
   params?: string | $ZodLiteralParams
 ): schemas.$ZodLiteral<T>;
+// @__NO_SIDE_EFFECTS__
 export function _literal(Class: util.SchemaClass<schemas.$ZodLiteral>, value: any, params: any) {
   return new Class({
     type: "literal",
@@ -1274,6 +1465,7 @@ export function _literal(Class: util.SchemaClass<schemas.$ZodLiteral>, value: an
 
 // ZodFile
 export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
+// @__NO_SIDE_EFFECTS__
 export function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile {
   return new Class({
     type: "file",
@@ -1283,6 +1475,7 @@ export function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string
 
 // ZodTransform
 export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
+// @__NO_SIDE_EFFECTS__
 export function _transform<I = unknown, O = I>(
   Class: util.SchemaClass<schemas.$ZodTransform>,
   fn: (input: I, ctx?: schemas.ParsePayload) => O
@@ -1295,6 +1488,7 @@ export function _transform<I = unknown, O = I>(
 
 // ZodOptional
 export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
+// @__NO_SIDE_EFFECTS__
 export function _optional<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodOptional>,
   innerType: T
@@ -1307,6 +1501,7 @@ export function _optional<T extends schemas.$ZodObject>(
 
 // ZodNullable
 export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
+// @__NO_SIDE_EFFECTS__
 export function _nullable<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodNullable>,
   innerType: T
@@ -1319,6 +1514,7 @@ export function _nullable<T extends schemas.$ZodObject>(
 
 // ZodDefault
 export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
+// @__NO_SIDE_EFFECTS__
 export function _default<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodDefault>,
   innerType: T,
@@ -1328,13 +1524,14 @@ export function _default<T extends schemas.$ZodObject>(
     type: "default",
     innerType,
     get defaultValue() {
-      return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue;
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : util.shallowClone(defaultValue);
     },
   }) as any;
 }
 
 // ZodNonOptional
 export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
+// @__NO_SIDE_EFFECTS__
 export function _nonoptional<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodNonOptional>,
   innerType: T,
@@ -1349,6 +1546,7 @@ export function _nonoptional<T extends schemas.$ZodObject>(
 
 // ZodSuccess
 export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
+// @__NO_SIDE_EFFECTS__
 export function _success<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodSuccess>,
   innerType: T
@@ -1361,6 +1559,7 @@ export function _success<T extends schemas.$ZodObject>(
 
 // ZodCatch
 export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
+// @__NO_SIDE_EFFECTS__
 export function _catch<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodCatch>,
   innerType: T,
@@ -1369,12 +1568,13 @@ export function _catch<T extends schemas.$ZodObject>(
   return new Class({
     type: "catch",
     innerType,
-    catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as any,
+    catchValue: (typeof catchValue === "function" ? catchValue : util.constantCatch(catchValue)) as any,
   }) as any;
 }
 
 // ZodPipe
 export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
+// @__NO_SIDE_EFFECTS__
 export function _pipe<
   const A extends schemas.$ZodType,
   B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>,
@@ -1392,6 +1592,7 @@ export function _pipe<
 
 // ZodReadonly
 export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
+// @__NO_SIDE_EFFECTS__
 export function _readonly<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodReadonly>,
   innerType: T
@@ -1404,6 +1605,7 @@ export function _readonly<T extends schemas.$ZodObject>(
 
 // ZodTemplateLiteral
 export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
+// @__NO_SIDE_EFFECTS__
 export function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(
   Class: util.SchemaClass<schemas.$ZodTemplateLiteral>,
   parts: Parts,
@@ -1418,6 +1620,7 @@ export function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteral
 
 // ZodLazy
 export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
+// @__NO_SIDE_EFFECTS__
 export function _lazy<T extends schemas.$ZodType>(
   Class: util.SchemaClass<schemas.$ZodLazy>,
   getter: () => T
@@ -1430,6 +1633,7 @@ export function _lazy<T extends schemas.$ZodType>(
 
 // ZodPromise
 export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
+// @__NO_SIDE_EFFECTS__
 export function _promise<T extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodPromise>,
   innerType: T
@@ -1442,6 +1646,7 @@ export function _promise<T extends schemas.$ZodObject>(
 
 // ZodCustom
 export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
+// @__NO_SIDE_EFFECTS__
 export function _custom<O = unknown, I = O>(
   Class: util.SchemaClass<schemas.$ZodCustom>,
   fn: (data: O) => unknown,
@@ -1459,14 +1664,8 @@ export function _custom<O = unknown, I = O>(
   return schema as any;
 }
 
-// export function _refine<T>(
-//   Class: util.SchemaClass<schemas.$ZodCustom>,
-//   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
-//   _params: string | $ZodCustomParams = {}
-// ): checks.$ZodCheck<T> {
-//   return _custom(Class, fn, _params);
-// }
 // same as _custom but defaults to abort:false
+// @__NO_SIDE_EFFECTS__
 export function _refine<O = unknown, I = O>(
   Class: util.SchemaClass<schemas.$ZodCustom>,
   fn: (data: O) => unknown,
@@ -1482,6 +1681,92 @@ export function _refine<O = unknown, I = O>(
   return schema as any;
 }
 
+export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any
+  ? RawIssue<T>
+  : never;
+type RawIssue<T extends errors.$ZodIssueBase> = T extends any
+  ? util.Flatten<
+      util.MakePartial<T, "message" | "path"> & {
+        /** The schema or check that originated this issue. */
+        readonly inst?: schemas.$ZodType | checks.$ZodCheck;
+        /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+        readonly continue?: boolean | undefined;
+      } & Record<string, unknown>
+    >
+  : never;
+
+export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+
+export interface $ZodSuperRefineParams {
+  /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _superRefine<T>(
+  fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>,
+  params?: $ZodSuperRefineParams
+): checks.$ZodCheck<T> {
+  const ch = _check<T>((payload) => {
+    (payload as $RefinementCtx).addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
+      } else {
+        // for Zod 3 backwards compatibility
+        const _issue: any = issue;
+        if (_issue.fatal) _issue.continue = false;
+        _issue.code ??= "custom";
+        if (!("input" in _issue)) _issue.input = payload.value;
+        _issue.inst ??= ch;
+        _issue.continue ??= !ch._zod.def.abort; // abort is always undefined, so this is always true...
+        payload.issues.push(util.issue(_issue));
+      }
+    };
+
+    return fn(payload.value, payload as $RefinementCtx<T>);
+  }, params);
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O> {
+  const ch = new checks.$ZodCheck({
+    check: "custom",
+    ...util.normalizeParams(params),
+  });
+
+  ch._zod.check = fn;
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function describe<T>(description: string): checks.$ZodCheck<T> {
+  const ch = new checks.$ZodCheck({ check: "describe" });
+  ch._zod.onattach = [
+    (inst) => {
+      const existing = registries.globalRegistry.get(inst) ?? {};
+      registries.globalRegistry.add(inst, { ...existing, description });
+    },
+  ];
+  ch._zod.check = () => {}; // no-op check
+  return ch;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T> {
+  const ch = new checks.$ZodCheck({ check: "meta" });
+  ch._zod.onattach = [
+    (inst) => {
+      const existing = registries.globalRegistry.get(inst) ?? {};
+      registries.globalRegistry.add(inst, { ...existing, ...metadata });
+    },
+  ];
+  ch._zod.check = () => {}; // no-op check
+  return ch;
+}
+
 // export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">
 
 /////////    STRINGBOOL   /////////
@@ -1498,18 +1783,15 @@ export interface $ZodStringBoolParams extends TypeParams {
   case?: "sensitive" | "insensitive" | undefined;
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _stringbool(
   Classes: {
-    Pipe?: typeof schemas.$ZodPipe;
+    Codec?: typeof schemas.$ZodCodec;
     Boolean?: typeof schemas.$ZodBoolean;
-    Transform?: typeof schemas.$ZodTransform;
     String?: typeof schemas.$ZodString;
   },
   _params?: string | $ZodStringBoolParams
-): schemas.$ZodPipe<
-  schemas.$ZodPipe<schemas.$ZodString, schemas.$ZodTransform<boolean, string>>,
-  schemas.$ZodBoolean<boolean>
-> {
+): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean> {
   const params = util.normalizeParams(_params);
 
   let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
@@ -1522,15 +1804,19 @@ export function _stringbool(
   const truthySet = new Set(truthyArray);
   const falsySet = new Set(falsyArray);
 
-  const _Pipe = Classes.Pipe ?? schemas.$ZodPipe;
+  const _Codec = Classes.Codec ?? schemas.$ZodCodec;
   const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
   const _String = Classes.String ?? schemas.$ZodString;
-  const _Transform = Classes.Transform ?? schemas.$ZodTransform;
 
-  const tx = new _Transform({
-    type: "transform",
-    transform: (input, payload: schemas.ParsePayload<unknown>) => {
-      let data: string = input as string;
+  const stringSchema = new _String({ type: "string", error: params.error });
+  const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
+
+  const codec = new _Codec({
+    type: "pipe",
+    in: stringSchema as any,
+    out: booleanSchema as any,
+    transform: ((input: string, payload: schemas.ParsePayload<string>) => {
+      let data: string = input;
       if (params.case !== "sensitive") data = data.toLowerCase();
       if (truthySet.has(data)) {
         return true;
@@ -1542,34 +1828,30 @@ export function _stringbool(
           expected: "stringbool",
           values: [...truthySet, ...falsySet],
           input: payload.value,
-          inst: tx,
+          inst: codec,
+          continue: false,
         });
         return {} as never;
       }
-    },
+    }) as any,
+    reverseTransform: ((input: boolean, _payload: schemas.ParsePayload<boolean>) => {
+      if (input === true) {
+        return truthyArray[0] || "true";
+      } else {
+        return falsyArray[0] || "false";
+      }
+    }) as any,
     error: params.error,
-  });
-  // params.error;
+  }) as any;
 
-  const innerPipe = new _Pipe({
-    type: "pipe",
-    in: new _String({ type: "string", error: params.error }),
-    out: tx,
-    error: params.error,
-  });
+  codec._zod.bag.truthy = truthyArray;
+  codec._zod.bag.falsy = falsyArray;
+  codec._zod.bag.case = params.case ?? "insensitive";
 
-  const outerPipe = new _Pipe({
-    type: "pipe",
-    in: innerPipe,
-    out: new _Boolean({
-      type: "boolean",
-      error: params.error,
-    }),
-    error: params.error,
-  });
-  return outerPipe as any;
+  return codec;
 }
 
+// @__NO_SIDE_EFFECTS__
 export function _stringFormat<Format extends string>(
   Class: typeof schemas.$ZodCustomStringFormat,
   format: Format,
@@ -1578,7 +1860,6 @@ export function _stringFormat<Format extends string>(
 ): schemas.$ZodCustomStringFormat<Format> {
   const params = util.normalizeParams(_params);
   const def: schemas.$ZodCustomStringFormatDef = {
-    ...util.normalizeParams(_params),
     check: "string_format",
     type: "string",
     format,