@reforma/components 0.1.6 → 0.2.1

package/dist/node_modules/zod/v4/classic/schemas.js

@@ -0,0 +1,822 @@
+import { objectProcessor as G, unionProcessor as K, recordProcessor as Y, enumProcessor as V, optionalProcessor as E, nonoptionalProcessor as X, numberProcessor as q, booleanProcessor as H, anyProcessor as Q, arrayProcessor as ee, stringProcessor as te, readonlyProcessor as re, pipeProcessor as ne, catchProcessor as oe, prefaultProcessor as ie, defaultProcessor as ce, transformProcessor as se, intersectionProcessor as ue, nullableProcessor as ae, aggregateChecks as d, customProcessor as he, unknownProcessor as de, neverProcessor as me } from "../core/json-schema-processors.js";
+import { createToJSONSchemaMethod as le, createStandardJSONSchemaMethod as S } from "../core/to-json-schema.js";
+import pe from "../locales/en.js";
+import { safeDecodeAsync as Ze, safeEncodeAsync as _e, safeDecode as fe, safeEncode as ye, decodeAsync as ke, encodeAsync as Se, decode as Ie, encode as Oe, safeParseAsync as Ne, safeParse as we, parseAsync as ge, parse as ve } from "./parse.js";
+import { normalizeParams as h, required as De, partial as I, omit as ze, pick as $e, merge as Pe, safeExtend as Te, extend as be, mergeDefs as m, installLazyProp as Ee, derived as U, own as O, hide as Ue, clone as xe, constantCatch as Je, shallowClone as x, issue as N } from "../core/util.js";
+import { _boolean as Ae, _any as Ce, _number as Re, _array as je, _string as Le, _isoDuration as Fe, _isoTime as Be, _isoDate as Me, _isoDateTime as We, _e164 as Ge, _cidrv6 as Ke, _cidrv4 as Ye, _ipv6 as Ve, _ipv4 as Xe, _ksuid as qe, _xid as He, _base64url as Qe, _base64 as et, _ulid as tt, _cuid2 as rt, _cuid as nt, _nanoid as ot, _uuidv7 as it, _uuidv6 as ct, _uuidv4 as st, _uuid as ut, _guid as at, _emoji as ht, _jwt as dt, _url as mt, _email as lt, _length as J, _maxLength as A, _minLength as Z, _overwrite as pt, _superRefine as Zt, _refine as _t, _slugify as ft, _toUpperCase as yt, _toLowerCase as kt, _normalize as St, _trim as It, _uppercase as Ot, _lowercase as Nt, _endsWith as wt, _startsWith as gt, _includes as vt, _regex as Dt, _multipleOf as w, _lte as f, _lt as g, _gte as y, _gt as v, _int as zt, _never as $t, _unknown as Pt } from "../core/api.js";
+import { $constructor as o, globalConfig as C, config as R, $ZodEncodeError as Tt } from "../core/core.js";
+import { $ZodObjectJIT as bt, $ZodUnion as Et, $ZodRecord as Ut, $ZodEnum as xt, $ZodOptional as Jt, $ZodExactOptional as At, $ZodNonOptional as Ct, $ZodString as j, $ZodNumber as Rt, $ZodBoolean as jt, $ZodAny as Lt, $ZodArray as Ft, $ZodType as Bt, $ZodReadonly as Mt, $ZodPipe as Wt, $ZodCatch as Gt, $ZodPrefault as Kt, $ZodDefault as Yt, $ZodTransform as Vt, $ZodIntersection as Xt, $ZodNullable as qt, standardProps as Ht, $ZodISODateTime as Qt, $ZodISODate as er, $ZodISOTime as tr, $ZodISODuration as rr, $ZodEmail as nr, $ZodGUID as or, $ZodUUID as ir, $ZodURL as cr, $ZodEmoji as sr, $ZodNanoID as ur, $ZodCUID as ar, $ZodCUID2 as hr, $ZodULID as dr, $ZodXID as mr, $ZodKSUID as lr, $ZodIPv4 as pr, $ZodIPv6 as Zr, $ZodCIDRv4 as _r, $ZodCIDRv6 as fr, $ZodBase64 as yr, $ZodBase64URL as kr, $ZodE164 as Sr, $ZodJWT as Ir, $ZodStringFormat as Or, $ZodCustom as Nr, $ZodNumberFormat as wr, $ZodUnknown as gr, $ZodNever as vr } from "../core/schemas.js";
+import { globalRegistry as l } from "../core/registries.js";
+import { validateAsync as Dr, validate as zr } from "../core/parse.js";
+import { memoizer as $r } from "../core/memoizer.js";
+function Pr() {
+  C.localeError || R(pe());
+}
+function _() {
+  C.memoizer || R({ memoizer: $r() });
+}
+const c = /* @__PURE__ */ o("ZodType", (e, t) => (Pr(), Bt.init(e, t), e.def = t, e.type = t.type, e), {
+  check(...e) {
+    const t = this.def;
+    return this.clone(m(t, {
+      checks: [
+        ...t.checks ?? [],
+        ...e.map((r) => typeof r == "function" ? { _zod: { check: r, def: { check: "custom" }, onattach: [] } } : r)
+      ]
+    }), { parent: !0 });
+  },
+  with(...e) {
+    return this.check(...e);
+  },
+  clone(e, t) {
+    return xe(this, e, t);
+  },
+  brand() {
+    return this;
+  },
+  register(e, t) {
+    return e.add(this, t), this;
+  },
+  refine(e, t) {
+    return this.check(Tn(e, t));
+  },
+  superRefine(e, t) {
+    return this.check(bn(e, t));
+  },
+  overwrite(e) {
+    return this.check(pt(e));
+  },
+  optional() {
+    return P(this);
+  },
+  exactOptional() {
+    return yn(this);
+  },
+  nullable() {
+    return T(this);
+  },
+  nullish() {
+    return P(T(this));
+  },
+  nonoptional(e) {
+    return wn(this, e);
+  },
+  array() {
+    return an(this);
+  },
+  or(e) {
+    return mn([this, e]);
+  },
+  and(e) {
+    return pn(this, e);
+  },
+  transform(e) {
+    return b(this, fn(e));
+  },
+  default(e) {
+    return In(this, e);
+  },
+  prefault(e) {
+    return Nn(this, e);
+  },
+  catch(e) {
+    return vn(this, e);
+  },
+  pipe(e) {
+    return b(this, e);
+  },
+  readonly() {
+    return $n(this);
+  },
+  describe(e) {
+    const t = this.clone();
+    return l.add(t, { description: e }), t;
+  },
+  meta(...e) {
+    if (e.length === 0)
+      return l.get(this);
+    const t = this.clone();
+    return l.add(t, e[0]), t;
+  },
+  isOptional() {
+    return this.safeParse(void 0).success;
+  },
+  isNullable() {
+    return this.safeParse(null).success;
+  },
+  apply(e, ...t) {
+    return t.length === 0 ? e(this) : e(this, ...t);
+  },
+  // Overrides core's `~standard` to add `jsonSchema`. Must stay a prototype entry: redefining it per instance demotes instances to dictionary mode.
+  get "~standard"() {
+    return Ue(this, "~standard", {
+      ...Ht(this),
+      jsonSchema: {
+        input: S(this, "input"),
+        output: S(this, "output")
+      }
+    });
+  },
+  set "~standard"(e) {
+    O(this, "~standard", e);
+  },
+  parse: function e(t, r) {
+    return ve(this, t, r, { callee: e });
+  },
+  parseAsync: async function e(t, r) {
+    return await ge(this, t, r, { callee: e });
+  },
+  safeParse(e, t) {
+    return we(this, e, t);
+  },
+  async safeParseAsync(e, t) {
+    return Ne(this, e, t);
+  },
+  // `spa` is an alias: same function object as `safeParseAsync`, as before.
+  get spa() {
+    return this?.safeParseAsync;
+  },
+  set spa(e) {
+    O(this, "spa", e);
+  },
+  validate(e, t) {
+    return zr(this, e, t);
+  },
+  validateAsync(e, t) {
+    return Dr(this, e, t);
+  },
+  encode: function e(t, r) {
+    return Oe(this, t, r, { callee: e });
+  },
+  decode: function e(t, r) {
+    return Ie(this, t, r, { callee: e });
+  },
+  encodeAsync: async function e(t, r) {
+    return await Se(this, t, r, { callee: e });
+  },
+  decodeAsync: async function e(t, r) {
+    return await ke(this, t, r, { callee: e });
+  },
+  safeEncode(e, t) {
+    return ye(this, e, t);
+  },
+  safeDecode(e, t) {
+    return fe(this, e, t);
+  },
+  async safeEncodeAsync(e, t) {
+    return _e(this, e, t);
+  },
+  async safeDecodeAsync(e, t) {
+    return Ze(this, e, t);
+  },
+  toJSONSchema(e) {
+    return le(this, {})(e);
+  },
+  // Reads through to the registry on every access, so it must not cache.
+  get description() {
+    return l.get(this)?.description;
+  },
+  // No setter: `schema._def = x` throws, as it did when `_def` was a non-writable own property.
+  get _def() {
+    return this._zod.def;
+  }
+}), L = /* @__PURE__ */ o(
+  "_ZodString",
+  (e, t) => {
+    j.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => te(e, r, n);
+  },
+  /* @__PURE__ */ U({
+    format: (e) => d(e).format ?? null,
+    minLength: (e) => d(e).minimum ?? null,
+    maxLength: (e) => d(e).maximum ?? null
+  }, {
+    regex(...e) {
+      return this.check(Dt(...e));
+    },
+    includes(...e) {
+      return this.check(vt(...e));
+    },
+    startsWith(...e) {
+      return this.check(gt(...e));
+    },
+    endsWith(...e) {
+      return this.check(wt(...e));
+    },
+    min(...e) {
+      return this.check(Z(...e));
+    },
+    max(...e) {
+      return this.check(A(...e));
+    },
+    length(...e) {
+      return this.check(J(...e));
+    },
+    nonempty(...e) {
+      return this.check(Z(1, ...e));
+    },
+    lowercase(e) {
+      return this.check(Nt(e));
+    },
+    uppercase(e) {
+      return this.check(Ot(e));
+    },
+    trim() {
+      return this.check(It());
+    },
+    normalize(...e) {
+      return this.check(St(...e));
+    },
+    toLowerCase() {
+      return this.check(kt());
+    },
+    toUpperCase() {
+      return this.check(yt());
+    },
+    slugify() {
+      return this.check(ft());
+    }
+  })
+), Tr = /* @__PURE__ */ o("ZodString", (e, t) => {
+  j.init(e, t), L.init(e, t);
+}, {
+  email(e) {
+    return this.check(lt(Ar, e));
+  },
+  url(e) {
+    return this.check(mt(Rr, e));
+  },
+  jwt(e) {
+    return this.check(dt(en, e));
+  },
+  emoji(e) {
+    return this.check(ht(jr, e));
+  },
+  guid(e) {
+    return this.check(at(Cr, e));
+  },
+  uuid(e) {
+    return this.check(ut(p, e));
+  },
+  uuidv4(e) {
+    return this.check(st(p, e));
+  },
+  uuidv6(e) {
+    return this.check(ct(p, e));
+  },
+  uuidv7(e) {
+    return this.check(it(p, e));
+  },
+  nanoid(e) {
+    return this.check(ot(Lr, e));
+  },
+  cuid(e) {
+    return this.check(nt(Fr, e));
+  },
+  cuid2(e) {
+    return this.check(rt(Br, e));
+  },
+  ulid(e) {
+    return this.check(tt(Mr, e));
+  },
+  base64(e) {
+    return this.check(et(qr, e));
+  },
+  base64url(e) {
+    return this.check(Qe(Hr, e));
+  },
+  xid(e) {
+    return this.check(He(Wr, e));
+  },
+  ksuid(e) {
+    return this.check(qe(Gr, e));
+  },
+  ipv4(e) {
+    return this.check(Xe(Kr, e));
+  },
+  ipv6(e) {
+    return this.check(Ve(Yr, e));
+  },
+  cidrv4(e) {
+    return this.check(Ye(Vr, e));
+  },
+  cidrv6(e) {
+    return this.check(Ke(Xr, e));
+  },
+  e164(e) {
+    return this.check(Ge(Qr, e));
+  },
+  datetime(e) {
+    return this.check(We(Er, e));
+  },
+  date(e) {
+    return this.check(Me(Ur, e));
+  },
+  time(e) {
+    return this.check(Be(xr, e));
+  },
+  duration(e) {
+    return this.check(Fe(Jr, e));
+  }
+});
+function br(e) {
+  return Le(Tr, e);
+}
+const s = /* @__PURE__ */ o("ZodStringFormat", (e, t) => {
+  Or.init(e, t), L.init(e, t);
+}), Er = /* @__PURE__ */ o("ZodISODateTime", (e, t) => {
+  Qt.init(e, t), s.init(e, t);
+}), Ur = /* @__PURE__ */ o("ZodISODate", (e, t) => {
+  er.init(e, t), s.init(e, t);
+}), xr = /* @__PURE__ */ o("ZodISOTime", (e, t) => {
+  tr.init(e, t), s.init(e, t);
+}), Jr = /* @__PURE__ */ o("ZodISODuration", (e, t) => {
+  rr.init(e, t), s.init(e, t);
+}), Ar = /* @__PURE__ */ o("ZodEmail", (e, t) => {
+  nr.init(e, t), s.init(e, t);
+}), Cr = /* @__PURE__ */ o("ZodGUID", (e, t) => {
+  or.init(e, t), s.init(e, t);
+}), p = /* @__PURE__ */ o("ZodUUID", (e, t) => {
+  ir.init(e, t), s.init(e, t);
+}), Rr = /* @__PURE__ */ o("ZodURL", (e, t) => {
+  cr.init(e, t), s.init(e, t);
+}), jr = /* @__PURE__ */ o("ZodEmoji", (e, t) => {
+  sr.init(e, t), s.init(e, t);
+}), Lr = /* @__PURE__ */ o("ZodNanoID", (e, t) => {
+  ur.init(e, t), s.init(e, t);
+}), Fr = /* @__PURE__ */ o("ZodCUID", (e, t) => {
+  ar.init(e, t), s.init(e, t);
+}), Br = /* @__PURE__ */ o("ZodCUID2", (e, t) => {
+  hr.init(e, t), s.init(e, t);
+}), Mr = /* @__PURE__ */ o("ZodULID", (e, t) => {
+  dr.init(e, t), s.init(e, t);
+}), Wr = /* @__PURE__ */ o("ZodXID", (e, t) => {
+  mr.init(e, t), s.init(e, t);
+}), Gr = /* @__PURE__ */ o("ZodKSUID", (e, t) => {
+  lr.init(e, t), s.init(e, t);
+}), Kr = /* @__PURE__ */ o("ZodIPv4", (e, t) => {
+  pr.init(e, t), s.init(e, t);
+}), Yr = /* @__PURE__ */ o("ZodIPv6", (e, t) => {
+  Zr.init(e, t), s.init(e, t);
+}), Vr = /* @__PURE__ */ o("ZodCIDRv4", (e, t) => {
+  _r.init(e, t), s.init(e, t);
+}), Xr = /* @__PURE__ */ o("ZodCIDRv6", (e, t) => {
+  fr.init(e, t), s.init(e, t);
+}), qr = /* @__PURE__ */ o("ZodBase64", (e, t) => {
+  yr.init(e, t), s.init(e, t);
+}), Hr = /* @__PURE__ */ o("ZodBase64URL", (e, t) => {
+  kr.init(e, t), s.init(e, t);
+}), Qr = /* @__PURE__ */ o("ZodE164", (e, t) => {
+  Sr.init(e, t), s.init(e, t);
+}), en = /* @__PURE__ */ o("ZodJWT", (e, t) => {
+  Ir.init(e, t), s.init(e, t);
+}), F = /* @__PURE__ */ o(
+  "ZodNumber",
+  (e, t) => {
+    Rt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => q(e, r, n, i), e.isFinite = !0;
+  },
+  /* @__PURE__ */ U({
+    minValue: (e) => {
+      const { minimum: t, exclusiveMinimum: r } = d(e);
+      return Math.max(t ?? Number.NEGATIVE_INFINITY, r ?? Number.NEGATIVE_INFINITY);
+    },
+    maxValue: (e) => {
+      const { maximum: t, exclusiveMaximum: r } = d(e);
+      return Math.min(t ?? Number.POSITIVE_INFINITY, r ?? Number.POSITIVE_INFINITY);
+    },
+    isInt: (e) => {
+      const { isInt: t, multipleOf: r } = d(e);
+      return !!t || !!r?.some(Number.isSafeInteger);
+    },
+    format: (e) => d(e).format ?? null
+  }, {
+    gt(e, t) {
+      return this.check(v(e, t));
+    },
+    gte(e, t) {
+      return this.check(y(e, t));
+    },
+    min(e, t) {
+      return this.check(y(e, t));
+    },
+    lt(e, t) {
+      return this.check(g(e, t));
+    },
+    lte(e, t) {
+      return this.check(f(e, t));
+    },
+    max(e, t) {
+      return this.check(f(e, t));
+    },
+    int(e) {
+      return this.check(D(e));
+    },
+    safe(e) {
+      return this.check(D(e));
+    },
+    positive(e) {
+      return this.check(v(0, e));
+    },
+    nonnegative(e) {
+      return this.check(y(0, e));
+    },
+    negative(e) {
+      return this.check(g(0, e));
+    },
+    nonpositive(e) {
+      return this.check(f(0, e));
+    },
+    multipleOf(e, t) {
+      return this.check(w(e, t));
+    },
+    step(e, t) {
+      return this.check(w(e, t));
+    },
+    finite() {
+      return this;
+    }
+  })
+);
+function Mn(e) {
+  return Re(F, e);
+}
+const tn = /* @__PURE__ */ o("ZodNumberFormat", (e, t) => {
+  wr.init(e, t), F.init(e, t);
+});
+function D(e) {
+  return zt(tn, e);
+}
+const rn = /* @__PURE__ */ o("ZodBoolean", (e, t) => {
+  jt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => H(e, r, n);
+});
+function Wn(e) {
+  return Ae(rn, e);
+}
+const nn = /* @__PURE__ */ o("ZodAny", (e, t) => {
+  Lt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => Q();
+});
+function Gn() {
+  return Ce(nn);
+}
+const on = /* @__PURE__ */ o("ZodUnknown", (e, t) => {
+  gr.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => de();
+});
+function z() {
+  return Pt(on);
+}
+const cn = /* @__PURE__ */ o("ZodNever", (e, t) => {
+  vr.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => me(e, r, n);
+});
+function sn(e) {
+  return $t(cn, e);
+}
+const un = /* @__PURE__ */ o("ZodArray", (e, t) => {
+  _(), Ft.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => ee(e, r, n, i), e.element = t.element;
+}, {
+  min(e, t) {
+    return this.check(Z(e, t));
+  },
+  nonempty(e) {
+    return this.check(Z(1, e));
+  },
+  max(e, t) {
+    return this.check(A(e, t));
+  },
+  length(e, t) {
+    return this.check(J(e, t));
+  },
+  unwrap() {
+    return this.element;
+  }
+});
+function an(e, t) {
+  return je(un, e, t);
+}
+const hn = /* @__PURE__ */ o("ZodObject", (e, t) => {
+  _(), bt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => G(e, r, n, i), Ee(e, "shape", (r) => r._zod.def.shape, !1);
+}, {
+  keyof() {
+    return Zn(Object.keys(this._zod.def.shape));
+  },
+  catchall(e) {
+    return this.clone(m(this._zod.def, { catchall: e }));
+  },
+  passthrough() {
+    return this.clone(m(this._zod.def, { catchall: z() }));
+  },
+  loose() {
+    return this.clone(m(this._zod.def, { catchall: z() }));
+  },
+  strict() {
+    return this.clone(m(this._zod.def, { catchall: sn() }));
+  },
+  strip() {
+    return this.clone(m(this._zod.def, { catchall: void 0 }));
+  },
+  extend(e) {
+    return be(this, e);
+  },
+  safeExtend(e) {
+    return Te(this, e);
+  },
+  merge(e) {
+    return Pe(this, e);
+  },
+  pick(e) {
+    return $e(this, e);
+  },
+  omit(e) {
+    return ze(this, e);
+  },
+  partial(...e) {
+    return I(B, this, e[0]);
+  },
+  exactPartial(...e) {
+    return I(M, this, e[0], "exactPartial");
+  },
+  required(...e) {
+    return De(W, this, e[0]);
+  }
+});
+function Kn(e, t) {
+  const r = {
+    type: "object",
+    shape: e ?? {},
+    ...h(t)
+  };
+  return new hn(r);
+}
+const dn = /* @__PURE__ */ o("ZodUnion", (e, t) => {
+  Et.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => K(e, r, n, i), e.options = t.options;
+});
+function mn(e, t) {
+  return new dn({
+    type: "union",
+    options: e,
+    ...h(t)
+  });
+}
+const ln = /* @__PURE__ */ o("ZodIntersection", (e, t) => {
+  Xt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => ue(e, r, n, i);
+});
+function pn(e, t) {
+  return new ln({
+    type: "intersection",
+    left: e,
+    right: t
+  });
+}
+const $ = /* @__PURE__ */ o("ZodRecord", (e, t) => {
+  _(), Ut.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => Y(e, r, n, i), e.keyType = t.keyType, e.valueType = t.valueType;
+});
+function Yn(e, t, r) {
+  return !t || !t._zod ? new $({
+    type: "record",
+    keyType: br(),
+    valueType: e,
+    ...h(t)
+  }) : new $({
+    type: "record",
+    keyType: e,
+    valueType: t,
+    ...h(r)
+  });
+}
+const k = /* @__PURE__ */ o("ZodEnum", (e, t) => {
+  xt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (n, i, a) => V(e, n, i), e.enum = t.entries, e.options = [...e._zod.values];
+  const r = new Set(Object.keys(t.entries));
+  e.extract = (n, i) => {
+    const a = {};
+    for (const u of n)
+      if (r.has(u))
+        a[u] = t.entries[u];
+      else
+        throw new Error(`Key ${u} not found in enum`);
+    return new k({
+      ...t,
+      checks: [],
+      ...h(i),
+      entries: a
+    });
+  }, e.exclude = (n, i) => {
+    const a = { ...t.entries };
+    for (const u of n)
+      if (r.has(u))
+        delete a[u];
+      else
+        throw new Error(`Key ${u} not found in enum`);
+    return new k({
+      ...t,
+      checks: [],
+      ...h(i),
+      entries: a
+    });
+  };
+});
+function Zn(e, t) {
+  const r = Array.isArray(e) ? Object.fromEntries(e.map((n) => [n, n])) : e;
+  return new k({
+    type: "enum",
+    entries: r,
+    ...h(t)
+  });
+}
+const _n = /* @__PURE__ */ o("ZodTransform", (e, t) => {
+  _(), Vt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => se(e, r, n, i), e._zod.parse = (r, n) => {
+    if (n.direction === "backward")
+      throw new Tt(e.constructor.name);
+    r.addIssue = (a) => {
+      if (typeof a == "string")
+        r.issues.push(N(a, r.value, t));
+      else {
+        const u = a;
+        u.fatal && (u.continue = !1), u.code ?? (u.code = "custom"), "input" in u || (u.input = r.value), u.inst ?? (u.inst = e), r.issues.push(N(u));
+      }
+    };
+    const i = t.transform(r.value, r);
+    return i instanceof Promise ? i.then((a) => (r.value = a, r)) : (r.value = i, r);
+  };
+});
+function fn(e) {
+  return new _n({
+    type: "transform",
+    transform: e
+  });
+}
+const B = /* @__PURE__ */ o("ZodOptional", (e, t) => {
+  Jt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => E(e, r, n, i), e.unwrap = () => e._zod.def.innerType;
+});
+function P(e) {
+  return new B({
+    type: "optional",
+    innerType: e
+  });
+}
+const M = /* @__PURE__ */ o("ZodExactOptional", (e, t) => {
+  At.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => E(e, r, n, i), e.unwrap = () => e._zod.def.innerType;
+});
+function yn(e) {
+  return new M({
+    type: "optional",
+    innerType: e
+  });
+}
+const kn = /* @__PURE__ */ o("ZodNullable", (e, t) => {
+  qt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => ae(e, r, n, i), e.unwrap = () => e._zod.def.innerType;
+});
+function T(e) {
+  return new kn({
+    type: "nullable",
+    innerType: e
+  });
+}
+const Sn = /* @__PURE__ */ o("ZodDefault", (e, t) => {
+  Yt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => ce(e, r, n, i), e.unwrap = () => e._zod.def.innerType, e.removeDefault = e.unwrap;
+});
+function In(e, t) {
+  return new Sn({
+    type: "default",
+    innerType: e,
+    get defaultValue() {
+      return typeof t == "function" ? t() : x(t);
+    }
+  });
+}
+const On = /* @__PURE__ */ o("ZodPrefault", (e, t) => {
+  Kt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => ie(e, r, n, i), e.unwrap = () => e._zod.def.innerType;
+});
+function Nn(e, t) {
+  return new On({
+    type: "prefault",
+    innerType: e,
+    get defaultValue() {
+      return typeof t == "function" ? t() : x(t);
+    }
+  });
+}
+const W = /* @__PURE__ */ o("ZodNonOptional", (e, t) => {
+  Ct.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => X(e, r, n, i), e.unwrap = () => e._zod.def.innerType;
+});
+function wn(e, t) {
+  return new W({
+    type: "nonoptional",
+    innerType: e,
+    ...h(t)
+  });
+}
+const gn = /* @__PURE__ */ o("ZodCatch", (e, t) => {
+  Gt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => oe(e, r, n, i), e.unwrap = () => e._zod.def.innerType, e.removeCatch = e.unwrap;
+});
+function vn(e, t) {
+  return new gn({
+    type: "catch",
+    innerType: e,
+    catchValue: typeof t == "function" ? t : Je(t)
+  });
+}
+const Dn = /* @__PURE__ */ o("ZodPipe", (e, t) => {
+  Wt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => ne(e, r, n, i), e.in = t.in, e.out = t.out;
+});
+function b(e, t) {
+  return new Dn({
+    type: "pipe",
+    in: e,
+    out: t
+    // ...util.normalizeParams(params),
+  });
+}
+const zn = /* @__PURE__ */ o("ZodReadonly", (e, t) => {
+  Mt.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => re(e, r, n, i), e.unwrap = () => e._zod.def.innerType;
+});
+function $n(e) {
+  return new zn({
+    type: "readonly",
+    innerType: e
+  });
+}
+const Pn = /* @__PURE__ */ o("ZodCustom", (e, t) => {
+  Nr.init(e, t), c.init(e, t), e._zod.processJSONSchema = (r, n, i) => he(e, r, n, i);
+});
+function Tn(e, t = {}) {
+  return _t(Pn, e, t);
+}
+function bn(e, t) {
+  return Zt(e, t);
+}
+export {
+  nn as ZodAny,
+  un as ZodArray,
+  qr as ZodBase64,
+  Hr as ZodBase64URL,
+  rn as ZodBoolean,
+  Vr as ZodCIDRv4,
+  Xr as ZodCIDRv6,
+  Fr as ZodCUID,
+  Br as ZodCUID2,
+  gn as ZodCatch,
+  Pn as ZodCustom,
+  Sn as ZodDefault,
+  Qr as ZodE164,
+  Ar as ZodEmail,
+  jr as ZodEmoji,
+  k as ZodEnum,
+  M as ZodExactOptional,
+  Cr as ZodGUID,
+  Kr as ZodIPv4,
+  Yr as ZodIPv6,
+  Ur as ZodISODate,
+  Er as ZodISODateTime,
+  Jr as ZodISODuration,
+  xr as ZodISOTime,
+  ln as ZodIntersection,
+  en as ZodJWT,
+  Gr as ZodKSUID,
+  Lr as ZodNanoID,
+  cn as ZodNever,
+  W as ZodNonOptional,
+  kn as ZodNullable,
+  F as ZodNumber,
+  tn as ZodNumberFormat,
+  hn as ZodObject,
+  B as ZodOptional,
+  Dn as ZodPipe,
+  On as ZodPrefault,
+  zn as ZodReadonly,
+  $ as ZodRecord,
+  Tr as ZodString,
+  s as ZodStringFormat,
+  _n as ZodTransform,
+  c as ZodType,
+  Mr as ZodULID,
+  Rr as ZodURL,
+  p as ZodUUID,
+  dn as ZodUnion,
+  on as ZodUnknown,
+  Wr as ZodXID,
+  L as _ZodString,
+  In as _default,
+  Gn as any,
+  an as array,
+  Wn as boolean,
+  vn as catch,
+  Zn as enum,
+  yn as exactOptional,
+  D as int,
+  pn as intersection,
+  sn as never,
+  wn as nonoptional,
+  T as nullable,
+  Mn as number,
+  Kn as object,
+  P as optional,
+  b as pipe,
+  Nn as prefault,
+  $n as readonly,
+  Yn as record,
+  Tn as refine,
+  br as string,
+  bn as superRefine,
+  fn as transform,
+  mn as union,
+  z as unknown
+};
+//# sourceMappingURL=schemas.js.map