@athenaintel/react 0.19.0 → 0.21.0

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

@@ -0,0 +1,871 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsonSchemaProcessors = require("../core/json-schema-processors.cjs");
+const toJsonSchema = require("../core/to-json-schema.cjs");
+const iso = require("./iso.cjs");
+const parse = require("./parse.cjs");
+const util = require("../core/util.cjs");
+const api = require("../core/api.cjs");
+const core = require("../core/core.cjs");
+const schemas = require("../core/schemas.cjs");
+const registries = require("../core/registries.cjs");
+const _installedGroups = /* @__PURE__ */ new WeakMap();
+function _installLazyMethods(inst, group, methods) {
+  const proto = Object.getPrototypeOf(inst);
+  let installed = _installedGroups.get(proto);
+  if (!installed) {
+    installed = /* @__PURE__ */ new Set();
+    _installedGroups.set(proto, installed);
+  }
+  if (installed.has(group))
+    return;
+  installed.add(group);
+  for (const key in methods) {
+    const fn = methods[key];
+    Object.defineProperty(proto, key, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        const bound = fn.bind(this);
+        Object.defineProperty(this, key, {
+          configurable: true,
+          writable: true,
+          enumerable: true,
+          value: bound
+        });
+        return bound;
+      },
+      set(v) {
+        Object.defineProperty(this, key, {
+          configurable: true,
+          writable: true,
+          enumerable: true,
+          value: v
+        });
+      }
+    });
+  }
+}
+const ZodType = /* @__PURE__ */ core.$constructor("ZodType", (inst, def) => {
+  schemas.$ZodType.init(inst, def);
+  Object.assign(inst["~standard"], {
+    jsonSchema: {
+      input: toJsonSchema.createStandardJSONSchemaMethod(inst, "input"),
+      output: toJsonSchema.createStandardJSONSchemaMethod(inst, "output")
+    }
+  });
+  inst.toJSONSchema = toJsonSchema.createToJSONSchemaMethod(inst, {});
+  inst.def = def;
+  inst.type = def.type;
+  Object.defineProperty(inst, "_def", { value: def });
+  inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
+  inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
+  inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
+  inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
+  inst.spa = inst.safeParseAsync;
+  inst.encode = (data, params) => parse.encode(inst, data, params);
+  inst.decode = (data, params) => parse.decode(inst, data, params);
+  inst.encodeAsync = async (data, params) => parse.encodeAsync(inst, data, params);
+  inst.decodeAsync = async (data, params) => parse.decodeAsync(inst, data, params);
+  inst.safeEncode = (data, params) => parse.safeEncode(inst, data, params);
+  inst.safeDecode = (data, params) => parse.safeDecode(inst, data, params);
+  inst.safeEncodeAsync = async (data, params) => parse.safeEncodeAsync(inst, data, params);
+  inst.safeDecodeAsync = async (data, params) => parse.safeDecodeAsync(inst, data, params);
+  _installLazyMethods(inst, "ZodType", {
+    check(...chks) {
+      const def2 = this.def;
+      return this.clone(util.mergeDefs(def2, {
+        checks: [
+          ...def2.checks ?? [],
+          ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+        ]
+      }), { parent: true });
+    },
+    with(...chks) {
+      return this.check(...chks);
+    },
+    clone(def2, params) {
+      return util.clone(this, def2, params);
+    },
+    brand() {
+      return this;
+    },
+    register(reg, meta) {
+      reg.add(this, meta);
+      return this;
+    },
+    refine(check, params) {
+      return this.check(refine(check, params));
+    },
+    superRefine(refinement, params) {
+      return this.check(superRefine(refinement, params));
+    },
+    overwrite(fn) {
+      return this.check(api._overwrite(fn));
+    },
+    optional() {
+      return optional(this);
+    },
+    exactOptional() {
+      return exactOptional(this);
+    },
+    nullable() {
+      return nullable(this);
+    },
+    nullish() {
+      return optional(nullable(this));
+    },
+    nonoptional(params) {
+      return nonoptional(this, params);
+    },
+    array() {
+      return array(this);
+    },
+    or(arg) {
+      return union([this, arg]);
+    },
+    and(arg) {
+      return intersection(this, arg);
+    },
+    transform(tx) {
+      return pipe(this, transform(tx));
+    },
+    default(d) {
+      return _default(this, d);
+    },
+    prefault(d) {
+      return prefault(this, d);
+    },
+    catch(params) {
+      return _catch(this, params);
+    },
+    pipe(target) {
+      return pipe(this, target);
+    },
+    readonly() {
+      return readonly(this);
+    },
+    describe(description) {
+      const cl = this.clone();
+      registries.globalRegistry.add(cl, { description });
+      return cl;
+    },
+    meta(...args) {
+      if (args.length === 0)
+        return registries.globalRegistry.get(this);
+      const cl = this.clone();
+      registries.globalRegistry.add(cl, args[0]);
+      return cl;
+    },
+    isOptional() {
+      return this.safeParse(void 0).success;
+    },
+    isNullable() {
+      return this.safeParse(null).success;
+    },
+    apply(fn) {
+      return fn(this);
+    }
+  });
+  Object.defineProperty(inst, "description", {
+    get() {
+      var _a;
+      return (_a = registries.globalRegistry.get(inst)) == null ? void 0 : _a.description;
+    },
+    configurable: true
+  });
+  return inst;
+});
+const _ZodString = /* @__PURE__ */ core.$constructor("_ZodString", (inst, def) => {
+  schemas.$ZodString.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.stringProcessor(inst, ctx, json);
+  const bag = inst._zod.bag;
+  inst.format = bag.format ?? null;
+  inst.minLength = bag.minimum ?? null;
+  inst.maxLength = bag.maximum ?? null;
+  _installLazyMethods(inst, "_ZodString", {
+    regex(...args) {
+      return this.check(api._regex(...args));
+    },
+    includes(...args) {
+      return this.check(api._includes(...args));
+    },
+    startsWith(...args) {
+      return this.check(api._startsWith(...args));
+    },
+    endsWith(...args) {
+      return this.check(api._endsWith(...args));
+    },
+    min(...args) {
+      return this.check(api._minLength(...args));
+    },
+    max(...args) {
+      return this.check(api._maxLength(...args));
+    },
+    length(...args) {
+      return this.check(api._length(...args));
+    },
+    nonempty(...args) {
+      return this.check(api._minLength(1, ...args));
+    },
+    lowercase(params) {
+      return this.check(api._lowercase(params));
+    },
+    uppercase(params) {
+      return this.check(api._uppercase(params));
+    },
+    trim() {
+      return this.check(api._trim());
+    },
+    normalize(...args) {
+      return this.check(api._normalize(...args));
+    },
+    toLowerCase() {
+      return this.check(api._toLowerCase());
+    },
+    toUpperCase() {
+      return this.check(api._toUpperCase());
+    },
+    slugify() {
+      return this.check(api._slugify());
+    }
+  });
+});
+const ZodString = /* @__PURE__ */ core.$constructor("ZodString", (inst, def) => {
+  schemas.$ZodString.init(inst, def);
+  _ZodString.init(inst, def);
+  inst.email = (params) => inst.check(api._email(ZodEmail, params));
+  inst.url = (params) => inst.check(api._url(ZodURL, params));
+  inst.jwt = (params) => inst.check(api._jwt(ZodJWT, params));
+  inst.emoji = (params) => inst.check(api._emoji(ZodEmoji, params));
+  inst.guid = (params) => inst.check(api._guid(ZodGUID, params));
+  inst.uuid = (params) => inst.check(api._uuid(ZodUUID, params));
+  inst.uuidv4 = (params) => inst.check(api._uuidv4(ZodUUID, params));
+  inst.uuidv6 = (params) => inst.check(api._uuidv6(ZodUUID, params));
+  inst.uuidv7 = (params) => inst.check(api._uuidv7(ZodUUID, params));
+  inst.nanoid = (params) => inst.check(api._nanoid(ZodNanoID, params));
+  inst.guid = (params) => inst.check(api._guid(ZodGUID, params));
+  inst.cuid = (params) => inst.check(api._cuid(ZodCUID, params));
+  inst.cuid2 = (params) => inst.check(api._cuid2(ZodCUID2, params));
+  inst.ulid = (params) => inst.check(api._ulid(ZodULID, params));
+  inst.base64 = (params) => inst.check(api._base64(ZodBase64, params));
+  inst.base64url = (params) => inst.check(api._base64url(ZodBase64URL, params));
+  inst.xid = (params) => inst.check(api._xid(ZodXID, params));
+  inst.ksuid = (params) => inst.check(api._ksuid(ZodKSUID, params));
+  inst.ipv4 = (params) => inst.check(api._ipv4(ZodIPv4, params));
+  inst.ipv6 = (params) => inst.check(api._ipv6(ZodIPv6, params));
+  inst.cidrv4 = (params) => inst.check(api._cidrv4(ZodCIDRv4, params));
+  inst.cidrv6 = (params) => inst.check(api._cidrv6(ZodCIDRv6, params));
+  inst.e164 = (params) => inst.check(api._e164(ZodE164, params));
+  inst.datetime = (params) => inst.check(iso.datetime(params));
+  inst.date = (params) => inst.check(iso.date(params));
+  inst.time = (params) => inst.check(iso.time(params));
+  inst.duration = (params) => inst.check(iso.duration(params));
+});
+function string(params) {
+  return api._string(ZodString, params);
+}
+const ZodStringFormat = /* @__PURE__ */ core.$constructor("ZodStringFormat", (inst, def) => {
+  schemas.$ZodStringFormat.init(inst, def);
+  _ZodString.init(inst, def);
+});
+const ZodEmail = /* @__PURE__ */ core.$constructor("ZodEmail", (inst, def) => {
+  schemas.$ZodEmail.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodGUID = /* @__PURE__ */ core.$constructor("ZodGUID", (inst, def) => {
+  schemas.$ZodGUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodUUID = /* @__PURE__ */ core.$constructor("ZodUUID", (inst, def) => {
+  schemas.$ZodUUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodURL = /* @__PURE__ */ core.$constructor("ZodURL", (inst, def) => {
+  schemas.$ZodURL.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodEmoji = /* @__PURE__ */ core.$constructor("ZodEmoji", (inst, def) => {
+  schemas.$ZodEmoji.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodNanoID = /* @__PURE__ */ core.$constructor("ZodNanoID", (inst, def) => {
+  schemas.$ZodNanoID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodCUID = /* @__PURE__ */ core.$constructor("ZodCUID", (inst, def) => {
+  schemas.$ZodCUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodCUID2 = /* @__PURE__ */ core.$constructor("ZodCUID2", (inst, def) => {
+  schemas.$ZodCUID2.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodULID = /* @__PURE__ */ core.$constructor("ZodULID", (inst, def) => {
+  schemas.$ZodULID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodXID = /* @__PURE__ */ core.$constructor("ZodXID", (inst, def) => {
+  schemas.$ZodXID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodKSUID = /* @__PURE__ */ core.$constructor("ZodKSUID", (inst, def) => {
+  schemas.$ZodKSUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodIPv4 = /* @__PURE__ */ core.$constructor("ZodIPv4", (inst, def) => {
+  schemas.$ZodIPv4.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodIPv6 = /* @__PURE__ */ core.$constructor("ZodIPv6", (inst, def) => {
+  schemas.$ZodIPv6.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv4 = /* @__PURE__ */ core.$constructor("ZodCIDRv4", (inst, def) => {
+  schemas.$ZodCIDRv4.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv6 = /* @__PURE__ */ core.$constructor("ZodCIDRv6", (inst, def) => {
+  schemas.$ZodCIDRv6.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodBase64 = /* @__PURE__ */ core.$constructor("ZodBase64", (inst, def) => {
+  schemas.$ZodBase64.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodBase64URL = /* @__PURE__ */ core.$constructor("ZodBase64URL", (inst, def) => {
+  schemas.$ZodBase64URL.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodE164 = /* @__PURE__ */ core.$constructor("ZodE164", (inst, def) => {
+  schemas.$ZodE164.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodJWT = /* @__PURE__ */ core.$constructor("ZodJWT", (inst, def) => {
+  schemas.$ZodJWT.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+const ZodNumber = /* @__PURE__ */ core.$constructor("ZodNumber", (inst, def) => {
+  schemas.$ZodNumber.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.numberProcessor(inst, ctx, json);
+  _installLazyMethods(inst, "ZodNumber", {
+    gt(value, params) {
+      return this.check(api._gt(value, params));
+    },
+    gte(value, params) {
+      return this.check(api._gte(value, params));
+    },
+    min(value, params) {
+      return this.check(api._gte(value, params));
+    },
+    lt(value, params) {
+      return this.check(api._lt(value, params));
+    },
+    lte(value, params) {
+      return this.check(api._lte(value, params));
+    },
+    max(value, params) {
+      return this.check(api._lte(value, params));
+    },
+    int(params) {
+      return this.check(int(params));
+    },
+    safe(params) {
+      return this.check(int(params));
+    },
+    positive(params) {
+      return this.check(api._gt(0, params));
+    },
+    nonnegative(params) {
+      return this.check(api._gte(0, params));
+    },
+    negative(params) {
+      return this.check(api._lt(0, params));
+    },
+    nonpositive(params) {
+      return this.check(api._lte(0, params));
+    },
+    multipleOf(value, params) {
+      return this.check(api._multipleOf(value, params));
+    },
+    step(value, params) {
+      return this.check(api._multipleOf(value, params));
+    },
+    finite() {
+      return this;
+    }
+  });
+  const bag = inst._zod.bag;
+  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
+  inst.isFinite = true;
+  inst.format = bag.format ?? null;
+});
+function number(params) {
+  return api._number(ZodNumber, params);
+}
+const ZodNumberFormat = /* @__PURE__ */ core.$constructor("ZodNumberFormat", (inst, def) => {
+  schemas.$ZodNumberFormat.init(inst, def);
+  ZodNumber.init(inst, def);
+});
+function int(params) {
+  return api._int(ZodNumberFormat, params);
+}
+const ZodBoolean = /* @__PURE__ */ core.$constructor("ZodBoolean", (inst, def) => {
+  schemas.$ZodBoolean.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.booleanProcessor(inst, ctx, json);
+});
+function boolean(params) {
+  return api._boolean(ZodBoolean, params);
+}
+const ZodUnknown = /* @__PURE__ */ core.$constructor("ZodUnknown", (inst, def) => {
+  schemas.$ZodUnknown.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.unknownProcessor();
+});
+function unknown() {
+  return api._unknown(ZodUnknown);
+}
+const ZodNever = /* @__PURE__ */ core.$constructor("ZodNever", (inst, def) => {
+  schemas.$ZodNever.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.neverProcessor(inst, ctx, json);
+});
+function never(params) {
+  return api._never(ZodNever, params);
+}
+const ZodArray = /* @__PURE__ */ core.$constructor("ZodArray", (inst, def) => {
+  schemas.$ZodArray.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.arrayProcessor(inst, ctx, json, params);
+  inst.element = def.element;
+  _installLazyMethods(inst, "ZodArray", {
+    min(n, params) {
+      return this.check(api._minLength(n, params));
+    },
+    nonempty(params) {
+      return this.check(api._minLength(1, params));
+    },
+    max(n, params) {
+      return this.check(api._maxLength(n, params));
+    },
+    length(n, params) {
+      return this.check(api._length(n, params));
+    },
+    unwrap() {
+      return this.element;
+    }
+  });
+});
+function array(element, params) {
+  return api._array(ZodArray, element, params);
+}
+const ZodObject = /* @__PURE__ */ core.$constructor("ZodObject", (inst, def) => {
+  schemas.$ZodObjectJIT.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.objectProcessor(inst, ctx, json, params);
+  util.defineLazy(inst, "shape", () => {
+    return def.shape;
+  });
+  _installLazyMethods(inst, "ZodObject", {
+    keyof() {
+      return _enum(Object.keys(this._zod.def.shape));
+    },
+    catchall(catchall) {
+      return this.clone({ ...this._zod.def, catchall });
+    },
+    passthrough() {
+      return this.clone({ ...this._zod.def, catchall: unknown() });
+    },
+    loose() {
+      return this.clone({ ...this._zod.def, catchall: unknown() });
+    },
+    strict() {
+      return this.clone({ ...this._zod.def, catchall: never() });
+    },
+    strip() {
+      return this.clone({ ...this._zod.def, catchall: void 0 });
+    },
+    extend(incoming) {
+      return util.extend(this, incoming);
+    },
+    safeExtend(incoming) {
+      return util.safeExtend(this, incoming);
+    },
+    merge(other) {
+      return util.merge(this, other);
+    },
+    pick(mask) {
+      return util.pick(this, mask);
+    },
+    omit(mask) {
+      return util.omit(this, mask);
+    },
+    partial(...args) {
+      return util.partial(ZodOptional, this, args[0]);
+    },
+    required(...args) {
+      return util.required(ZodNonOptional, this, args[0]);
+    }
+  });
+});
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    ...util.normalizeParams(params)
+  };
+  return new ZodObject(def);
+}
+const ZodUnion = /* @__PURE__ */ core.$constructor("ZodUnion", (inst, def) => {
+  schemas.$ZodUnion.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.unionProcessor(inst, ctx, json, params);
+  inst.options = def.options;
+});
+function union(options, params) {
+  return new ZodUnion({
+    type: "union",
+    options,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodDiscriminatedUnion = /* @__PURE__ */ core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
+  ZodUnion.init(inst, def);
+  schemas.$ZodDiscriminatedUnion.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+  return new ZodDiscriminatedUnion({
+    type: "union",
+    options,
+    discriminator,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodIntersection = /* @__PURE__ */ core.$constructor("ZodIntersection", (inst, def) => {
+  schemas.$ZodIntersection.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.intersectionProcessor(inst, ctx, json, params);
+});
+function intersection(left, right) {
+  return new ZodIntersection({
+    type: "intersection",
+    left,
+    right
+  });
+}
+const ZodEnum = /* @__PURE__ */ core.$constructor("ZodEnum", (inst, def) => {
+  schemas.$ZodEnum.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.enumProcessor(inst, ctx, json);
+  inst.enum = def.entries;
+  inst.options = Object.values(def.entries);
+  const keys = new Set(Object.keys(def.entries));
+  inst.extract = (values, params) => {
+    const newEntries = {};
+    for (const value of values) {
+      if (keys.has(value)) {
+        newEntries[value] = def.entries[value];
+      } else
+        throw new Error(`Key ${value} not found in enum`);
+    }
+    return new ZodEnum({
+      ...def,
+      checks: [],
+      ...util.normalizeParams(params),
+      entries: newEntries
+    });
+  };
+  inst.exclude = (values, params) => {
+    const newEntries = { ...def.entries };
+    for (const value of values) {
+      if (keys.has(value)) {
+        delete newEntries[value];
+      } else
+        throw new Error(`Key ${value} not found in enum`);
+    }
+    return new ZodEnum({
+      ...def,
+      checks: [],
+      ...util.normalizeParams(params),
+      entries: newEntries
+    });
+  };
+});
+function _enum(values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  return new ZodEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodLiteral = /* @__PURE__ */ core.$constructor("ZodLiteral", (inst, def) => {
+  schemas.$ZodLiteral.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.literalProcessor(inst, ctx, json);
+  inst.values = new Set(def.values);
+  Object.defineProperty(inst, "value", {
+    get() {
+      if (def.values.length > 1) {
+        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+      }
+      return def.values[0];
+    }
+  });
+});
+function literal(value, params) {
+  return new ZodLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util.normalizeParams(params)
+  });
+}
+const ZodTransform = /* @__PURE__ */ core.$constructor("ZodTransform", (inst, def) => {
+  schemas.$ZodTransform.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.transformProcessor(inst, ctx);
+  inst._zod.parse = (payload, _ctx) => {
+    if (_ctx.direction === "backward") {
+      throw new core.$ZodEncodeError(inst.constructor.name);
+    }
+    payload.addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(util.issue(issue, payload.value, def));
+      } else {
+        const _issue = issue;
+        if (_issue.fatal)
+          _issue.continue = false;
+        _issue.code ?? (_issue.code = "custom");
+        _issue.input ?? (_issue.input = payload.value);
+        _issue.inst ?? (_issue.inst = inst);
+        payload.issues.push(util.issue(_issue));
+      }
+    };
+    const output = def.transform(payload.value, payload);
+    if (output instanceof Promise) {
+      return output.then((output2) => {
+        payload.value = output2;
+        payload.fallback = true;
+        return payload;
+      });
+    }
+    payload.value = output;
+    payload.fallback = true;
+    return payload;
+  };
+});
+function transform(fn) {
+  return new ZodTransform({
+    type: "transform",
+    transform: fn
+  });
+}
+const ZodOptional = /* @__PURE__ */ core.$constructor("ZodOptional", (inst, def) => {
+  schemas.$ZodOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.optionalProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function optional(innerType) {
+  return new ZodOptional({
+    type: "optional",
+    innerType
+  });
+}
+const ZodExactOptional = /* @__PURE__ */ core.$constructor("ZodExactOptional", (inst, def) => {
+  schemas.$ZodExactOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.optionalProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function exactOptional(innerType) {
+  return new ZodExactOptional({
+    type: "optional",
+    innerType
+  });
+}
+const ZodNullable = /* @__PURE__ */ core.$constructor("ZodNullable", (inst, def) => {
+  schemas.$ZodNullable.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.nullableProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function nullable(innerType) {
+  return new ZodNullable({
+    type: "nullable",
+    innerType
+  });
+}
+const ZodDefault = /* @__PURE__ */ core.$constructor("ZodDefault", (inst, def) => {
+  schemas.$ZodDefault.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.defaultProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+  inst.removeDefault = inst.unwrap;
+});
+function _default(innerType, defaultValue) {
+  return new ZodDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
+    }
+  });
+}
+const ZodPrefault = /* @__PURE__ */ core.$constructor("ZodPrefault", (inst, def) => {
+  schemas.$ZodPrefault.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.prefaultProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function prefault(innerType, defaultValue) {
+  return new ZodPrefault({
+    type: "prefault",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
+    }
+  });
+}
+const ZodNonOptional = /* @__PURE__ */ core.$constructor("ZodNonOptional", (inst, def) => {
+  schemas.$ZodNonOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.nonoptionalProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function nonoptional(innerType, params) {
+  return new ZodNonOptional({
+    type: "nonoptional",
+    innerType,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodCatch = /* @__PURE__ */ core.$constructor("ZodCatch", (inst, def) => {
+  schemas.$ZodCatch.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.catchProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+  inst.removeCatch = inst.unwrap;
+});
+function _catch(innerType, catchValue) {
+  return new ZodCatch({
+    type: "catch",
+    innerType,
+    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+  });
+}
+const ZodPipe = /* @__PURE__ */ core.$constructor("ZodPipe", (inst, def) => {
+  schemas.$ZodPipe.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.pipeProcessor(inst, ctx, json, params);
+  inst.in = def.in;
+  inst.out = def.out;
+});
+function pipe(in_, out) {
+  return new ZodPipe({
+    type: "pipe",
+    in: in_,
+    out
+    // ...util.normalizeParams(params),
+  });
+}
+const ZodReadonly = /* @__PURE__ */ core.$constructor("ZodReadonly", (inst, def) => {
+  schemas.$ZodReadonly.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.readonlyProcessor(inst, ctx, json, params);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function readonly(innerType) {
+  return new ZodReadonly({
+    type: "readonly",
+    innerType
+  });
+}
+const ZodCustom = /* @__PURE__ */ core.$constructor("ZodCustom", (inst, def) => {
+  schemas.$ZodCustom.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => jsonSchemaProcessors.customProcessor(inst, ctx);
+});
+function refine(fn, _params = {}) {
+  return api._refine(ZodCustom, fn, _params);
+}
+function superRefine(fn, params) {
+  return api._superRefine(fn, params);
+}
+exports.ZodArray = ZodArray;
+exports.ZodBase64 = ZodBase64;
+exports.ZodBase64URL = ZodBase64URL;
+exports.ZodBoolean = ZodBoolean;
+exports.ZodCIDRv4 = ZodCIDRv4;
+exports.ZodCIDRv6 = ZodCIDRv6;
+exports.ZodCUID = ZodCUID;
+exports.ZodCUID2 = ZodCUID2;
+exports.ZodCatch = ZodCatch;
+exports.ZodCustom = ZodCustom;
+exports.ZodDefault = ZodDefault;
+exports.ZodDiscriminatedUnion = ZodDiscriminatedUnion;
+exports.ZodE164 = ZodE164;
+exports.ZodEmail = ZodEmail;
+exports.ZodEmoji = ZodEmoji;
+exports.ZodEnum = ZodEnum;
+exports.ZodExactOptional = ZodExactOptional;
+exports.ZodGUID = ZodGUID;
+exports.ZodIPv4 = ZodIPv4;
+exports.ZodIPv6 = ZodIPv6;
+exports.ZodIntersection = ZodIntersection;
+exports.ZodJWT = ZodJWT;
+exports.ZodKSUID = ZodKSUID;
+exports.ZodLiteral = ZodLiteral;
+exports.ZodNanoID = ZodNanoID;
+exports.ZodNever = ZodNever;
+exports.ZodNonOptional = ZodNonOptional;
+exports.ZodNullable = ZodNullable;
+exports.ZodNumber = ZodNumber;
+exports.ZodNumberFormat = ZodNumberFormat;
+exports.ZodObject = ZodObject;
+exports.ZodOptional = ZodOptional;
+exports.ZodPipe = ZodPipe;
+exports.ZodPrefault = ZodPrefault;
+exports.ZodReadonly = ZodReadonly;
+exports.ZodString = ZodString;
+exports.ZodStringFormat = ZodStringFormat;
+exports.ZodTransform = ZodTransform;
+exports.ZodType = ZodType;
+exports.ZodULID = ZodULID;
+exports.ZodURL = ZodURL;
+exports.ZodUUID = ZodUUID;
+exports.ZodUnion = ZodUnion;
+exports.ZodUnknown = ZodUnknown;
+exports.ZodXID = ZodXID;
+exports._ZodString = _ZodString;
+exports._default = _default;
+exports.array = array;
+exports.boolean = boolean;
+exports.catch = _catch;
+exports.discriminatedUnion = discriminatedUnion;
+exports.enum = _enum;
+exports.exactOptional = exactOptional;
+exports.int = int;
+exports.intersection = intersection;
+exports.literal = literal;
+exports.never = never;
+exports.nonoptional = nonoptional;
+exports.nullable = nullable;
+exports.number = number;
+exports.object = object;
+exports.optional = optional;
+exports.pipe = pipe;
+exports.prefault = prefault;
+exports.readonly = readonly;
+exports.refine = refine;
+exports.string = string;
+exports.superRefine = superRefine;
+exports.transform = transform;
+exports.union = union;
+exports.unknown = unknown;
+//# sourceMappingURL=schemas.cjs.map