wapi-client 0.14.11 → 0.14.14

package/dist/lib/zod.browser.js

@@ -726,7 +726,7 @@ var allowsEval = cached(() => {
   }
 });
 function isPlainObject(data) {
-  return typeof data === "object" && data !== null && Object.getPrototypeOf(data) === Object.prototype;
+  return typeof data === "object" && data !== null && (Object.getPrototypeOf(data) === Object.prototype || Object.getPrototypeOf(data) === null);
 }
 function numKeys(data) {
   let keyCount = 0;
@@ -1069,10 +1069,10 @@ var initializer = (inst, def) => {
 };
 var $ZodError = $constructor("$ZodError", initializer);
 var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-function flattenError(error35, mapper = (issue2) => issue2.message) {
+function flattenError(error38, mapper = (issue2) => issue2.message) {
   const fieldErrors = {};
   const formErrors = [];
-  for (const sub of error35.issues) {
+  for (const sub of error38.issues) {
     if (sub.path.length > 0) {
       fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
       fieldErrors[sub.path[0]].push(mapper(sub));
@@ -1082,13 +1082,13 @@ function flattenError(error35, mapper = (issue2) => issue2.message) {
   }
   return { formErrors, fieldErrors };
 }
-function formatError(error35, _mapper) {
+function formatError(error38, _mapper) {
   const mapper = _mapper || function(issue2) {
     return issue2.message;
   };
   const fieldErrors = { _errors: [] };
-  const processError = (error36) => {
-    for (const issue2 of error36.issues) {
+  const processError = (error39) => {
+    for (const issue2 of error39.issues) {
       if (issue2.code === "invalid_union") {
         issue2.errors.map((issues) => processError({ issues }));
       } else if (issue2.code === "invalid_key") {
@@ -1115,18 +1115,18 @@ function formatError(error35, _mapper) {
       }
     }
   };
-  processError(error35);
+  processError(error38);
   return fieldErrors;
 }
-function treeifyError(error35, _mapper) {
+function treeifyError(error38, _mapper) {
   const mapper = _mapper || function(issue2) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error36, path = []) => {
+  const processError = (error39, path = []) => {
     var _a2, _b2, _c, _d;
     var _a, _b;
-    for (const issue2 of error36.issues) {
+    for (const issue2 of error39.issues) {
       if (issue2.code === "invalid_union") {
         issue2.errors.map((issues) => processError({ issues }, issue2.path));
       } else if (issue2.code === "invalid_key") {
@@ -1161,7 +1161,7 @@ function treeifyError(error35, _mapper) {
       }
     }
   };
-  processError(error35);
+  processError(error38);
   return result;
 }
 function toDotPath(path) {
@@ -1181,10 +1181,10 @@ function toDotPath(path) {
   }
   return segs.join("");
 }
-function prettifyError(error35) {
+function prettifyError(error38) {
   var _a;
   const lines = [];
-  const issues = [...error35.issues].sort((a, b) => a.path.length - b.path.length);
+  const issues = [...error38.issues].sort((a, b) => a.path.length - b.path.length);
   for (const issue2 of issues) {
     lines.push(`\u2716 ${issue2.message}`);
     if ((_a = issue2.path) == null ? void 0 : _a.length)
@@ -2598,6 +2598,11 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   $ZodType.init(inst, def);
   const _normalized = cached(() => {
     const keys = Object.keys(def.shape);
+    for (const k of keys) {
+      if (!(def.shape[k] instanceof $ZodType)) {
+        throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+      }
+    }
     const okeys = optionalKeys(def.shape);
     return {
       shape: def.shape,
@@ -2607,26 +2612,19 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
       optionalKeys: new Set(okeys)
     };
   });
-  defineLazy(inst._zod, "disc", () => {
+  defineLazy(inst._zod, "propValues", () => {
     var _a;
     const shape = def.shape;
-    const discMap = /* @__PURE__ */ new Map();
-    let hasDisc = false;
+    const propValues = {};
     for (const key in shape) {
       const field = shape[key]._zod;
-      if (field.values || field.disc) {
-        hasDisc = true;
-        const o = {
-          values: new Set((_a = field.values) != null ? _a : []),
-          maps: field.disc ? [field.disc] : []
-        };
-        discMap.set(key, o);
+      if (field.values) {
+        (_a = propValues[key]) != null ? _a : propValues[key] = /* @__PURE__ */ new Set();
+        for (const v of field.values)
+          propValues[key].add(v);
       }
     }
-    if (!hasDisc) {
-      return void 0;
-    }
-    return discMap;
+    return propValues;
   });
   const generateFastpass = (shape) => {
     const doc = new Doc(["shape", "payload", "ctx"]);
@@ -2814,63 +2812,36 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
     });
   };
 });
-function matchDiscriminatorAtKey(input, key, disc) {
-  let matched = true;
-  const data = input == null ? void 0 : input[key];
-  if (disc.values.size && !disc.values.has(data)) {
-    matched = false;
-  }
-  if (disc.maps.length > 0) {
-    for (const m of disc.maps) {
-      if (!matchDiscriminators(data, m)) {
-        matched = false;
-      }
-    }
-  }
-  return matched;
-}
-function matchDiscriminators(input, discs) {
-  let matched = true;
-  for (const [key, value] of discs) {
-    if (!matchDiscriminatorAtKey(input, key, value)) {
-      matched = false;
-    }
-  }
-  return matched;
-}
 var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   const _super = inst._zod.parse;
-  defineLazy(inst._zod, "disc", () => {
-    const _disc = /* @__PURE__ */ new Map();
-    for (const el of def.options) {
-      const subdisc = el._zod.disc;
-      if (!subdisc)
-        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(el)}"`);
-      for (const [key, o] of subdisc) {
-        if (!_disc.has(key))
-          _disc.set(key, {
-            values: /* @__PURE__ */ new Set(),
-            maps: []
-          });
-        const _o = _disc.get(key);
-        for (const v of o.values) {
-          _o.values.add(v);
+  defineLazy(inst._zod, "propValues", () => {
+    const propValues = {};
+    for (const option of def.options) {
+      const pv = option._zod.propValues;
+      if (!pv || Object.keys(pv).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+      for (const [k, v] of Object.entries(pv)) {
+        if (!propValues[k])
+          propValues[k] = /* @__PURE__ */ new Set();
+        for (const val of v) {
+          propValues[k].add(val);
         }
-        for (const m of o.maps)
-          _o.maps.push(m);
       }
     }
-    return _disc;
+    return propValues;
   });
-  const _discmap = cached(() => {
-    var _a;
+  const disc = cached(() => {
+    const opts = def.options;
     const map2 = /* @__PURE__ */ new Map();
-    for (const o of def.options) {
-      const discEl = (_a = o._zod.disc) == null ? void 0 : _a.get(def.discriminator);
-      if (!discEl)
-        throw new Error("Invalid discriminated union option");
-      map2.set(o, discEl);
+    for (const o of opts) {
+      const values = o._zod.propValues[def.discriminator];
+      for (const v of values) {
+        if (map2.has(v)) {
+          throw new Error(`Duplicate discriminator value "${String(v)}"`);
+        }
+        map2.set(v, o);
+      }
     }
     return map2;
   });
@@ -2885,16 +2856,10 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       });
       return payload;
     }
-    const filtered = [];
-    const discmap = _discmap.value;
-    for (const option of def.options) {
-      const subdisc = discmap.get(option);
-      if (matchDiscriminatorAtKey(input, def.discriminator, subdisc)) {
-        filtered.push(option);
-      }
+    const opt = disc.value.get(input == null ? void 0 : input[def.discriminator]);
+    if (opt) {
+      return opt._zod.run(payload, ctx);
     }
-    if (filtered.length === 1)
-      return filtered[0]._zod.run(payload, ctx);
     if (def.unionFallback) {
       return _super(payload, ctx);
     }
@@ -3492,7 +3457,7 @@ function handlePipeResult(left, def, ctx) {
 }
 var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
   $ZodType.init(inst, def);
-  defineLazy(inst._zod, "disc", () => def.innerType._zod.disc);
+  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
   defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
   defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   inst._zod.parse = (payload, ctx) => {
@@ -3562,7 +3527,7 @@ var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "innerType", () => def.getter());
   defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
-  defineLazy(inst._zod, "disc", () => inst._zod.innerType._zod.disc);
+  defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
   defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
   defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
   inst._zod.parse = (payload, ctx) => {
@@ -3619,21 +3584,24 @@ __export(locales_exports, {
   fa: () => fa_default,
   fi: () => fi_default,
   fr: () => fr_default,
-  frCA: () => frCA_default,
+  frCA: () => fr_CA_default,
   he: () => he_default,
   hu: () => hu_default,
   id: () => id_default,
   it: () => it_default,
   ja: () => ja_default,
+  kh: () => kh_default,
   ko: () => ko_default,
   mk: () => mk_default,
   ms: () => ms_default,
+  nl: () => nl_default,
   no: () => no_default,
   ota: () => ota_default,
   pl: () => pl_default,
   pt: () => pt_default,
   ru: () => ru_default,
   sl: () => sl_default,
+  sv: () => sv_default,
   ta: () => ta_default,
   th: () => th_default,
   tr: () => tr_default,
@@ -3641,7 +3609,7 @@ __export(locales_exports, {
   ur: () => ur_default,
   vi: () => vi_default,
   zhCN: () => zh_CN_default,
-  zhTW: () => zh_tw_default
+  zhTW: () => zh_TW_default
 });
 
 // node_modules/zod/dist/esm/v4/locales/ar.js
@@ -4481,7 +4449,6 @@ var error7 = (issue2) => {
   switch (issue2.code) {
     case "invalid_type":
       return `Invalid input: expected ${issue2.expected}, received ${parsedType7(issue2.input)}`;
-    // return `Invalid input: expected ${issue.expected}, received ${util.getParsedType(issue.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
@@ -5015,7 +4982,7 @@ function fr_default() {
   };
 }
 
-// node_modules/zod/dist/esm/v4/locales/frCA.js
+// node_modules/zod/dist/esm/v4/locales/fr-CA.js
 var Sizable12 = {
   string: { unit: "caract\xE8res", verb: "avoir" },
   file: { unit: "octets", verb: "avoir" },
@@ -5127,7 +5094,7 @@ var error12 = (issue2) => {
       return `Entr\xE9e invalide`;
   }
 };
-function frCA_default() {
+function fr_CA_default() {
   return {
     localeError: error12
   };
@@ -5720,18 +5687,136 @@ function ja_default() {
   };
 }
 
-// node_modules/zod/dist/esm/v4/locales/ko.js
+// node_modules/zod/dist/esm/v4/locales/kh.js
 var Sizable18 = {
+  string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
+  file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
+  array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
+  set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
+};
+function getSizing18(origin) {
+  var _a;
+  return (_a = Sizable18[origin]) != null ? _a : null;
+}
+var parsedType18 = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "\u1798\u17B7\u1793\u1798\u17C2\u1793\u1787\u17B6\u179B\u17C1\u1781 (NaN)" : "\u179B\u17C1\u1781";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "\u17A2\u17B6\u179A\u17C1 (Array)";
+      }
+      if (data === null) {
+        return "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)";
+      }
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  return t;
+};
+var Nouns18 = {
+  regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
+  email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
+  url: "URL",
+  emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
+  uuid: "UUID",
+  uuidv4: "UUIDv4",
+  uuidv6: "UUIDv6",
+  nanoid: "nanoid",
+  guid: "GUID",
+  cuid: "cuid",
+  cuid2: "cuid2",
+  ulid: "ULID",
+  xid: "XID",
+  ksuid: "KSUID",
+  datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
+  date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
+  time: "\u1798\u17C9\u17C4\u1784 ISO",
+  duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
+  ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
+  ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
+  cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
+  cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
+  base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
+  base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
+  json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
+  e164: "\u179B\u17C1\u1781 E.164",
+  jwt: "JWT",
+  template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
+};
+var error18 = (issue2) => {
+  var _a, _b, _c, _d;
+  switch (issue2.code) {
+    case "invalid_type":
+      return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${parsedType18(issue2.input)}`;
+    case "invalid_value":
+      if (issue2.values.length === 1)
+        return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive(issue2.values[0])}`;
+      return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues(issue2.values, "|")}`;
+    case "too_big": {
+      const adj = issue2.inclusive ? "<=" : "<";
+      const sizing = getSizing18(issue2.origin);
+      if (sizing)
+        return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_a = issue2.origin) != null ? _a : "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u1792\u17B6\u178F\u17BB"}`;
+      return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_c = issue2.origin) != null ? _c : "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()}`;
+    }
+    case "too_small": {
+      const adj = issue2.inclusive ? ">=" : ">";
+      const sizing = getSizing18(issue2.origin);
+      if (sizing) {
+        return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
+      }
+      return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()}`;
+    }
+    case "invalid_format": {
+      const _issue = issue2;
+      if (_issue.format === "starts_with") {
+        return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
+      }
+      if (_issue.format === "ends_with")
+        return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
+      if (_issue.format === "includes")
+        return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
+      if (_issue.format === "regex")
+        return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
+      return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${(_d = Nouns18[_issue.format]) != null ? _d : issue2.format}`;
+    }
+    case "not_multiple_of":
+      return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue2.divisor}`;
+    case "unrecognized_keys":
+      return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues(issue2.keys, ", ")}`;
+    case "invalid_key":
+      return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`;
+    case "invalid_union":
+      return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
+    case "invalid_element":
+      return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`;
+    default:
+      return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
+  }
+};
+function kh_default() {
+  return {
+    localeError: error18
+  };
+}
+
+// node_modules/zod/dist/esm/v4/locales/ko.js
+var Sizable19 = {
   string: { unit: "\uBB38\uC790", verb: "to have" },
   file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
   array: { unit: "\uAC1C", verb: "to have" },
   set: { unit: "\uAC1C", verb: "to have" }
 };
-function getSizing18(origin) {
+function getSizing19(origin) {
   var _a;
-  return (_a = Sizable18[origin]) != null ? _a : null;
+  return (_a = Sizable19[origin]) != null ? _a : null;
 }
-var parsedType18 = (data) => {
+var parsedType19 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -5751,7 +5836,7 @@ var parsedType18 = (data) => {
   }
   return t;
 };
-var Nouns18 = {
+var Nouns19 = {
   regex: "\uC785\uB825",
   email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
   url: "URL",
@@ -5781,11 +5866,11 @@ var Nouns18 = {
   jwt: "JWT",
   template_literal: "\uC785\uB825"
 };
-var error18 = (issue2) => {
+var error19 = (issue2) => {
   var _a, _b, _c, _d, _e, _f, _g;
   switch (issue2.code) {
     case "invalid_type":
-      return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${parsedType18(issue2.input)}\uC785\uB2C8\uB2E4`;
+      return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${parsedType19(issue2.input)}\uC785\uB2C8\uB2E4`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive(issue2.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
@@ -5793,7 +5878,7 @@ var error18 = (issue2) => {
     case "too_big": {
       const adj = issue2.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
       const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
-      const sizing = getSizing18(issue2.origin);
+      const sizing = getSizing19(issue2.origin);
       const unit = (_a = sizing == null ? void 0 : sizing.unit) != null ? _a : "\uC694\uC18C";
       if (sizing)
         return `${(_b = issue2.origin) != null ? _b : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`;
@@ -5802,7 +5887,7 @@ var error18 = (issue2) => {
     case "too_small": {
       const adj = issue2.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
       const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
-      const sizing = getSizing18(issue2.origin);
+      const sizing = getSizing19(issue2.origin);
       const unit = (_d = sizing == null ? void 0 : sizing.unit) != null ? _d : "\uC694\uC18C";
       if (sizing) {
         return `${(_e = issue2.origin) != null ? _e : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`;
@@ -5820,7 +5905,7 @@ var error18 = (issue2) => {
         return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
       if (_issue.format === "regex")
         return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
-      return `\uC798\uBABB\uB41C ${(_g = Nouns18[_issue.format]) != null ? _g : issue2.format}`;
+      return `\uC798\uBABB\uB41C ${(_g = Nouns19[_issue.format]) != null ? _g : issue2.format}`;
     }
     case "not_multiple_of":
       return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue2.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
@@ -5838,22 +5923,22 @@ var error18 = (issue2) => {
 };
 function ko_default() {
   return {
-    localeError: error18
+    localeError: error19
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/mk.js
-var Sizable19 = {
+var Sizable20 = {
   string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
   file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
   array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
   set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
 };
-function getSizing19(origin) {
+function getSizing20(origin) {
   var _a;
-  return (_a = Sizable19[origin]) != null ? _a : null;
+  return (_a = Sizable20[origin]) != null ? _a : null;
 }
-var parsedType19 = (data) => {
+var parsedType20 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -5873,7 +5958,7 @@ var parsedType19 = (data) => {
   }
   return t;
 };
-var Nouns19 = {
+var Nouns20 = {
   regex: "\u0432\u043D\u0435\u0441",
   email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
   url: "URL",
@@ -5903,11 +5988,11 @@ var Nouns19 = {
   jwt: "JWT",
   template_literal: "\u0432\u043D\u0435\u0441"
 };
-var error19 = (issue2) => {
+var error20 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${parsedType19(issue2.input)}`;
+      return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${parsedType20(issue2.input)}`;
     // return `Invalid input: expected ${issue.expected}, received ${util.getParsedType(issue.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
@@ -5915,14 +6000,14 @@ var error19 = (issue2) => {
       return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing19(issue2.origin);
+      const sizing = getSizing20(issue2.origin);
       if (sizing)
         return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_a = issue2.origin) != null ? _a : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
       return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_c = issue2.origin) != null ? _c : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing19(issue2.origin);
+      const sizing = getSizing20(issue2.origin);
       if (sizing) {
         return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -5939,7 +6024,7 @@ var error19 = (issue2) => {
         return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
-      return `Invalid ${(_d = Nouns19[_issue.format]) != null ? _d : issue2.format}`;
+      return `Invalid ${(_d = Nouns20[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue2.divisor}`;
@@ -5957,22 +6042,22 @@ var error19 = (issue2) => {
 };
 function mk_default() {
   return {
-    localeError: error19
+    localeError: error20
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/ms.js
-var Sizable20 = {
+var Sizable21 = {
   string: { unit: "aksara", verb: "mempunyai" },
   file: { unit: "bait", verb: "mempunyai" },
   array: { unit: "elemen", verb: "mempunyai" },
   set: { unit: "elemen", verb: "mempunyai" }
 };
-function getSizing20(origin) {
+function getSizing21(origin) {
   var _a;
-  return (_a = Sizable20[origin]) != null ? _a : null;
+  return (_a = Sizable21[origin]) != null ? _a : null;
 }
-var parsedType20 = (data) => {
+var parsedType21 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -5992,7 +6077,7 @@ var parsedType20 = (data) => {
   }
   return t;
 };
-var Nouns20 = {
+var Nouns21 = {
   regex: "input",
   email: "alamat e-mel",
   url: "URL",
@@ -6022,25 +6107,25 @@ var Nouns20 = {
   jwt: "JWT",
   template_literal: "input"
 };
-var error20 = (issue2) => {
+var error21 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `Input tidak sah: dijangka ${issue2.expected}, diterima ${parsedType20(issue2.input)}`;
+      return `Input tidak sah: dijangka ${issue2.expected}, diterima ${parsedType21(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Input tidak sah: dijangka ${stringifyPrimitive(issue2.values[0])}`;
       return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing20(issue2.origin);
+      const sizing = getSizing21(issue2.origin);
       if (sizing)
         return `Terlalu besar: dijangka ${(_a = issue2.origin) != null ? _a : "nilai"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "elemen"}`;
       return `Terlalu besar: dijangka ${(_c = issue2.origin) != null ? _c : "nilai"} adalah ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing20(issue2.origin);
+      const sizing = getSizing21(issue2.origin);
       if (sizing) {
         return `Terlalu kecil: dijangka ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -6056,7 +6141,7 @@ var error20 = (issue2) => {
         return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
-      return `${(_d = Nouns20[_issue.format]) != null ? _d : issue2.format} tidak sah`;
+      return `${(_d = Nouns21[_issue.format]) != null ? _d : issue2.format} tidak sah`;
     }
     case "not_multiple_of":
       return `Nombor tidak sah: perlu gandaan ${issue2.divisor}`;
@@ -6074,22 +6159,140 @@ var error20 = (issue2) => {
 };
 function ms_default() {
   return {
-    localeError: error20
+    localeError: error21
+  };
+}
+
+// node_modules/zod/dist/esm/v4/locales/nl.js
+var Sizable22 = {
+  string: { unit: "tekens" },
+  file: { unit: "bytes" },
+  array: { unit: "elementen" },
+  set: { unit: "elementen" }
+};
+function getSizing22(origin) {
+  var _a;
+  return (_a = Sizable22[origin]) != null ? _a : null;
+}
+var parsedType22 = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "getal";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  return t;
+};
+var Nouns22 = {
+  regex: "invoer",
+  email: "emailadres",
+  url: "URL",
+  emoji: "emoji",
+  uuid: "UUID",
+  uuidv4: "UUIDv4",
+  uuidv6: "UUIDv6",
+  nanoid: "nanoid",
+  guid: "GUID",
+  cuid: "cuid",
+  cuid2: "cuid2",
+  ulid: "ULID",
+  xid: "XID",
+  ksuid: "KSUID",
+  datetime: "ISO datum en tijd",
+  date: "ISO datum",
+  time: "ISO tijd",
+  duration: "ISO duur",
+  ipv4: "IPv4-adres",
+  ipv6: "IPv6-adres",
+  cidrv4: "IPv4-bereik",
+  cidrv6: "IPv6-bereik",
+  base64: "base64-gecodeerde tekst",
+  base64url: "base64 URL-gecodeerde tekst",
+  json_string: "JSON string",
+  e164: "E.164-nummer",
+  jwt: "JWT",
+  template_literal: "invoer"
+};
+var error22 = (issue2) => {
+  var _a, _b, _c, _d;
+  switch (issue2.code) {
+    case "invalid_type":
+      return `Ongeldige invoer: verwacht ${issue2.expected}, ontving ${parsedType22(issue2.input)}`;
+    case "invalid_value":
+      if (issue2.values.length === 1)
+        return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue2.values[0])}`;
+      return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues(issue2.values, "|")}`;
+    case "too_big": {
+      const adj = issue2.inclusive ? "<=" : "<";
+      const sizing = getSizing22(issue2.origin);
+      if (sizing)
+        return `Te lang: verwacht dat ${(_a = issue2.origin) != null ? _a : "waarde"} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "elementen"} bevat`;
+      return `Te lang: verwacht dat ${(_c = issue2.origin) != null ? _c : "waarde"} ${adj}${issue2.maximum.toString()} is`;
+    }
+    case "too_small": {
+      const adj = issue2.inclusive ? ">=" : ">";
+      const sizing = getSizing22(issue2.origin);
+      if (sizing) {
+        return `Te kort: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} bevat`;
+      }
+      return `Te kort: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
+    }
+    case "invalid_format": {
+      const _issue = issue2;
+      if (_issue.format === "starts_with") {
+        return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`;
+      }
+      if (_issue.format === "ends_with")
+        return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`;
+      if (_issue.format === "includes")
+        return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
+      if (_issue.format === "regex")
+        return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
+      return `Ongeldig: ${(_d = Nouns22[_issue.format]) != null ? _d : issue2.format}`;
+    }
+    case "not_multiple_of":
+      return `Ongeldig getal: moet een veelvoud van ${issue2.divisor} zijn`;
+    case "unrecognized_keys":
+      return `Onbekende key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
+    case "invalid_key":
+      return `Ongeldige key in ${issue2.origin}`;
+    case "invalid_union":
+      return "Ongeldige invoer";
+    case "invalid_element":
+      return `Ongeldige waarde in ${issue2.origin}`;
+    default:
+      return `Ongeldige invoer`;
+  }
+};
+function nl_default() {
+  return {
+    localeError: error22
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/no.js
-var Sizable21 = {
+var Sizable23 = {
   string: { unit: "tegn", verb: "\xE5 ha" },
   file: { unit: "bytes", verb: "\xE5 ha" },
   array: { unit: "elementer", verb: "\xE5 inneholde" },
   set: { unit: "elementer", verb: "\xE5 inneholde" }
 };
-function getSizing21(origin) {
+function getSizing23(origin) {
   var _a;
-  return (_a = Sizable21[origin]) != null ? _a : null;
+  return (_a = Sizable23[origin]) != null ? _a : null;
 }
-var parsedType21 = (data) => {
+var parsedType23 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6109,7 +6312,7 @@ var parsedType21 = (data) => {
   }
   return t;
 };
-var Nouns21 = {
+var Nouns23 = {
   regex: "input",
   email: "e-postadresse",
   url: "URL",
@@ -6139,25 +6342,25 @@ var Nouns21 = {
   jwt: "JWT",
   template_literal: "input"
 };
-var error21 = (issue2) => {
+var error23 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `Ugyldig input: forventet ${issue2.expected}, fikk ${parsedType21(issue2.input)}`;
+      return `Ugyldig input: forventet ${issue2.expected}, fikk ${parsedType23(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Ugyldig verdi: forventet ${stringifyPrimitive(issue2.values[0])}`;
       return `Ugyldig valg: forventet en av ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing21(issue2.origin);
+      const sizing = getSizing23(issue2.origin);
       if (sizing)
         return `For stor(t): forventet ${(_a = issue2.origin) != null ? _a : "value"} til \xE5 ha ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "elementer"}`;
       return `For stor(t): forventet ${(_c = issue2.origin) != null ? _c : "value"} til \xE5 ha ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing21(issue2.origin);
+      const sizing = getSizing23(issue2.origin);
       if (sizing) {
         return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -6173,7 +6376,7 @@ var error21 = (issue2) => {
         return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
-      return `Ugyldig ${(_d = Nouns21[_issue.format]) != null ? _d : issue2.format}`;
+      return `Ugyldig ${(_d = Nouns23[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue2.divisor}`;
@@ -6191,22 +6394,22 @@ var error21 = (issue2) => {
 };
 function no_default() {
   return {
-    localeError: error21
+    localeError: error23
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/ota.js
-var Sizable22 = {
+var Sizable24 = {
   string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
   file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
   array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
   set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
 };
-function getSizing22(origin) {
+function getSizing24(origin) {
   var _a;
-  return (_a = Sizable22[origin]) != null ? _a : null;
+  return (_a = Sizable24[origin]) != null ? _a : null;
 }
-var parsedType22 = (data) => {
+var parsedType24 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6226,7 +6429,7 @@ var parsedType22 = (data) => {
   }
   return t;
 };
-var Nouns22 = {
+var Nouns24 = {
   regex: "giren",
   email: "epostag\xE2h",
   url: "URL",
@@ -6256,11 +6459,11 @@ var Nouns22 = {
   jwt: "JWT",
   template_literal: "giren"
 };
-var error22 = (issue2) => {
+var error24 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `F\xE2sit giren: umulan ${issue2.expected}, al\u0131nan ${parsedType22(issue2.input)}`;
+      return `F\xE2sit giren: umulan ${issue2.expected}, al\u0131nan ${parsedType24(issue2.input)}`;
     // return `Fâsit giren: umulan ${issue.expected}, alınan ${util.getParsedType(issue.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
@@ -6268,14 +6471,14 @@ var error22 = (issue2) => {
       return `F\xE2sit tercih: m\xFBteberler ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing22(issue2.origin);
+      const sizing = getSizing24(issue2.origin);
       if (sizing)
         return `Fazla b\xFCy\xFCk: ${(_a = issue2.origin) != null ? _a : "value"}, ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "elements"} sahip olmal\u0131yd\u0131.`;
       return `Fazla b\xFCy\xFCk: ${(_c = issue2.origin) != null ? _c : "value"}, ${adj}${issue2.maximum.toString()} olmal\u0131yd\u0131.`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing22(issue2.origin);
+      const sizing = getSizing24(issue2.origin);
       if (sizing) {
         return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
       }
@@ -6291,7 +6494,7 @@ var error22 = (issue2) => {
         return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
       if (_issue.format === "regex")
         return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
-      return `F\xE2sit ${(_d = Nouns22[_issue.format]) != null ? _d : issue2.format}`;
+      return `F\xE2sit ${(_d = Nouns24[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `F\xE2sit say\u0131: ${issue2.divisor} kat\u0131 olmal\u0131yd\u0131.`;
@@ -6309,22 +6512,22 @@ var error22 = (issue2) => {
 };
 function ota_default() {
   return {
-    localeError: error22
+    localeError: error24
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/pl.js
-var Sizable23 = {
+var Sizable25 = {
   string: { unit: "znak\xF3w", verb: "mie\u0107" },
   file: { unit: "bajt\xF3w", verb: "mie\u0107" },
   array: { unit: "element\xF3w", verb: "mie\u0107" },
   set: { unit: "element\xF3w", verb: "mie\u0107" }
 };
-function getSizing23(origin) {
+function getSizing25(origin) {
   var _a;
-  return (_a = Sizable23[origin]) != null ? _a : null;
+  return (_a = Sizable25[origin]) != null ? _a : null;
 }
-var parsedType23 = (data) => {
+var parsedType25 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6344,7 +6547,7 @@ var parsedType23 = (data) => {
   }
   return t;
 };
-var Nouns23 = {
+var Nouns25 = {
   regex: "wyra\u017Cenie",
   email: "adres email",
   url: "URL",
@@ -6374,18 +6577,18 @@ var Nouns23 = {
   jwt: "JWT",
   template_literal: "wej\u015Bcie"
 };
-var error23 = (issue2) => {
+var error25 = (issue2) => {
   var _a, _b, _c, _d, _e, _f, _g;
   switch (issue2.code) {
     case "invalid_type":
-      return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${issue2.expected}, otrzymano ${parsedType23(issue2.input)}`;
+      return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${issue2.expected}, otrzymano ${parsedType25(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive(issue2.values[0])}`;
       return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing23(issue2.origin);
+      const sizing = getSizing25(issue2.origin);
       if (sizing) {
         return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${(_a = issue2.origin) != null ? _a : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "element\xF3w"}`;
       }
@@ -6393,7 +6596,7 @@ var error23 = (issue2) => {
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing23(issue2.origin);
+      const sizing = getSizing25(issue2.origin);
       if (sizing) {
         return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${(_d = issue2.origin) != null ? _d : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.minimum.toString()} ${(_e = sizing.unit) != null ? _e : "element\xF3w"}`;
       }
@@ -6409,7 +6612,7 @@ var error23 = (issue2) => {
         return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
-      return `Nieprawid\u0142ow(y/a/e) ${(_g = Nouns23[_issue.format]) != null ? _g : issue2.format}`;
+      return `Nieprawid\u0142ow(y/a/e) ${(_g = Nouns25[_issue.format]) != null ? _g : issue2.format}`;
     }
     case "not_multiple_of":
       return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue2.divisor}`;
@@ -6427,22 +6630,22 @@ var error23 = (issue2) => {
 };
 function pl_default() {
   return {
-    localeError: error23
+    localeError: error25
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/pt.js
-var Sizable24 = {
+var Sizable26 = {
   string: { unit: "caracteres", verb: "ter" },
   file: { unit: "bytes", verb: "ter" },
   array: { unit: "itens", verb: "ter" },
   set: { unit: "itens", verb: "ter" }
 };
-function getSizing24(origin) {
+function getSizing26(origin) {
   var _a;
-  return (_a = Sizable24[origin]) != null ? _a : null;
+  return (_a = Sizable26[origin]) != null ? _a : null;
 }
-var parsedType24 = (data) => {
+var parsedType26 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6462,7 +6665,7 @@ var parsedType24 = (data) => {
   }
   return t;
 };
-var Nouns24 = {
+var Nouns26 = {
   regex: "padr\xE3o",
   email: "endere\xE7o de e-mail",
   url: "URL",
@@ -6492,25 +6695,25 @@ var Nouns24 = {
   jwt: "JWT",
   template_literal: "entrada"
 };
-var error24 = (issue2) => {
+var error26 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `Tipo inv\xE1lido: esperado ${issue2.expected}, recebido ${parsedType24(issue2.input)}`;
+      return `Tipo inv\xE1lido: esperado ${issue2.expected}, recebido ${parsedType26(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Entrada inv\xE1lida: esperado ${stringifyPrimitive(issue2.values[0])}`;
       return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing24(issue2.origin);
+      const sizing = getSizing26(issue2.origin);
       if (sizing)
         return `Muito grande: esperado que ${(_a = issue2.origin) != null ? _a : "valor"} tivesse ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "elementos"}`;
       return `Muito grande: esperado que ${(_c = issue2.origin) != null ? _c : "valor"} fosse ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing24(issue2.origin);
+      const sizing = getSizing26(issue2.origin);
       if (sizing) {
         return `Muito pequeno: esperado que ${issue2.origin} tivesse ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -6526,7 +6729,7 @@ var error24 = (issue2) => {
         return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
-      return `${(_d = Nouns24[_issue.format]) != null ? _d : issue2.format} inv\xE1lido`;
+      return `${(_d = Nouns26[_issue.format]) != null ? _d : issue2.format} inv\xE1lido`;
     }
     case "not_multiple_of":
       return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
@@ -6544,7 +6747,7 @@ var error24 = (issue2) => {
 };
 function pt_default() {
   return {
-    localeError: error24
+    localeError: error26
   };
 }
 
@@ -6564,7 +6767,7 @@ function getRussianPlural(count, one, few, many) {
   }
   return many;
 }
-var Sizable25 = {
+var Sizable27 = {
   string: {
     unit: {
       one: "\u0441\u0438\u043C\u0432\u043E\u043B",
@@ -6598,11 +6801,11 @@ var Sizable25 = {
     verb: "\u0438\u043C\u0435\u0442\u044C"
   }
 };
-function getSizing25(origin) {
+function getSizing27(origin) {
   var _a;
-  return (_a = Sizable25[origin]) != null ? _a : null;
+  return (_a = Sizable27[origin]) != null ? _a : null;
 }
-var parsedType25 = (data) => {
+var parsedType27 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6622,7 +6825,7 @@ var parsedType25 = (data) => {
   }
   return t;
 };
-var Nouns25 = {
+var Nouns27 = {
   regex: "\u0432\u0432\u043E\u0434",
   email: "email \u0430\u0434\u0440\u0435\u0441",
   url: "URL",
@@ -6652,18 +6855,18 @@ var Nouns25 = {
   jwt: "JWT",
   template_literal: "\u0432\u0432\u043E\u0434"
 };
-var error25 = (issue2) => {
+var error27 = (issue2) => {
   var _a, _b, _c;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${parsedType25(issue2.input)}`;
+      return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${parsedType27(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive(issue2.values[0])}`;
       return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing25(issue2.origin);
+      const sizing = getSizing27(issue2.origin);
       if (sizing) {
         const maxValue = Number(issue2.maximum);
         const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
@@ -6673,7 +6876,7 @@ var error25 = (issue2) => {
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing25(issue2.origin);
+      const sizing = getSizing27(issue2.origin);
       if (sizing) {
         const minValue = Number(issue2.minimum);
         const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
@@ -6691,7 +6894,7 @@ var error25 = (issue2) => {
         return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
-      return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${(_c = Nouns25[_issue.format]) != null ? _c : issue2.format}`;
+      return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${(_c = Nouns27[_issue.format]) != null ? _c : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
@@ -6709,22 +6912,22 @@ var error25 = (issue2) => {
 };
 function ru_default() {
   return {
-    localeError: error25
+    localeError: error27
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/sl.js
-var Sizable26 = {
+var Sizable28 = {
   string: { unit: "znakov", verb: "imeti" },
   file: { unit: "bajtov", verb: "imeti" },
   array: { unit: "elementov", verb: "imeti" },
   set: { unit: "elementov", verb: "imeti" }
 };
-function getSizing26(origin) {
+function getSizing28(origin) {
   var _a;
-  return (_a = Sizable26[origin]) != null ? _a : null;
+  return (_a = Sizable28[origin]) != null ? _a : null;
 }
-var parsedType26 = (data) => {
+var parsedType28 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6744,7 +6947,7 @@ var parsedType26 = (data) => {
   }
   return t;
 };
-var Nouns26 = {
+var Nouns28 = {
   regex: "vnos",
   email: "e-po\u0161tni naslov",
   url: "URL",
@@ -6774,25 +6977,25 @@ var Nouns26 = {
   jwt: "JWT",
   template_literal: "vnos"
 };
-var error26 = (issue2) => {
+var error28 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `Neveljaven vnos: pri\u010Dakovano ${issue2.expected}, prejeto ${parsedType26(issue2.input)}`;
+      return `Neveljaven vnos: pri\u010Dakovano ${issue2.expected}, prejeto ${parsedType28(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive(issue2.values[0])}`;
       return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing26(issue2.origin);
+      const sizing = getSizing28(issue2.origin);
       if (sizing)
         return `Preveliko: pri\u010Dakovano, da bo ${(_a = issue2.origin) != null ? _a : "vrednost"} imelo ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "elementov"}`;
       return `Preveliko: pri\u010Dakovano, da bo ${(_c = issue2.origin) != null ? _c : "vrednost"} ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing26(issue2.origin);
+      const sizing = getSizing28(issue2.origin);
       if (sizing) {
         return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} imelo ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -6809,7 +7012,7 @@ var error26 = (issue2) => {
         return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
-      return `Neveljaven ${(_d = Nouns26[_issue.format]) != null ? _d : issue2.format}`;
+      return `Neveljaven ${(_d = Nouns28[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue2.divisor}`;
@@ -6827,22 +7030,141 @@ var error26 = (issue2) => {
 };
 function sl_default() {
   return {
-    localeError: error26
+    localeError: error28
+  };
+}
+
+// node_modules/zod/dist/esm/v4/locales/sv.js
+var Sizable29 = {
+  string: { unit: "tecken", verb: "att ha" },
+  file: { unit: "bytes", verb: "att ha" },
+  array: { unit: "objekt", verb: "att inneh\xE5lla" },
+  set: { unit: "objekt", verb: "att inneh\xE5lla" }
+};
+function getSizing29(origin) {
+  var _a;
+  return (_a = Sizable29[origin]) != null ? _a : null;
+}
+var parsedType29 = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "antal";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "lista";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  return t;
+};
+var Nouns29 = {
+  regex: "regulj\xE4rt uttryck",
+  email: "e-postadress",
+  url: "URL",
+  emoji: "emoji",
+  uuid: "UUID",
+  uuidv4: "UUIDv4",
+  uuidv6: "UUIDv6",
+  nanoid: "nanoid",
+  guid: "GUID",
+  cuid: "cuid",
+  cuid2: "cuid2",
+  ulid: "ULID",
+  xid: "XID",
+  ksuid: "KSUID",
+  datetime: "ISO-datum och tid",
+  date: "ISO-datum",
+  time: "ISO-tid",
+  duration: "ISO-varaktighet",
+  ipv4: "IPv4-intervall",
+  ipv6: "IPv6-intervall",
+  cidrv4: "IPv4-spektrum",
+  cidrv6: "IPv6-spektrum",
+  base64: "base64-kodad str\xE4ng",
+  base64url: "base64url-kodad str\xE4ng",
+  json_string: "JSON-str\xE4ng",
+  e164: "E.164-nummer",
+  jwt: "JWT",
+  template_literal: "mall-literal"
+};
+var error29 = (issue2) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  switch (issue2.code) {
+    case "invalid_type":
+      return `Ogiltig inmatning: f\xF6rv\xE4ntat ${issue2.expected}, fick ${parsedType29(issue2.input)}`;
+    case "invalid_value":
+      if (issue2.values.length === 1)
+        return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive(issue2.values[0])}`;
+      return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues(issue2.values, "|")}`;
+    case "too_big": {
+      const adj = issue2.inclusive ? "<=" : "<";
+      const sizing = getSizing29(issue2.origin);
+      if (sizing) {
+        return `F\xF6r stor(t): f\xF6rv\xE4ntade ${(_a = issue2.origin) != null ? _a : "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "element"}`;
+      }
+      return `F\xF6r stor(t): f\xF6rv\xE4ntat ${(_c = issue2.origin) != null ? _c : "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()}`;
+    }
+    case "too_small": {
+      const adj = issue2.inclusive ? ">=" : ">";
+      const sizing = getSizing29(issue2.origin);
+      if (sizing) {
+        return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_d = issue2.origin) != null ? _d : "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+      }
+      return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_e = issue2.origin) != null ? _e : "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()}`;
+    }
+    case "invalid_format": {
+      const _issue = issue2;
+      if (_issue.format === "starts_with") {
+        return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
+      }
+      if (_issue.format === "ends_with")
+        return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
+      if (_issue.format === "includes")
+        return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
+      if (_issue.format === "regex")
+        return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
+      return `Ogiltig(t) ${(_f = Nouns29[_issue.format]) != null ? _f : issue2.format}`;
+    }
+    case "not_multiple_of":
+      return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue2.divisor}`;
+    case "unrecognized_keys":
+      return `${issue2.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues(issue2.keys, ", ")}`;
+    case "invalid_key":
+      return `Ogiltig nyckel i ${(_g = issue2.origin) != null ? _g : "v\xE4rdet"}`;
+    case "invalid_union":
+      return "Ogiltig input";
+    case "invalid_element":
+      return `Ogiltigt v\xE4rde i ${(_h = issue2.origin) != null ? _h : "v\xE4rdet"}`;
+    default:
+      return `Ogiltig input`;
+  }
+};
+function sv_default() {
+  return {
+    localeError: error29
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/ta.js
-var Sizable27 = {
+var Sizable30 = {
   string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
   file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
   array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
   set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
 };
-function getSizing27(origin) {
+function getSizing30(origin) {
   var _a;
-  return (_a = Sizable27[origin]) != null ? _a : null;
+  return (_a = Sizable30[origin]) != null ? _a : null;
 }
-var parsedType27 = (data) => {
+var parsedType30 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6862,7 +7184,7 @@ var parsedType27 = (data) => {
   }
   return t;
 };
-var Nouns27 = {
+var Nouns30 = {
   regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
   email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
   url: "URL",
@@ -6892,18 +7214,18 @@ var Nouns27 = {
   jwt: "JWT",
   template_literal: "input"
 };
-var error27 = (issue2) => {
+var error30 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${parsedType27(issue2.input)}`;
+      return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${parsedType30(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive(issue2.values[0])}`;
       return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues(issue2.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing27(issue2.origin);
+      const sizing = getSizing30(issue2.origin);
       if (sizing) {
         return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_a = issue2.origin) != null ? _a : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
       }
@@ -6911,7 +7233,7 @@ var error27 = (issue2) => {
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing27(issue2.origin);
+      const sizing = getSizing30(issue2.origin);
       if (sizing) {
         return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
       }
@@ -6927,7 +7249,7 @@ var error27 = (issue2) => {
         return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
       if (_issue.format === "regex")
         return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
-      return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${(_d = Nouns27[_issue.format]) != null ? _d : issue2.format}`;
+      return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${(_d = Nouns30[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue2.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
@@ -6945,22 +7267,22 @@ var error27 = (issue2) => {
 };
 function ta_default() {
   return {
-    localeError: error27
+    localeError: error30
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/th.js
-var Sizable28 = {
+var Sizable31 = {
   string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
   file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
   array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
   set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
 };
-function getSizing28(origin) {
+function getSizing31(origin) {
   var _a;
-  return (_a = Sizable28[origin]) != null ? _a : null;
+  return (_a = Sizable31[origin]) != null ? _a : null;
 }
-var parsedType28 = (data) => {
+var parsedType31 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -6980,7 +7302,7 @@ var parsedType28 = (data) => {
   }
   return t;
 };
-var Nouns28 = {
+var Nouns31 = {
   regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
   email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
   url: "URL",
@@ -7010,25 +7332,25 @@ var Nouns28 = {
   jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
   template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
 };
-var error28 = (issue2) => {
+var error31 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${parsedType28(issue2.input)}`;
+      return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${parsedType31(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive(issue2.values[0])}`;
       return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
-      const sizing = getSizing28(issue2.origin);
+      const sizing = getSizing31(issue2.origin);
       if (sizing)
         return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_a = issue2.origin) != null ? _a : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
       return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_c = issue2.origin) != null ? _c : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
-      const sizing = getSizing28(issue2.origin);
+      const sizing = getSizing31(issue2.origin);
       if (sizing) {
         return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -7045,7 +7367,7 @@ var error28 = (issue2) => {
         return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
       if (_issue.format === "regex")
         return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
-      return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${(_d = Nouns28[_issue.format]) != null ? _d : issue2.format}`;
+      return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${(_d = Nouns31[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue2.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
@@ -7063,22 +7385,22 @@ var error28 = (issue2) => {
 };
 function th_default() {
   return {
-    localeError: error28
+    localeError: error31
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/tr.js
-var Sizable29 = {
+var Sizable32 = {
   string: { unit: "karakter", verb: "olmal\u0131" },
   file: { unit: "bayt", verb: "olmal\u0131" },
   array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
   set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
 };
-function getSizing29(origin) {
+function getSizing32(origin) {
   var _a;
-  return (_a = Sizable29[origin]) != null ? _a : null;
+  return (_a = Sizable32[origin]) != null ? _a : null;
 }
-var parsedType29 = (data) => {
+var parsedType32 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -7098,7 +7420,7 @@ var parsedType29 = (data) => {
   }
   return t;
 };
-var Nouns29 = {
+var Nouns32 = {
   regex: "girdi",
   email: "e-posta adresi",
   url: "URL",
@@ -7128,25 +7450,25 @@ var Nouns29 = {
   jwt: "JWT",
   template_literal: "\u015Eablon dizesi"
 };
-var error29 = (issue2) => {
+var error32 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `Ge\xE7ersiz de\u011Fer: beklenen ${issue2.expected}, al\u0131nan ${parsedType29(issue2.input)}`;
+      return `Ge\xE7ersiz de\u011Fer: beklenen ${issue2.expected}, al\u0131nan ${parsedType32(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive(issue2.values[0])}`;
       return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing29(issue2.origin);
+      const sizing = getSizing32(issue2.origin);
       if (sizing)
         return `\xC7ok b\xFCy\xFCk: beklenen ${(_a = issue2.origin) != null ? _a : "de\u011Fer"} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\xF6\u011Fe"}`;
       return `\xC7ok b\xFCy\xFCk: beklenen ${(_c = issue2.origin) != null ? _c : "de\u011Fer"} ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing29(issue2.origin);
+      const sizing = getSizing32(issue2.origin);
       if (sizing)
         return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
@@ -7161,7 +7483,7 @@ var error29 = (issue2) => {
         return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
       if (_issue.format === "regex")
         return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
-      return `Ge\xE7ersiz ${(_d = Nouns29[_issue.format]) != null ? _d : issue2.format}`;
+      return `Ge\xE7ersiz ${(_d = Nouns32[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `Ge\xE7ersiz say\u0131: ${issue2.divisor} ile tam b\xF6l\xFCnebilmeli`;
@@ -7179,22 +7501,22 @@ var error29 = (issue2) => {
 };
 function tr_default() {
   return {
-    localeError: error29
+    localeError: error32
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/ua.js
-var Sizable30 = {
+var Sizable33 = {
   string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
   file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
   array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
   set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
 };
-function getSizing30(origin) {
+function getSizing33(origin) {
   var _a;
-  return (_a = Sizable30[origin]) != null ? _a : null;
+  return (_a = Sizable33[origin]) != null ? _a : null;
 }
-var parsedType30 = (data) => {
+var parsedType33 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -7214,7 +7536,7 @@ var parsedType30 = (data) => {
   }
   return t;
 };
-var Nouns30 = {
+var Nouns33 = {
   regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
   email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
   url: "URL",
@@ -7244,11 +7566,11 @@ var Nouns30 = {
   jwt: "JWT",
   template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
 };
-var error30 = (issue2) => {
+var error33 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${parsedType30(issue2.input)}`;
+      return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${parsedType33(issue2.input)}`;
     // return `Неправильні вхідні дані: очікується ${issue.expected}, отримано ${util.getParsedType(issue.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
@@ -7256,14 +7578,14 @@ var error30 = (issue2) => {
       return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing30(issue2.origin);
+      const sizing = getSizing33(issue2.origin);
       if (sizing)
         return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_a = issue2.origin) != null ? _a : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
       return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_c = issue2.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing30(issue2.origin);
+      const sizing = getSizing33(issue2.origin);
       if (sizing) {
         return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -7279,7 +7601,7 @@ var error30 = (issue2) => {
         return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
-      return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${(_d = Nouns30[_issue.format]) != null ? _d : issue2.format}`;
+      return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${(_d = Nouns33[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue2.divisor}`;
@@ -7297,22 +7619,22 @@ var error30 = (issue2) => {
 };
 function ua_default() {
   return {
-    localeError: error30
+    localeError: error33
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/ur.js
-var Sizable31 = {
+var Sizable34 = {
   string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
   file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
   array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
   set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
 };
-function getSizing31(origin) {
+function getSizing34(origin) {
   var _a;
-  return (_a = Sizable31[origin]) != null ? _a : null;
+  return (_a = Sizable34[origin]) != null ? _a : null;
 }
-var parsedType31 = (data) => {
+var parsedType34 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -7332,7 +7654,7 @@ var parsedType31 = (data) => {
   }
   return t;
 };
-var Nouns31 = {
+var Nouns34 = {
   regex: "\u0627\u0646 \u067E\u0679",
   email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
   url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
@@ -7362,25 +7684,25 @@ var Nouns31 = {
   jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
   template_literal: "\u0627\u0646 \u067E\u0679"
 };
-var error31 = (issue2) => {
+var error34 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${parsedType31(issue2.input)} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
+      return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${parsedType34(issue2.input)} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive(issue2.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
       return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues(issue2.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing31(issue2.origin);
+      const sizing = getSizing34(issue2.origin);
       if (sizing)
         return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_a = issue2.origin) != null ? _a : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
       return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_c = issue2.origin) != null ? _c : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue2.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing31(issue2.origin);
+      const sizing = getSizing34(issue2.origin);
       if (sizing) {
         return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u06D2 ${adj}${issue2.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
       }
@@ -7397,7 +7719,7 @@ var error31 = (issue2) => {
         return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
       if (_issue.format === "regex")
         return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
-      return `\u063A\u0644\u0637 ${(_d = Nouns31[_issue.format]) != null ? _d : issue2.format}`;
+      return `\u063A\u0644\u0637 ${(_d = Nouns34[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue2.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
@@ -7415,22 +7737,22 @@ var error31 = (issue2) => {
 };
 function ur_default() {
   return {
-    localeError: error31
+    localeError: error34
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/vi.js
-var Sizable32 = {
+var Sizable35 = {
   string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
   file: { unit: "byte", verb: "c\xF3" },
   array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
   set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
 };
-function getSizing32(origin) {
+function getSizing35(origin) {
   var _a;
-  return (_a = Sizable32[origin]) != null ? _a : null;
+  return (_a = Sizable35[origin]) != null ? _a : null;
 }
-var parsedType32 = (data) => {
+var parsedType35 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -7450,7 +7772,7 @@ var parsedType32 = (data) => {
   }
   return t;
 };
-var Nouns32 = {
+var Nouns35 = {
   regex: "\u0111\u1EA7u v\xE0o",
   email: "\u0111\u1ECBa ch\u1EC9 email",
   url: "URL",
@@ -7480,25 +7802,25 @@ var Nouns32 = {
   jwt: "JWT",
   template_literal: "\u0111\u1EA7u v\xE0o"
 };
-var error32 = (issue2) => {
+var error35 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${parsedType32(issue2.input)}`;
+      return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${parsedType35(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive(issue2.values[0])}`;
       return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing32(issue2.origin);
+      const sizing = getSizing35(issue2.origin);
       if (sizing)
         return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_a = issue2.origin) != null ? _a : "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "ph\u1EA7n t\u1EED"}`;
       return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_c = issue2.origin) != null ? _c : "gi\xE1 tr\u1ECB"} ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing32(issue2.origin);
+      const sizing = getSizing35(issue2.origin);
       if (sizing) {
         return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -7514,7 +7836,7 @@ var error32 = (issue2) => {
         return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
-      return `${(_d = Nouns32[_issue.format]) != null ? _d : issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`;
+      return `${(_d = Nouns35[_issue.format]) != null ? _d : issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`;
     }
     case "not_multiple_of":
       return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue2.divisor}`;
@@ -7532,22 +7854,22 @@ var error32 = (issue2) => {
 };
 function vi_default() {
   return {
-    localeError: error32
+    localeError: error35
   };
 }
 
 // node_modules/zod/dist/esm/v4/locales/zh-CN.js
-var Sizable33 = {
+var Sizable36 = {
   string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
   file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
   array: { unit: "\u9879", verb: "\u5305\u542B" },
   set: { unit: "\u9879", verb: "\u5305\u542B" }
 };
-function getSizing33(origin) {
+function getSizing36(origin) {
   var _a;
-  return (_a = Sizable33[origin]) != null ? _a : null;
+  return (_a = Sizable36[origin]) != null ? _a : null;
 }
-var parsedType33 = (data) => {
+var parsedType36 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -7567,7 +7889,7 @@ var parsedType33 = (data) => {
   }
   return t;
 };
-var Nouns33 = {
+var Nouns36 = {
   regex: "\u8F93\u5165",
   email: "\u7535\u5B50\u90AE\u4EF6",
   url: "URL",
@@ -7597,25 +7919,25 @@ var Nouns33 = {
   jwt: "JWT",
   template_literal: "\u8F93\u5165"
 };
-var error33 = (issue2) => {
+var error36 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${parsedType33(issue2.input)}`;
+      return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${parsedType36(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive(issue2.values[0])}`;
       return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing33(issue2.origin);
+      const sizing = getSizing36(issue2.origin);
       if (sizing)
         return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_a = issue2.origin) != null ? _a : "\u503C"} ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u4E2A\u5143\u7D20"}`;
       return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_c = issue2.origin) != null ? _c : "\u503C"} ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing33(issue2.origin);
+      const sizing = getSizing36(issue2.origin);
       if (sizing) {
         return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -7631,7 +7953,7 @@ var error33 = (issue2) => {
         return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
-      return `\u65E0\u6548${(_d = Nouns33[_issue.format]) != null ? _d : issue2.format}`;
+      return `\u65E0\u6548${(_d = Nouns36[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue2.divisor} \u7684\u500D\u6570`;
@@ -7649,22 +7971,22 @@ var error33 = (issue2) => {
 };
 function zh_CN_default() {
   return {
-    localeError: error33
+    localeError: error36
   };
 }
 
-// node_modules/zod/dist/esm/v4/locales/zh-tw.js
-var Sizable34 = {
+// node_modules/zod/dist/esm/v4/locales/zh-TW.js
+var Sizable37 = {
   string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
   file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
   array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
   set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
 };
-function getSizing34(origin) {
+function getSizing37(origin) {
   var _a;
-  return (_a = Sizable34[origin]) != null ? _a : null;
+  return (_a = Sizable37[origin]) != null ? _a : null;
 }
-var parsedType34 = (data) => {
+var parsedType37 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -7684,7 +8006,7 @@ var parsedType34 = (data) => {
   }
   return t;
 };
-var Nouns34 = {
+var Nouns37 = {
   regex: "\u8F38\u5165",
   email: "\u90F5\u4EF6\u5730\u5740",
   url: "URL",
@@ -7714,25 +8036,25 @@ var Nouns34 = {
   jwt: "JWT",
   template_literal: "\u8F38\u5165"
 };
-var error34 = (issue2) => {
+var error37 = (issue2) => {
   var _a, _b, _c, _d;
   switch (issue2.code) {
     case "invalid_type":
-      return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${parsedType34(issue2.input)}`;
+      return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${parsedType37(issue2.input)}`;
     case "invalid_value":
       if (issue2.values.length === 1)
         return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive(issue2.values[0])}`;
       return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`;
     case "too_big": {
       const adj = issue2.inclusive ? "<=" : "<";
-      const sizing = getSizing34(issue2.origin);
+      const sizing = getSizing37(issue2.origin);
       if (sizing)
         return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_a = issue2.origin) != null ? _a : "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()} ${(_b = sizing.unit) != null ? _b : "\u500B\u5143\u7D20"}`;
       return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_c = issue2.origin) != null ? _c : "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()}`;
     }
     case "too_small": {
       const adj = issue2.inclusive ? ">=" : ">";
-      const sizing = getSizing34(issue2.origin);
+      const sizing = getSizing37(issue2.origin);
       if (sizing) {
         return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
       }
@@ -7749,7 +8071,7 @@ var error34 = (issue2) => {
         return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
       if (_issue.format === "regex")
         return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
-      return `\u7121\u6548\u7684 ${(_d = Nouns34[_issue.format]) != null ? _d : issue2.format}`;
+      return `\u7121\u6548\u7684 ${(_d = Nouns37[_issue.format]) != null ? _d : issue2.format}`;
     }
     case "not_multiple_of":
       return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue2.divisor} \u7684\u500D\u6578`;
@@ -7765,9 +8087,9 @@ var error34 = (issue2) => {
       return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
   }
 };
-function zh_tw_default() {
+function zh_TW_default() {
   return {
-    localeError: error34
+    localeError: error37
   };
 }
 
@@ -8517,7 +8839,7 @@ function _refine(Class2, fn, _params = {}) {
 }
 function _stringbool(Classes, _params) {
   var _a, _b, _c;
-  const { case: _case, error: error35, truthy, falsy } = normalizeParams(_params);
+  const { case: _case, error: error38, truthy, falsy } = normalizeParams(_params);
   const trueValues = new Set(truthy != null ? truthy : ["true", "1", "yes", "on", "y", "enabled"]);
   const falseValues = new Set(falsy != null ? falsy : ["false", "0", "no", "off", "n", "disabled"]);
   const _Pipe = (_a = Classes.Pipe) != null ? _a : $ZodPipe;
@@ -8561,16 +8883,16 @@ function _stringbool(Classes, _params) {
         }
       }
     ],
-    error: error35
+    error: error38
   });
   return new _Pipe({
     type: "pipe",
     in: inst,
     out: new _Boolean({
       type: "boolean",
-      error: error35
+      error: error38
     }),
-    error: error35
+    error: error38
   });
 }
 
@@ -8835,7 +9157,9 @@ var JSONSchemaGenerator = class {
               return v.optout === void 0;
             }
           }));
-          json2.required = Array.from(requiredKeys);
+          if (requiredKeys.size > 0) {
+            json2.required = Array.from(requiredKeys);
+          }
           if (((_b = def.catchall) == null ? void 0 : _b._zod.def.type) === "never") {
             json2.additionalProperties = false;
           } else if (!def.catchall) {
@@ -9020,7 +9344,7 @@ var JSONSchemaGenerator = class {
           break;
         }
         case "pipe": {
-          const innerType = this.io === "input" ? def.in : def.out;
+          const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
           this.process(innerType, params);
           result.ref = innerType;
           break;
@@ -9062,11 +9386,9 @@ var JSONSchemaGenerator = class {
     const meta = this.metadataRegistry.get(schema);
     if (meta)
       Object.assign(result.schema, meta);
-    if (this.io === "input" && def.type === "pipe") {
+    if (this.io === "input" && isTransforming(schema)) {
       delete result.schema.examples;
       delete result.schema.default;
-      if (result.schema._prefault)
-        result.schema.default = result.schema._prefault;
     }
     if (this.io === "input" && result.schema._prefault)
       (_c = (_a = result.schema).default) != null ? _c : _a.default = result.schema._prefault;
@@ -9117,8 +9439,8 @@ var JSONSchemaGenerator = class {
       const schema2 = seen.schema;
       for (const key in schema2) {
         delete schema2[key];
-        schema2.$ref = ref;
       }
+      schema2.$ref = ref;
     };
     for (const entry of this.seen.entries()) {
       const seen = entry[1];
@@ -9159,7 +9481,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       var _a2, _b2;
       const seen = this.seen.get(zodSchema);
       const schema2 = (_a2 = seen.def) != null ? _a2 : seen.schema;
-      const _schema = __spreadValues({}, schema2);
+      const _cached = __spreadValues({}, schema2);
       if (seen.ref === null) {
         return;
       }
@@ -9173,7 +9495,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           schema2.allOf.push(refSchema);
         } else {
           Object.assign(schema2, refSchema);
-          Object.assign(schema2, _schema);
+          Object.assign(schema2, _cached);
         }
       }
       if (!seen.isParent)
@@ -9247,6 +9569,105 @@ function toJSONSchema(input, _params) {
   gen.process(input);
   return gen.emit(input, _params);
 }
+function isTransforming(_schema, _ctx) {
+  const ctx = _ctx != null ? _ctx : { seen: /* @__PURE__ */ new Set() };
+  if (ctx.seen.has(_schema))
+    return false;
+  ctx.seen.add(_schema);
+  const schema = _schema;
+  const def = schema._zod.def;
+  switch (def.type) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+    case "date":
+    case "symbol":
+    case "undefined":
+    case "null":
+    case "any":
+    case "unknown":
+    case "never":
+    case "void":
+    case "literal":
+    case "enum":
+    case "nan":
+    case "file":
+    case "template_literal":
+      return false;
+    case "array": {
+      return isTransforming(def.element, ctx);
+    }
+    case "object": {
+      for (const key in def.shape) {
+        if (isTransforming(def.shape[key], ctx))
+          return true;
+      }
+      return false;
+    }
+    case "union": {
+      for (const option of def.options) {
+        if (isTransforming(option, ctx))
+          return true;
+      }
+      return false;
+    }
+    case "intersection": {
+      return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    case "tuple": {
+      for (const item of def.items) {
+        if (isTransforming(item, ctx))
+          return true;
+      }
+      if (def.rest && isTransforming(def.rest, ctx))
+        return true;
+      return false;
+    }
+    case "record": {
+      return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    case "map": {
+      return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    case "set": {
+      return isTransforming(def.valueType, ctx);
+    }
+    // inner types
+    case "promise":
+    case "optional":
+    case "nonoptional":
+    case "nullable":
+    case "readonly":
+      return isTransforming(def.innerType, ctx);
+    case "lazy":
+      return isTransforming(def.getter(), ctx);
+    case "default": {
+      return isTransforming(def.innerType, ctx);
+    }
+    case "prefault": {
+      return isTransforming(def.innerType, ctx);
+    }
+    case "custom": {
+      return false;
+    }
+    case "transform": {
+      return true;
+    }
+    case "pipe": {
+      return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    case "success": {
+      return false;
+    }
+    case "catch": {
+      return false;
+    }
+    default:
+      def;
+  }
+  throw new Error(`Unknown schema type: ${def.type}`);
+}
 
 // node_modules/zod/dist/esm/v4/core/json-schema.js
 var json_schema_exports = {};