@fileflow/sdk 0.1.0

package/dist/KYCWizard-D3Leb4rK.mjs

@@ -0,0 +1,4575 @@
+import { jsxs as v, jsx as c, Fragment as zt } from "react/jsx-runtime";
+import { useCallback as gt, useState as Yt, useEffect as Wt } from "react";
+import { c as se, b as Ht, u as Kt, X as vt, d as R, U as Jt, A as Qt, h as Xe, e as et, L as Ee, f as Me, g as he, C as Gt } from "./index-CML_nPxo.mjs";
+/**
+ * @license lucide-react v0.321.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Xt = se("Car", [
+  [
+    "path",
+    {
+      d: "M19 17h2c.6 0 1-.4 1-1v-3c0-.9-.7-1.7-1.5-1.9C18.7 10.6 16 10 16 10s-1.3-1.4-2.2-2.3c-.5-.4-1.1-.7-1.8-.7H5c-.6 0-1.1.4-1.4.9l-1.4 2.9A3.7 3.7 0 0 0 2 12v4c0 .6.4 1 1 1h2",
+      key: "5owen"
+    }
+  ],
+  ["circle", { cx: "7", cy: "17", r: "2", key: "u2ysq9" }],
+  ["path", { d: "M9 17h6", key: "r8uit2" }],
+  ["circle", { cx: "17", cy: "17", r: "2", key: "axvx0g" }]
+]);
+/**
+ * @license lucide-react v0.321.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const tt = se("Clock", [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
+  ["polyline", { points: "12 6 12 12 16 14", key: "68esgv" }]
+]);
+/**
+ * @license lucide-react v0.321.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const _t = se("FileText", [
+  ["path", { d: "M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z", key: "1rqfz7" }],
+  ["path", { d: "M14 2v4a2 2 0 0 0 2 2h4", key: "tnqrlb" }],
+  ["path", { d: "M10 9H8", key: "b1mrlr" }],
+  ["path", { d: "M16 13H8", key: "t4e002" }],
+  ["path", { d: "M16 17H8", key: "z1uh3a" }]
+]);
+/**
+ * @license lucide-react v0.321.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const er = se("Home", [
+  ["path", { d: "m3 9 9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z", key: "y5dka4" }],
+  ["polyline", { points: "9 22 9 12 15 12 15 22", key: "e2us08" }]
+]);
+/**
+ * @license lucide-react v0.321.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const tr = se("Image", [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", key: "1m3agn" }],
+  ["circle", { cx: "9", cy: "9", r: "2", key: "af1f0g" }],
+  ["path", { d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21", key: "1xmnt7" }]
+]);
+/**
+ * @license lucide-react v0.321.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const rt = se("ShieldCheck", [
+  ["path", { d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10", key: "1irkt0" }],
+  ["path", { d: "m9 12 2 2 4-4", key: "dzmm74" }]
+]), at = (a) => ({
+  id: null,
+  type: a,
+  status: "uploaded",
+  file: null,
+  previewUrl: null,
+  extractedData: null,
+  confidence: 0,
+  fraudFlags: [],
+  error: null
+}), st = {
+  sessionId: null,
+  status: "idle",
+  step: "select",
+  requiredDocuments: [],
+  currentDocumentType: null,
+  documents: /* @__PURE__ */ new Map(),
+  isVerified: !1,
+  verificationStatus: null,
+  isLoading: !1,
+  error: null
+}, ye = Ht((a, e) => ({
+  ...st,
+  setSessionId: (t) => a({ sessionId: t }),
+  setRequiredDocuments: (t) => {
+    const r = /* @__PURE__ */ new Map();
+    for (const s of t)
+      r.set(s, at(s));
+    a({
+      requiredDocuments: t,
+      documents: r,
+      currentDocumentType: t[0] || null
+    });
+  },
+  setCurrentDocumentType: (t) => a({ currentDocumentType: t }),
+  setDocumentFile: (t, r) => {
+    const { documents: s } = e(), i = s.get(t) || at(t), n = URL.createObjectURL(r), o = new Map(s);
+    o.set(t, {
+      ...i,
+      file: r,
+      previewUrl: n,
+      status: "uploaded",
+      error: null
+    }), a({ documents: o });
+  },
+  setDocumentStatus: (t, r) => {
+    const { documents: s } = e(), i = s.get(t);
+    if (i) {
+      const n = new Map(s);
+      n.set(t, { ...i, status: r }), a({ documents: n });
+    }
+  },
+  setDocumentData: (t, r) => {
+    const { documents: s } = e(), i = s.get(t);
+    if (i) {
+      const n = new Map(s);
+      n.set(t, { ...i, ...r }), a({ documents: n });
+    }
+  },
+  clearDocumentPreview: (t) => {
+    const { documents: r } = e(), s = r.get(t);
+    s != null && s.previewUrl && URL.revokeObjectURL(s.previewUrl);
+  },
+  setStep: (t) => a({ step: t }),
+  nextDocument: () => {
+    const { requiredDocuments: t, currentDocumentType: r, documents: s } = e(), i = r ? t.indexOf(r) : -1;
+    for (let n = i + 1; n < t.length; n++) {
+      const o = t[n], d = s.get(o);
+      if (!(d != null && d.file)) {
+        a({ currentDocumentType: o });
+        return;
+      }
+    }
+    a({
+      currentDocumentType: null,
+      step: "processing"
+    });
+  },
+  setVerificationStatus: (t) => a({ verificationStatus: t }),
+  setVerified: (t) => a({ isVerified: t }),
+  setStatus: (t) => a({ status: t }),
+  setLoading: (t) => a({ isLoading: t }),
+  setError: (t) => a({ error: t }),
+  getNextRequiredDocument: () => {
+    const { requiredDocuments: t, documents: r } = e();
+    for (const s of t) {
+      const i = r.get(s);
+      if (!(i != null && i.file))
+        return s;
+    }
+    return null;
+  },
+  areAllDocumentsUploaded: () => {
+    const { requiredDocuments: t, documents: r } = e();
+    return t.every((s) => {
+      const i = r.get(s);
+      return (i == null ? void 0 : i.file) !== null;
+    });
+  },
+  areAllDocumentsProcessed: () => {
+    const { requiredDocuments: t, documents: r } = e();
+    return t.every((s) => {
+      const i = r.get(s);
+      return (i == null ? void 0 : i.status) === "completed" || (i == null ? void 0 : i.status) === "requires_review";
+    });
+  },
+  reset: () => {
+    const { documents: t } = e();
+    for (const r of t.values())
+      r.previewUrl && URL.revokeObjectURL(r.previewUrl);
+    a(st);
+  }
+}));
+var k;
+(function(a) {
+  a.assertEqual = (s) => {
+  };
+  function e(s) {
+  }
+  a.assertIs = e;
+  function t(s) {
+    throw new Error();
+  }
+  a.assertNever = t, a.arrayToEnum = (s) => {
+    const i = {};
+    for (const n of s)
+      i[n] = n;
+    return i;
+  }, a.getValidEnumValues = (s) => {
+    const i = a.objectKeys(s).filter((o) => typeof s[s[o]] != "number"), n = {};
+    for (const o of i)
+      n[o] = s[o];
+    return a.objectValues(n);
+  }, a.objectValues = (s) => a.objectKeys(s).map(function(i) {
+    return s[i];
+  }), a.objectKeys = typeof Object.keys == "function" ? (s) => Object.keys(s) : (s) => {
+    const i = [];
+    for (const n in s)
+      Object.prototype.hasOwnProperty.call(s, n) && i.push(n);
+    return i;
+  }, a.find = (s, i) => {
+    for (const n of s)
+      if (i(n))
+        return n;
+  }, a.isInteger = typeof Number.isInteger == "function" ? (s) => Number.isInteger(s) : (s) => typeof s == "number" && Number.isFinite(s) && Math.floor(s) === s;
+  function r(s, i = " | ") {
+    return s.map((n) => typeof n == "string" ? `'${n}'` : n).join(i);
+  }
+  a.joinValues = r, a.jsonStringifyReplacer = (s, i) => typeof i == "bigint" ? i.toString() : i;
+})(k || (k = {}));
+var it;
+(function(a) {
+  a.mergeShapes = (e, t) => ({
+    ...e,
+    ...t
+    // second overwrites first
+  });
+})(it || (it = {}));
+const m = k.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), V = (a) => {
+  switch (typeof a) {
+    case "undefined":
+      return m.undefined;
+    case "string":
+      return m.string;
+    case "number":
+      return Number.isNaN(a) ? m.nan : m.number;
+    case "boolean":
+      return m.boolean;
+    case "function":
+      return m.function;
+    case "bigint":
+      return m.bigint;
+    case "symbol":
+      return m.symbol;
+    case "object":
+      return Array.isArray(a) ? m.array : a === null ? m.null : a.then && typeof a.then == "function" && a.catch && typeof a.catch == "function" ? m.promise : typeof Map < "u" && a instanceof Map ? m.map : typeof Set < "u" && a instanceof Set ? m.set : typeof Date < "u" && a instanceof Date ? m.date : m.object;
+    default:
+      return m.unknown;
+  }
+}, l = k.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite"
+]);
+class U extends Error {
+  get errors() {
+    return this.issues;
+  }
+  constructor(e) {
+    super(), this.issues = [], this.addIssue = (r) => {
+      this.issues = [...this.issues, r];
+    }, this.addIssues = (r = []) => {
+      this.issues = [...this.issues, ...r];
+    };
+    const t = new.target.prototype;
+    Object.setPrototypeOf ? Object.setPrototypeOf(this, t) : this.__proto__ = t, this.name = "ZodError", this.issues = e;
+  }
+  format(e) {
+    const t = e || function(i) {
+      return i.message;
+    }, r = { _errors: [] }, s = (i) => {
+      for (const n of i.issues)
+        if (n.code === "invalid_union")
+          n.unionErrors.map(s);
+        else if (n.code === "invalid_return_type")
+          s(n.returnTypeError);
+        else if (n.code === "invalid_arguments")
+          s(n.argumentsError);
+        else if (n.path.length === 0)
+          r._errors.push(t(n));
+        else {
+          let o = r, d = 0;
+          for (; d < n.path.length; ) {
+            const h = n.path[d];
+            d === n.path.length - 1 ? (o[h] = o[h] || { _errors: [] }, o[h]._errors.push(t(n))) : o[h] = o[h] || { _errors: [] }, o = o[h], d++;
+          }
+        }
+    };
+    return s(this), r;
+  }
+  static assert(e) {
+    if (!(e instanceof U))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, k.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (t) => t.message) {
+    const t = {}, r = [];
+    for (const s of this.issues)
+      if (s.path.length > 0) {
+        const i = s.path[0];
+        t[i] = t[i] || [], t[i].push(e(s));
+      } else
+        r.push(e(s));
+    return { formErrors: r, fieldErrors: t };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+U.create = (a) => new U(a);
+const je = (a, e) => {
+  let t;
+  switch (a.code) {
+    case l.invalid_type:
+      a.received === m.undefined ? t = "Required" : t = `Expected ${a.expected}, received ${a.received}`;
+      break;
+    case l.invalid_literal:
+      t = `Invalid literal value, expected ${JSON.stringify(a.expected, k.jsonStringifyReplacer)}`;
+      break;
+    case l.unrecognized_keys:
+      t = `Unrecognized key(s) in object: ${k.joinValues(a.keys, ", ")}`;
+      break;
+    case l.invalid_union:
+      t = "Invalid input";
+      break;
+    case l.invalid_union_discriminator:
+      t = `Invalid discriminator value. Expected ${k.joinValues(a.options)}`;
+      break;
+    case l.invalid_enum_value:
+      t = `Invalid enum value. Expected ${k.joinValues(a.options)}, received '${a.received}'`;
+      break;
+    case l.invalid_arguments:
+      t = "Invalid function arguments";
+      break;
+    case l.invalid_return_type:
+      t = "Invalid function return type";
+      break;
+    case l.invalid_date:
+      t = "Invalid date";
+      break;
+    case l.invalid_string:
+      typeof a.validation == "object" ? "includes" in a.validation ? (t = `Invalid input: must include "${a.validation.includes}"`, typeof a.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${a.validation.position}`)) : "startsWith" in a.validation ? t = `Invalid input: must start with "${a.validation.startsWith}"` : "endsWith" in a.validation ? t = `Invalid input: must end with "${a.validation.endsWith}"` : k.assertNever(a.validation) : a.validation !== "regex" ? t = `Invalid ${a.validation}` : t = "Invalid";
+      break;
+    case l.too_small:
+      a.type === "array" ? t = `Array must contain ${a.exact ? "exactly" : a.inclusive ? "at least" : "more than"} ${a.minimum} element(s)` : a.type === "string" ? t = `String must contain ${a.exact ? "exactly" : a.inclusive ? "at least" : "over"} ${a.minimum} character(s)` : a.type === "number" ? t = `Number must be ${a.exact ? "exactly equal to " : a.inclusive ? "greater than or equal to " : "greater than "}${a.minimum}` : a.type === "bigint" ? t = `Number must be ${a.exact ? "exactly equal to " : a.inclusive ? "greater than or equal to " : "greater than "}${a.minimum}` : a.type === "date" ? t = `Date must be ${a.exact ? "exactly equal to " : a.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(a.minimum))}` : t = "Invalid input";
+      break;
+    case l.too_big:
+      a.type === "array" ? t = `Array must contain ${a.exact ? "exactly" : a.inclusive ? "at most" : "less than"} ${a.maximum} element(s)` : a.type === "string" ? t = `String must contain ${a.exact ? "exactly" : a.inclusive ? "at most" : "under"} ${a.maximum} character(s)` : a.type === "number" ? t = `Number must be ${a.exact ? "exactly" : a.inclusive ? "less than or equal to" : "less than"} ${a.maximum}` : a.type === "bigint" ? t = `BigInt must be ${a.exact ? "exactly" : a.inclusive ? "less than or equal to" : "less than"} ${a.maximum}` : a.type === "date" ? t = `Date must be ${a.exact ? "exactly" : a.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(a.maximum))}` : t = "Invalid input";
+      break;
+    case l.custom:
+      t = "Invalid input";
+      break;
+    case l.invalid_intersection_types:
+      t = "Intersection results could not be merged";
+      break;
+    case l.not_multiple_of:
+      t = `Number must be a multiple of ${a.multipleOf}`;
+      break;
+    case l.not_finite:
+      t = "Number must be finite";
+      break;
+    default:
+      t = e.defaultError, k.assertNever(a);
+  }
+  return { message: t };
+};
+let rr = je;
+function ar() {
+  return rr;
+}
+const sr = (a) => {
+  const { data: e, path: t, errorMaps: r, issueData: s } = a, i = [...t, ...s.path || []], n = {
+    ...s,
+    path: i
+  };
+  if (s.message !== void 0)
+    return {
+      ...s,
+      path: i,
+      message: s.message
+    };
+  let o = "";
+  const d = r.filter((h) => !!h).slice().reverse();
+  for (const h of d)
+    o = h(n, { data: e, defaultError: o }).message;
+  return {
+    ...s,
+    path: i,
+    message: o
+  };
+};
+function f(a, e) {
+  const t = ar(), r = sr({
+    issueData: e,
+    data: a.data,
+    path: a.path,
+    errorMaps: [
+      a.common.contextualErrorMap,
+      // contextual error map is first priority
+      a.schemaErrorMap,
+      // then schema-bound map if available
+      t,
+      // then global override map
+      t === je ? void 0 : je
+      // then global default map
+    ].filter((s) => !!s)
+  });
+  a.common.issues.push(r);
+}
+class A {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    this.value === "valid" && (this.value = "dirty");
+  }
+  abort() {
+    this.value !== "aborted" && (this.value = "aborted");
+  }
+  static mergeArray(e, t) {
+    const r = [];
+    for (const s of t) {
+      if (s.status === "aborted")
+        return y;
+      s.status === "dirty" && e.dirty(), r.push(s.value);
+    }
+    return { status: e.value, value: r };
+  }
+  static async mergeObjectAsync(e, t) {
+    const r = [];
+    for (const s of t) {
+      const i = await s.key, n = await s.value;
+      r.push({
+        key: i,
+        value: n
+      });
+    }
+    return A.mergeObjectSync(e, r);
+  }
+  static mergeObjectSync(e, t) {
+    const r = {};
+    for (const s of t) {
+      const { key: i, value: n } = s;
+      if (i.status === "aborted" || n.status === "aborted")
+        return y;
+      i.status === "dirty" && e.dirty(), n.status === "dirty" && e.dirty(), i.value !== "__proto__" && (typeof n.value < "u" || s.alwaysSet) && (r[i.value] = n.value);
+    }
+    return { status: e.value, value: r };
+  }
+}
+const y = Object.freeze({
+  status: "aborted"
+}), oe = (a) => ({ status: "dirty", value: a }), E = (a) => ({ status: "valid", value: a }), nt = (a) => a.status === "aborted", ot = (a) => a.status === "dirty", re = (a) => a.status === "valid", ge = (a) => typeof Promise < "u" && a instanceof Promise;
+var p;
+(function(a) {
+  a.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, a.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(p || (p = {}));
+class P {
+  constructor(e, t, r, s) {
+    this._cachedPath = [], this.parent = e, this.data = t, this._path = r, this._key = s;
+  }
+  get path() {
+    return this._cachedPath.length || (Array.isArray(this._key) ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+  }
+}
+const lt = (a, e) => {
+  if (re(e))
+    return { success: !0, data: e.value };
+  if (!a.common.issues.length)
+    throw new Error("Validation failed but no issues detected.");
+  return {
+    success: !1,
+    get error() {
+      if (this._error)
+        return this._error;
+      const t = new U(a.common.issues);
+      return this._error = t, this._error;
+    }
+  };
+};
+function _(a) {
+  if (!a)
+    return {};
+  const { errorMap: e, invalid_type_error: t, required_error: r, description: s } = a;
+  if (e && (t || r))
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  return e ? { errorMap: e, description: s } : { errorMap: (n, o) => {
+    const { message: d } = a;
+    return n.code === "invalid_enum_value" ? { message: d ?? o.defaultError } : typeof o.data > "u" ? { message: d ?? r ?? o.defaultError } : n.code !== "invalid_type" ? { message: o.defaultError } : { message: d ?? t ?? o.defaultError };
+  }, description: s };
+}
+class b {
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return V(e.data);
+  }
+  _getOrReturnCtx(e, t) {
+    return t || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: V(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new A(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: V(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const t = this._parse(e);
+    if (ge(t))
+      throw new Error("Synchronous parse encountered promise.");
+    return t;
+  }
+  _parseAsync(e) {
+    const t = this._parse(e);
+    return Promise.resolve(t);
+  }
+  parse(e, t) {
+    const r = this.safeParse(e, t);
+    if (r.success)
+      return r.data;
+    throw r.error;
+  }
+  safeParse(e, t) {
+    const r = {
+      common: {
+        issues: [],
+        async: (t == null ? void 0 : t.async) ?? !1,
+        contextualErrorMap: t == null ? void 0 : t.errorMap
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: V(e)
+    }, s = this._parseSync({ data: e, path: r.path, parent: r });
+    return lt(r, s);
+  }
+  "~validate"(e) {
+    var r, s;
+    const t = {
+      common: {
+        issues: [],
+        async: !!this["~standard"].async
+      },
+      path: [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: V(e)
+    };
+    if (!this["~standard"].async)
+      try {
+        const i = this._parseSync({ data: e, path: [], parent: t });
+        return re(i) ? {
+          value: i.value
+        } : {
+          issues: t.common.issues
+        };
+      } catch (i) {
+        (s = (r = i == null ? void 0 : i.message) == null ? void 0 : r.toLowerCase()) != null && s.includes("encountered") && (this["~standard"].async = !0), t.common = {
+          issues: [],
+          async: !0
+        };
+      }
+    return this._parseAsync({ data: e, path: [], parent: t }).then((i) => re(i) ? {
+      value: i.value
+    } : {
+      issues: t.common.issues
+    });
+  }
+  async parseAsync(e, t) {
+    const r = await this.safeParseAsync(e, t);
+    if (r.success)
+      return r.data;
+    throw r.error;
+  }
+  async safeParseAsync(e, t) {
+    const r = {
+      common: {
+        issues: [],
+        contextualErrorMap: t == null ? void 0 : t.errorMap,
+        async: !0
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: V(e)
+    }, s = this._parse({ data: e, path: r.path, parent: r }), i = await (ge(s) ? s : Promise.resolve(s));
+    return lt(r, i);
+  }
+  refine(e, t) {
+    const r = (s) => typeof t == "string" || typeof t > "u" ? { message: t } : typeof t == "function" ? t(s) : t;
+    return this._refinement((s, i) => {
+      const n = e(s), o = () => i.addIssue({
+        code: l.custom,
+        ...r(s)
+      });
+      return typeof Promise < "u" && n instanceof Promise ? n.then((d) => d ? !0 : (o(), !1)) : n ? !0 : (o(), !1);
+    });
+  }
+  refinement(e, t) {
+    return this._refinement((r, s) => e(r) ? !0 : (s.addIssue(typeof t == "function" ? t(r, s) : t), !1));
+  }
+  _refinement(e) {
+    return new Q({
+      schema: this,
+      typeName: g.ZodEffects,
+      effect: { type: "refinement", refinement: e }
+    });
+  }
+  superRefine(e) {
+    return this._refinement(e);
+  }
+  constructor(e) {
+    this.spa = this.safeParseAsync, this._def = e, this.parse = this.parse.bind(this), this.safeParse = this.safeParse.bind(this), this.parseAsync = this.parseAsync.bind(this), this.safeParseAsync = this.safeParseAsync.bind(this), this.spa = this.spa.bind(this), this.refine = this.refine.bind(this), this.refinement = this.refinement.bind(this), this.superRefine = this.superRefine.bind(this), this.optional = this.optional.bind(this), this.nullable = this.nullable.bind(this), this.nullish = this.nullish.bind(this), this.array = this.array.bind(this), this.promise = this.promise.bind(this), this.or = this.or.bind(this), this.and = this.and.bind(this), this.transform = this.transform.bind(this), this.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this), this["~standard"] = {
+      version: 1,
+      vendor: "zod",
+      validate: (t) => this["~validate"](t)
+    };
+  }
+  optional() {
+    return B.create(this, this._def);
+  }
+  nullable() {
+    return G.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return F.create(this);
+  }
+  promise() {
+    return Ne.create(this, this._def);
+  }
+  or(e) {
+    return xe.create([this, e], this._def);
+  }
+  and(e) {
+    return be.create(this, e, this._def);
+  }
+  transform(e) {
+    return new Q({
+      ..._(this._def),
+      schema: this,
+      typeName: g.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new Ce({
+      ..._(this._def),
+      innerType: this,
+      defaultValue: t,
+      typeName: g.ZodDefault
+    });
+  }
+  brand() {
+    return new wt({
+      typeName: g.ZodBranded,
+      type: this,
+      ..._(this._def)
+    });
+  }
+  catch(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new Se({
+      ..._(this._def),
+      innerType: this,
+      catchValue: t,
+      typeName: g.ZodCatch
+    });
+  }
+  describe(e) {
+    const t = this.constructor;
+    return new t({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return Ue.create(this, e);
+  }
+  readonly() {
+    return Te.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const ir = /^c[^\s-]{8,}$/i, nr = /^[0-9a-z]+$/, or = /^[0-9A-HJKMNP-TV-Z]{26}$/i, lr = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, cr = /^[a-z0-9_-]{21}$/i, dr = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, fr = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/, ur = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, mr = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let Re;
+const pr = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, hr = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/, yr = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/, gr = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, vr = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, _r = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, xt = "((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))", xr = new RegExp(`^${xt}$`);
+function bt(a) {
+  let e = "[0-5]\\d";
+  a.precision ? e = `${e}\\.\\d{${a.precision}}` : a.precision == null && (e = `${e}(\\.\\d+)?`);
+  const t = a.precision ? "+" : "?";
+  return `([01]\\d|2[0-3]):[0-5]\\d(:${e})${t}`;
+}
+function br(a) {
+  return new RegExp(`^${bt(a)}$`);
+}
+function kr(a) {
+  let e = `${xt}T${bt(a)}`;
+  const t = [];
+  return t.push(a.local ? "Z?" : "Z"), a.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
+}
+function wr(a, e) {
+  return !!((e === "v4" || !e) && pr.test(a) || (e === "v6" || !e) && yr.test(a));
+}
+function Nr(a, e) {
+  if (!dr.test(a))
+    return !1;
+  try {
+    const [t] = a.split(".");
+    if (!t)
+      return !1;
+    const r = t.replace(/-/g, "+").replace(/_/g, "/").padEnd(t.length + (4 - t.length % 4) % 4, "="), s = JSON.parse(atob(r));
+    return !(typeof s != "object" || s === null || "typ" in s && (s == null ? void 0 : s.typ) !== "JWT" || !s.alg || e && s.alg !== e);
+  } catch {
+    return !1;
+  }
+}
+function Cr(a, e) {
+  return !!((e === "v4" || !e) && hr.test(a) || (e === "v6" || !e) && gr.test(a));
+}
+class $ extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== m.string) {
+      const i = this._getOrReturnCtx(e);
+      return f(i, {
+        code: l.invalid_type,
+        expected: m.string,
+        received: i.parsedType
+      }), y;
+    }
+    const r = new A();
+    let s;
+    for (const i of this._def.checks)
+      if (i.kind === "min")
+        e.data.length < i.value && (s = this._getOrReturnCtx(e, s), f(s, {
+          code: l.too_small,
+          minimum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "max")
+        e.data.length > i.value && (s = this._getOrReturnCtx(e, s), f(s, {
+          code: l.too_big,
+          maximum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "length") {
+        const n = e.data.length > i.value, o = e.data.length < i.value;
+        (n || o) && (s = this._getOrReturnCtx(e, s), n ? f(s, {
+          code: l.too_big,
+          maximum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: i.message
+        }) : o && f(s, {
+          code: l.too_small,
+          minimum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: i.message
+        }), r.dirty());
+      } else if (i.kind === "email")
+        ur.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "email",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "emoji")
+        Re || (Re = new RegExp(mr, "u")), Re.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "emoji",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "uuid")
+        lr.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "uuid",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "nanoid")
+        cr.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "nanoid",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "cuid")
+        ir.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "cuid",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "cuid2")
+        nr.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "cuid2",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "ulid")
+        or.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "ulid",
+          code: l.invalid_string,
+          message: i.message
+        }), r.dirty());
+      else if (i.kind === "url")
+        try {
+          new URL(e.data);
+        } catch {
+          s = this._getOrReturnCtx(e, s), f(s, {
+            validation: "url",
+            code: l.invalid_string,
+            message: i.message
+          }), r.dirty();
+        }
+      else i.kind === "regex" ? (i.regex.lastIndex = 0, i.regex.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "regex",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty())) : i.kind === "trim" ? e.data = e.data.trim() : i.kind === "includes" ? e.data.includes(i.value, i.position) || (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.invalid_string,
+        validation: { includes: i.value, position: i.position },
+        message: i.message
+      }), r.dirty()) : i.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : i.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : i.kind === "startsWith" ? e.data.startsWith(i.value) || (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.invalid_string,
+        validation: { startsWith: i.value },
+        message: i.message
+      }), r.dirty()) : i.kind === "endsWith" ? e.data.endsWith(i.value) || (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.invalid_string,
+        validation: { endsWith: i.value },
+        message: i.message
+      }), r.dirty()) : i.kind === "datetime" ? kr(i).test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.invalid_string,
+        validation: "datetime",
+        message: i.message
+      }), r.dirty()) : i.kind === "date" ? xr.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.invalid_string,
+        validation: "date",
+        message: i.message
+      }), r.dirty()) : i.kind === "time" ? br(i).test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.invalid_string,
+        validation: "time",
+        message: i.message
+      }), r.dirty()) : i.kind === "duration" ? fr.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "duration",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty()) : i.kind === "ip" ? wr(e.data, i.version) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "ip",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty()) : i.kind === "jwt" ? Nr(e.data, i.alg) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "jwt",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty()) : i.kind === "cidr" ? Cr(e.data, i.version) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "cidr",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty()) : i.kind === "base64" ? vr.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "base64",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty()) : i.kind === "base64url" ? _r.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+        validation: "base64url",
+        code: l.invalid_string,
+        message: i.message
+      }), r.dirty()) : k.assertNever(i);
+    return { status: r.value, value: e.data };
+  }
+  _regex(e, t, r) {
+    return this.refinement((s) => e.test(s), {
+      validation: t,
+      code: l.invalid_string,
+      ...p.errToObj(r)
+    });
+  }
+  _addCheck(e) {
+    return new $({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...p.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...p.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...p.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...p.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...p.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...p.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...p.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...p.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...p.errToObj(e) });
+  }
+  base64url(e) {
+    return this._addCheck({
+      kind: "base64url",
+      ...p.errToObj(e)
+    });
+  }
+  jwt(e) {
+    return this._addCheck({ kind: "jwt", ...p.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...p.errToObj(e) });
+  }
+  cidr(e) {
+    return this._addCheck({ kind: "cidr", ...p.errToObj(e) });
+  }
+  datetime(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "datetime",
+      precision: null,
+      offset: !1,
+      local: !1,
+      message: e
+    }) : this._addCheck({
+      kind: "datetime",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      offset: (e == null ? void 0 : e.offset) ?? !1,
+      local: (e == null ? void 0 : e.local) ?? !1,
+      ...p.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  date(e) {
+    return this._addCheck({ kind: "date", message: e });
+  }
+  time(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "time",
+      precision: null,
+      message: e
+    }) : this._addCheck({
+      kind: "time",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      ...p.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...p.errToObj(e) });
+  }
+  regex(e, t) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...p.errToObj(t)
+    });
+  }
+  includes(e, t) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: t == null ? void 0 : t.position,
+      ...p.errToObj(t == null ? void 0 : t.message)
+    });
+  }
+  startsWith(e, t) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  endsWith(e, t) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  length(e, t) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(e) {
+    return this.min(1, p.errToObj(e));
+  }
+  trim() {
+    return new $({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new $({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new $({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toUpperCase" }]
+    });
+  }
+  get isDatetime() {
+    return !!this._def.checks.find((e) => e.kind === "datetime");
+  }
+  get isDate() {
+    return !!this._def.checks.find((e) => e.kind === "date");
+  }
+  get isTime() {
+    return !!this._def.checks.find((e) => e.kind === "time");
+  }
+  get isDuration() {
+    return !!this._def.checks.find((e) => e.kind === "duration");
+  }
+  get isEmail() {
+    return !!this._def.checks.find((e) => e.kind === "email");
+  }
+  get isURL() {
+    return !!this._def.checks.find((e) => e.kind === "url");
+  }
+  get isEmoji() {
+    return !!this._def.checks.find((e) => e.kind === "emoji");
+  }
+  get isUUID() {
+    return !!this._def.checks.find((e) => e.kind === "uuid");
+  }
+  get isNANOID() {
+    return !!this._def.checks.find((e) => e.kind === "nanoid");
+  }
+  get isCUID() {
+    return !!this._def.checks.find((e) => e.kind === "cuid");
+  }
+  get isCUID2() {
+    return !!this._def.checks.find((e) => e.kind === "cuid2");
+  }
+  get isULID() {
+    return !!this._def.checks.find((e) => e.kind === "ulid");
+  }
+  get isIP() {
+    return !!this._def.checks.find((e) => e.kind === "ip");
+  }
+  get isCIDR() {
+    return !!this._def.checks.find((e) => e.kind === "cidr");
+  }
+  get isBase64() {
+    return !!this._def.checks.find((e) => e.kind === "base64");
+  }
+  get isBase64url() {
+    return !!this._def.checks.find((e) => e.kind === "base64url");
+  }
+  get minLength() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxLength() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+}
+$.create = (a) => new $({
+  checks: [],
+  typeName: g.ZodString,
+  coerce: (a == null ? void 0 : a.coerce) ?? !1,
+  ..._(a)
+});
+function Sr(a, e) {
+  const t = (a.toString().split(".")[1] || "").length, r = (e.toString().split(".")[1] || "").length, s = t > r ? t : r, i = Number.parseInt(a.toFixed(s).replace(".", "")), n = Number.parseInt(e.toFixed(s).replace(".", ""));
+  return i % n / 10 ** s;
+}
+class ae extends b {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
+  }
+  _parse(e) {
+    if (this._def.coerce && (e.data = Number(e.data)), this._getType(e) !== m.number) {
+      const i = this._getOrReturnCtx(e);
+      return f(i, {
+        code: l.invalid_type,
+        expected: m.number,
+        received: i.parsedType
+      }), y;
+    }
+    let r;
+    const s = new A();
+    for (const i of this._def.checks)
+      i.kind === "int" ? k.isInteger(e.data) || (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: i.message
+      }), s.dirty()) : i.kind === "min" ? (i.inclusive ? e.data < i.value : e.data <= i.value) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.too_small,
+        minimum: i.value,
+        type: "number",
+        inclusive: i.inclusive,
+        exact: !1,
+        message: i.message
+      }), s.dirty()) : i.kind === "max" ? (i.inclusive ? e.data > i.value : e.data >= i.value) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.too_big,
+        maximum: i.value,
+        type: "number",
+        inclusive: i.inclusive,
+        exact: !1,
+        message: i.message
+      }), s.dirty()) : i.kind === "multipleOf" ? Sr(e.data, i.value) !== 0 && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.not_multiple_of,
+        multipleOf: i.value,
+        message: i.message
+      }), s.dirty()) : i.kind === "finite" ? Number.isFinite(e.data) || (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.not_finite,
+        message: i.message
+      }), s.dirty()) : k.assertNever(i);
+    return { status: s.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, p.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, p.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, p.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, p.toString(t));
+  }
+  setLimit(e, t, r, s) {
+    return new ae({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: r,
+          message: p.toString(s)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ae({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: p.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: p.toString(t)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: p.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: p.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: p.toString(e)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+  get isInt() {
+    return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && k.isInteger(e.value));
+  }
+  get isFinite() {
+    let e = null, t = null;
+    for (const r of this._def.checks) {
+      if (r.kind === "finite" || r.kind === "int" || r.kind === "multipleOf")
+        return !0;
+      r.kind === "min" ? (t === null || r.value > t) && (t = r.value) : r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    }
+    return Number.isFinite(t) && Number.isFinite(e);
+  }
+}
+ae.create = (a) => new ae({
+  checks: [],
+  typeName: g.ZodNumber,
+  coerce: (a == null ? void 0 : a.coerce) || !1,
+  ..._(a)
+});
+class ce extends b {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte;
+  }
+  _parse(e) {
+    if (this._def.coerce)
+      try {
+        e.data = BigInt(e.data);
+      } catch {
+        return this._getInvalidInput(e);
+      }
+    if (this._getType(e) !== m.bigint)
+      return this._getInvalidInput(e);
+    let r;
+    const s = new A();
+    for (const i of this._def.checks)
+      i.kind === "min" ? (i.inclusive ? e.data < i.value : e.data <= i.value) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.too_small,
+        type: "bigint",
+        minimum: i.value,
+        inclusive: i.inclusive,
+        message: i.message
+      }), s.dirty()) : i.kind === "max" ? (i.inclusive ? e.data > i.value : e.data >= i.value) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.too_big,
+        type: "bigint",
+        maximum: i.value,
+        inclusive: i.inclusive,
+        message: i.message
+      }), s.dirty()) : i.kind === "multipleOf" ? e.data % i.value !== BigInt(0) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: l.not_multiple_of,
+        multipleOf: i.value,
+        message: i.message
+      }), s.dirty()) : k.assertNever(i);
+    return { status: s.value, value: e.data };
+  }
+  _getInvalidInput(e) {
+    const t = this._getOrReturnCtx(e);
+    return f(t, {
+      code: l.invalid_type,
+      expected: m.bigint,
+      received: t.parsedType
+    }), y;
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, p.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, p.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, p.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, p.toString(t));
+  }
+  setLimit(e, t, r, s) {
+    return new ce({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: r,
+          message: p.toString(s)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ce({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: p.toString(t)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+}
+ce.create = (a) => new ce({
+  checks: [],
+  typeName: g.ZodBigInt,
+  coerce: (a == null ? void 0 : a.coerce) ?? !1,
+  ..._(a)
+});
+class Ze extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== m.boolean) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.boolean,
+        received: r.parsedType
+      }), y;
+    }
+    return E(e.data);
+  }
+}
+Ze.create = (a) => new Ze({
+  typeName: g.ZodBoolean,
+  coerce: (a == null ? void 0 : a.coerce) || !1,
+  ..._(a)
+});
+class ve extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== m.date) {
+      const i = this._getOrReturnCtx(e);
+      return f(i, {
+        code: l.invalid_type,
+        expected: m.date,
+        received: i.parsedType
+      }), y;
+    }
+    if (Number.isNaN(e.data.getTime())) {
+      const i = this._getOrReturnCtx(e);
+      return f(i, {
+        code: l.invalid_date
+      }), y;
+    }
+    const r = new A();
+    let s;
+    for (const i of this._def.checks)
+      i.kind === "min" ? e.data.getTime() < i.value && (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.too_small,
+        message: i.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: i.value,
+        type: "date"
+      }), r.dirty()) : i.kind === "max" ? e.data.getTime() > i.value && (s = this._getOrReturnCtx(e, s), f(s, {
+        code: l.too_big,
+        message: i.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: i.value,
+        type: "date"
+      }), r.dirty()) : k.assertNever(i);
+    return {
+      status: r.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new ve({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: p.toString(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: p.toString(t)
+    });
+  }
+  get minDate() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e != null ? new Date(e) : null;
+  }
+  get maxDate() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e != null ? new Date(e) : null;
+  }
+}
+ve.create = (a) => new ve({
+  checks: [],
+  coerce: (a == null ? void 0 : a.coerce) || !1,
+  typeName: g.ZodDate,
+  ..._(a)
+});
+class ct extends b {
+  _parse(e) {
+    if (this._getType(e) !== m.symbol) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.symbol,
+        received: r.parsedType
+      }), y;
+    }
+    return E(e.data);
+  }
+}
+ct.create = (a) => new ct({
+  typeName: g.ZodSymbol,
+  ..._(a)
+});
+class Fe extends b {
+  _parse(e) {
+    if (this._getType(e) !== m.undefined) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.undefined,
+        received: r.parsedType
+      }), y;
+    }
+    return E(e.data);
+  }
+}
+Fe.create = (a) => new Fe({
+  typeName: g.ZodUndefined,
+  ..._(a)
+});
+class _e extends b {
+  _parse(e) {
+    if (this._getType(e) !== m.null) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.null,
+        received: r.parsedType
+      }), y;
+    }
+    return E(e.data);
+  }
+}
+_e.create = (a) => new _e({
+  typeName: g.ZodNull,
+  ..._(a)
+});
+class dt extends b {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return E(e.data);
+  }
+}
+dt.create = (a) => new dt({
+  typeName: g.ZodAny,
+  ..._(a)
+});
+class Pe extends b {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return E(e.data);
+  }
+}
+Pe.create = (a) => new Pe({
+  typeName: g.ZodUnknown,
+  ..._(a)
+});
+class z extends b {
+  _parse(e) {
+    const t = this._getOrReturnCtx(e);
+    return f(t, {
+      code: l.invalid_type,
+      expected: m.never,
+      received: t.parsedType
+    }), y;
+  }
+}
+z.create = (a) => new z({
+  typeName: g.ZodNever,
+  ..._(a)
+});
+class ft extends b {
+  _parse(e) {
+    if (this._getType(e) !== m.undefined) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.void,
+        received: r.parsedType
+      }), y;
+    }
+    return E(e.data);
+  }
+}
+ft.create = (a) => new ft({
+  typeName: g.ZodVoid,
+  ..._(a)
+});
+class F extends b {
+  _parse(e) {
+    const { ctx: t, status: r } = this._processInputParams(e), s = this._def;
+    if (t.parsedType !== m.array)
+      return f(t, {
+        code: l.invalid_type,
+        expected: m.array,
+        received: t.parsedType
+      }), y;
+    if (s.exactLength !== null) {
+      const n = t.data.length > s.exactLength.value, o = t.data.length < s.exactLength.value;
+      (n || o) && (f(t, {
+        code: n ? l.too_big : l.too_small,
+        minimum: o ? s.exactLength.value : void 0,
+        maximum: n ? s.exactLength.value : void 0,
+        type: "array",
+        inclusive: !0,
+        exact: !0,
+        message: s.exactLength.message
+      }), r.dirty());
+    }
+    if (s.minLength !== null && t.data.length < s.minLength.value && (f(t, {
+      code: l.too_small,
+      minimum: s.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: s.minLength.message
+    }), r.dirty()), s.maxLength !== null && t.data.length > s.maxLength.value && (f(t, {
+      code: l.too_big,
+      maximum: s.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: s.maxLength.message
+    }), r.dirty()), t.common.async)
+      return Promise.all([...t.data].map((n, o) => s.type._parseAsync(new P(t, n, t.path, o)))).then((n) => A.mergeArray(r, n));
+    const i = [...t.data].map((n, o) => s.type._parseSync(new P(t, n, t.path, o)));
+    return A.mergeArray(r, i);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, t) {
+    return new F({
+      ...this._def,
+      minLength: { value: e, message: p.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new F({
+      ...this._def,
+      maxLength: { value: e, message: p.toString(t) }
+    });
+  }
+  length(e, t) {
+    return new F({
+      ...this._def,
+      exactLength: { value: e, message: p.toString(t) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+F.create = (a, e) => new F({
+  type: a,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: g.ZodArray,
+  ..._(e)
+});
+function te(a) {
+  if (a instanceof T) {
+    const e = {};
+    for (const t in a.shape) {
+      const r = a.shape[t];
+      e[t] = B.create(te(r));
+    }
+    return new T({
+      ...a._def,
+      shape: () => e
+    });
+  } else return a instanceof F ? new F({
+    ...a._def,
+    type: te(a.element)
+  }) : a instanceof B ? B.create(te(a.unwrap())) : a instanceof G ? G.create(te(a.unwrap())) : a instanceof K ? K.create(a.items.map((e) => te(e))) : a;
+}
+class T extends b {
+  constructor() {
+    super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
+  }
+  _getCached() {
+    if (this._cached !== null)
+      return this._cached;
+    const e = this._def.shape(), t = k.objectKeys(e);
+    return this._cached = { shape: e, keys: t }, this._cached;
+  }
+  _parse(e) {
+    if (this._getType(e) !== m.object) {
+      const h = this._getOrReturnCtx(e);
+      return f(h, {
+        code: l.invalid_type,
+        expected: m.object,
+        received: h.parsedType
+      }), y;
+    }
+    const { status: r, ctx: s } = this._processInputParams(e), { shape: i, keys: n } = this._getCached(), o = [];
+    if (!(this._def.catchall instanceof z && this._def.unknownKeys === "strip"))
+      for (const h in s.data)
+        n.includes(h) || o.push(h);
+    const d = [];
+    for (const h of n) {
+      const x = i[h], M = s.data[h];
+      d.push({
+        key: { status: "valid", value: h },
+        value: x._parse(new P(s, M, s.path, h)),
+        alwaysSet: h in s.data
+      });
+    }
+    if (this._def.catchall instanceof z) {
+      const h = this._def.unknownKeys;
+      if (h === "passthrough")
+        for (const x of o)
+          d.push({
+            key: { status: "valid", value: x },
+            value: { status: "valid", value: s.data[x] }
+          });
+      else if (h === "strict")
+        o.length > 0 && (f(s, {
+          code: l.unrecognized_keys,
+          keys: o
+        }), r.dirty());
+      else if (h !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const h = this._def.catchall;
+      for (const x of o) {
+        const M = s.data[x];
+        d.push({
+          key: { status: "valid", value: x },
+          value: h._parse(
+            new P(s, M, s.path, x)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: x in s.data
+        });
+      }
+    }
+    return s.common.async ? Promise.resolve().then(async () => {
+      const h = [];
+      for (const x of d) {
+        const M = await x.key, ie = await x.value;
+        h.push({
+          key: M,
+          value: ie,
+          alwaysSet: x.alwaysSet
+        });
+      }
+      return h;
+    }).then((h) => A.mergeObjectSync(r, h)) : A.mergeObjectSync(r, d);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return p.errToObj, new T({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (t, r) => {
+          var i, n;
+          const s = ((n = (i = this._def).errorMap) == null ? void 0 : n.call(i, t, r).message) ?? r.defaultError;
+          return t.code === "unrecognized_keys" ? {
+            message: p.errToObj(e).message ?? s
+          } : {
+            message: s
+          };
+        }
+      } : {}
+    });
+  }
+  strip() {
+    return new T({
+      ...this._def,
+      unknownKeys: "strip"
+    });
+  }
+  passthrough() {
+    return new T({
+      ...this._def,
+      unknownKeys: "passthrough"
+    });
+  }
+  // const AugmentFactory =
+  //   <Def extends ZodObjectDef>(def: Def) =>
+  //   <Augmentation extends ZodRawShape>(
+  //     augmentation: Augmentation
+  //   ): ZodObject<
+  //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
+  //     Def["unknownKeys"],
+  //     Def["catchall"]
+  //   > => {
+  //     return new ZodObject({
+  //       ...def,
+  //       shape: () => ({
+  //         ...def.shape(),
+  //         ...augmentation,
+  //       }),
+  //     }) as any;
+  //   };
+  extend(e) {
+    return new T({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e
+      })
+    });
+  }
+  /**
+   * Prior to zod@1.0.12 there was a bug in the
+   * inferred type of merged objects. Please
+   * upgrade if you are experiencing issues.
+   */
+  merge(e) {
+    return new T({
+      unknownKeys: e._def.unknownKeys,
+      catchall: e._def.catchall,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e._def.shape()
+      }),
+      typeName: g.ZodObject
+    });
+  }
+  // merge<
+  //   Incoming extends AnyZodObject,
+  //   Augmentation extends Incoming["shape"],
+  //   NewOutput extends {
+  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+  //       ? Augmentation[k]["_output"]
+  //       : k extends keyof Output
+  //       ? Output[k]
+  //       : never;
+  //   },
+  //   NewInput extends {
+  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+  //       ? Augmentation[k]["_input"]
+  //       : k extends keyof Input
+  //       ? Input[k]
+  //       : never;
+  //   }
+  // >(
+  //   merging: Incoming
+  // ): ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"],
+  //   NewOutput,
+  //   NewInput
+  // > {
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+  setKey(e, t) {
+    return this.augment({ [e]: t });
+  }
+  // merge<Incoming extends AnyZodObject>(
+  //   merging: Incoming
+  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
+  // ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"]
+  // > {
+  //   // const mergedShape = objectUtil.mergeShapes(
+  //   //   this._def.shape(),
+  //   //   merging._def.shape()
+  //   // );
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+  catchall(e) {
+    return new T({
+      ...this._def,
+      catchall: e
+    });
+  }
+  pick(e) {
+    const t = {};
+    for (const r of k.objectKeys(e))
+      e[r] && this.shape[r] && (t[r] = this.shape[r]);
+    return new T({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  omit(e) {
+    const t = {};
+    for (const r of k.objectKeys(this.shape))
+      e[r] || (t[r] = this.shape[r]);
+    return new T({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return te(this);
+  }
+  partial(e) {
+    const t = {};
+    for (const r of k.objectKeys(this.shape)) {
+      const s = this.shape[r];
+      e && !e[r] ? t[r] = s : t[r] = s.optional();
+    }
+    return new T({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  required(e) {
+    const t = {};
+    for (const r of k.objectKeys(this.shape))
+      if (e && !e[r])
+        t[r] = this.shape[r];
+      else {
+        let i = this.shape[r];
+        for (; i instanceof B; )
+          i = i._def.innerType;
+        t[r] = i;
+      }
+    return new T({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  keyof() {
+    return kt(k.objectKeys(this.shape));
+  }
+}
+T.create = (a, e) => new T({
+  shape: () => a,
+  unknownKeys: "strip",
+  catchall: z.create(),
+  typeName: g.ZodObject,
+  ..._(e)
+});
+T.strictCreate = (a, e) => new T({
+  shape: () => a,
+  unknownKeys: "strict",
+  catchall: z.create(),
+  typeName: g.ZodObject,
+  ..._(e)
+});
+T.lazycreate = (a, e) => new T({
+  shape: a,
+  unknownKeys: "strip",
+  catchall: z.create(),
+  typeName: g.ZodObject,
+  ..._(e)
+});
+class xe extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), r = this._def.options;
+    function s(i) {
+      for (const o of i)
+        if (o.result.status === "valid")
+          return o.result;
+      for (const o of i)
+        if (o.result.status === "dirty")
+          return t.common.issues.push(...o.ctx.common.issues), o.result;
+      const n = i.map((o) => new U(o.ctx.common.issues));
+      return f(t, {
+        code: l.invalid_union,
+        unionErrors: n
+      }), y;
+    }
+    if (t.common.async)
+      return Promise.all(r.map(async (i) => {
+        const n = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await i._parseAsync({
+            data: t.data,
+            path: t.path,
+            parent: n
+          }),
+          ctx: n
+        };
+      })).then(s);
+    {
+      let i;
+      const n = [];
+      for (const d of r) {
+        const h = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        }, x = d._parseSync({
+          data: t.data,
+          path: t.path,
+          parent: h
+        });
+        if (x.status === "valid")
+          return x;
+        x.status === "dirty" && !i && (i = { result: x, ctx: h }), h.common.issues.length && n.push(h.common.issues);
+      }
+      if (i)
+        return t.common.issues.push(...i.ctx.common.issues), i.result;
+      const o = n.map((d) => new U(d));
+      return f(t, {
+        code: l.invalid_union,
+        unionErrors: o
+      }), y;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+xe.create = (a, e) => new xe({
+  options: a,
+  typeName: g.ZodUnion,
+  ..._(e)
+});
+const L = (a) => a instanceof Le ? L(a.schema) : a instanceof Q ? L(a.innerType()) : a instanceof we ? [a.value] : a instanceof J ? a.options : a instanceof $e ? k.objectValues(a.enum) : a instanceof Ce ? L(a._def.innerType) : a instanceof Fe ? [void 0] : a instanceof _e ? [null] : a instanceof B ? [void 0, ...L(a.unwrap())] : a instanceof G ? [null, ...L(a.unwrap())] : a instanceof wt || a instanceof Te ? L(a.unwrap()) : a instanceof Se ? L(a._def.innerType) : [];
+class Be extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== m.object)
+      return f(t, {
+        code: l.invalid_type,
+        expected: m.object,
+        received: t.parsedType
+      }), y;
+    const r = this.discriminator, s = t.data[r], i = this.optionsMap.get(s);
+    return i ? t.common.async ? i._parseAsync({
+      data: t.data,
+      path: t.path,
+      parent: t
+    }) : i._parseSync({
+      data: t.data,
+      path: t.path,
+      parent: t
+    }) : (f(t, {
+      code: l.invalid_union_discriminator,
+      options: Array.from(this.optionsMap.keys()),
+      path: [r]
+    }), y);
+  }
+  get discriminator() {
+    return this._def.discriminator;
+  }
+  get options() {
+    return this._def.options;
+  }
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+  /**
+   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+   * have a different value for each object in the union.
+   * @param discriminator the name of the discriminator property
+   * @param types an array of object schemas
+   * @param params
+   */
+  static create(e, t, r) {
+    const s = /* @__PURE__ */ new Map();
+    for (const i of t) {
+      const n = L(i.shape[e]);
+      if (!n.length)
+        throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
+      for (const o of n) {
+        if (s.has(o))
+          throw new Error(`Discriminator property ${String(e)} has duplicate value ${String(o)}`);
+        s.set(o, i);
+      }
+    }
+    return new Be({
+      typeName: g.ZodDiscriminatedUnion,
+      discriminator: e,
+      options: t,
+      optionsMap: s,
+      ..._(r)
+    });
+  }
+}
+function qe(a, e) {
+  const t = V(a), r = V(e);
+  if (a === e)
+    return { valid: !0, data: a };
+  if (t === m.object && r === m.object) {
+    const s = k.objectKeys(e), i = k.objectKeys(a).filter((o) => s.indexOf(o) !== -1), n = { ...a, ...e };
+    for (const o of i) {
+      const d = qe(a[o], e[o]);
+      if (!d.valid)
+        return { valid: !1 };
+      n[o] = d.data;
+    }
+    return { valid: !0, data: n };
+  } else if (t === m.array && r === m.array) {
+    if (a.length !== e.length)
+      return { valid: !1 };
+    const s = [];
+    for (let i = 0; i < a.length; i++) {
+      const n = a[i], o = e[i], d = qe(n, o);
+      if (!d.valid)
+        return { valid: !1 };
+      s.push(d.data);
+    }
+    return { valid: !0, data: s };
+  } else return t === m.date && r === m.date && +a == +e ? { valid: !0, data: a } : { valid: !1 };
+}
+class be extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e), s = (i, n) => {
+      if (nt(i) || nt(n))
+        return y;
+      const o = qe(i.value, n.value);
+      return o.valid ? ((ot(i) || ot(n)) && t.dirty(), { status: t.value, value: o.data }) : (f(r, {
+        code: l.invalid_intersection_types
+      }), y);
+    };
+    return r.common.async ? Promise.all([
+      this._def.left._parseAsync({
+        data: r.data,
+        path: r.path,
+        parent: r
+      }),
+      this._def.right._parseAsync({
+        data: r.data,
+        path: r.path,
+        parent: r
+      })
+    ]).then(([i, n]) => s(i, n)) : s(this._def.left._parseSync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }), this._def.right._parseSync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }));
+  }
+}
+be.create = (a, e, t) => new be({
+  left: a,
+  right: e,
+  typeName: g.ZodIntersection,
+  ..._(t)
+});
+class K extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.array)
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.array,
+        received: r.parsedType
+      }), y;
+    if (r.data.length < this._def.items.length)
+      return f(r, {
+        code: l.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), y;
+    !this._def.rest && r.data.length > this._def.items.length && (f(r, {
+      code: l.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), t.dirty());
+    const i = [...r.data].map((n, o) => {
+      const d = this._def.items[o] || this._def.rest;
+      return d ? d._parse(new P(r, n, r.path, o)) : null;
+    }).filter((n) => !!n);
+    return r.common.async ? Promise.all(i).then((n) => A.mergeArray(t, n)) : A.mergeArray(t, i);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new K({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+K.create = (a, e) => {
+  if (!Array.isArray(a))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new K({
+    items: a,
+    typeName: g.ZodTuple,
+    rest: null,
+    ..._(e)
+  });
+};
+class ke extends b {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.object)
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.object,
+        received: r.parsedType
+      }), y;
+    const s = [], i = this._def.keyType, n = this._def.valueType;
+    for (const o in r.data)
+      s.push({
+        key: i._parse(new P(r, o, r.path, o)),
+        value: n._parse(new P(r, r.data[o], r.path, o)),
+        alwaysSet: o in r.data
+      });
+    return r.common.async ? A.mergeObjectAsync(t, s) : A.mergeObjectSync(t, s);
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(e, t, r) {
+    return t instanceof b ? new ke({
+      keyType: e,
+      valueType: t,
+      typeName: g.ZodRecord,
+      ..._(r)
+    }) : new ke({
+      keyType: $.create(),
+      valueType: e,
+      typeName: g.ZodRecord,
+      ..._(t)
+    });
+  }
+}
+class ut extends b {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.map)
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.map,
+        received: r.parsedType
+      }), y;
+    const s = this._def.keyType, i = this._def.valueType, n = [...r.data.entries()].map(([o, d], h) => ({
+      key: s._parse(new P(r, o, r.path, [h, "key"])),
+      value: i._parse(new P(r, d, r.path, [h, "value"]))
+    }));
+    if (r.common.async) {
+      const o = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const d of n) {
+          const h = await d.key, x = await d.value;
+          if (h.status === "aborted" || x.status === "aborted")
+            return y;
+          (h.status === "dirty" || x.status === "dirty") && t.dirty(), o.set(h.value, x.value);
+        }
+        return { status: t.value, value: o };
+      });
+    } else {
+      const o = /* @__PURE__ */ new Map();
+      for (const d of n) {
+        const h = d.key, x = d.value;
+        if (h.status === "aborted" || x.status === "aborted")
+          return y;
+        (h.status === "dirty" || x.status === "dirty") && t.dirty(), o.set(h.value, x.value);
+      }
+      return { status: t.value, value: o };
+    }
+  }
+}
+ut.create = (a, e, t) => new ut({
+  valueType: e,
+  keyType: a,
+  typeName: g.ZodMap,
+  ..._(t)
+});
+class de extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.set)
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.set,
+        received: r.parsedType
+      }), y;
+    const s = this._def;
+    s.minSize !== null && r.data.size < s.minSize.value && (f(r, {
+      code: l.too_small,
+      minimum: s.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: s.minSize.message
+    }), t.dirty()), s.maxSize !== null && r.data.size > s.maxSize.value && (f(r, {
+      code: l.too_big,
+      maximum: s.maxSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: s.maxSize.message
+    }), t.dirty());
+    const i = this._def.valueType;
+    function n(d) {
+      const h = /* @__PURE__ */ new Set();
+      for (const x of d) {
+        if (x.status === "aborted")
+          return y;
+        x.status === "dirty" && t.dirty(), h.add(x.value);
+      }
+      return { status: t.value, value: h };
+    }
+    const o = [...r.data.values()].map((d, h) => i._parse(new P(r, d, r.path, h)));
+    return r.common.async ? Promise.all(o).then((d) => n(d)) : n(o);
+  }
+  min(e, t) {
+    return new de({
+      ...this._def,
+      minSize: { value: e, message: p.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new de({
+      ...this._def,
+      maxSize: { value: e, message: p.toString(t) }
+    });
+  }
+  size(e, t) {
+    return this.min(e, t).max(e, t);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+de.create = (a, e) => new de({
+  valueType: a,
+  minSize: null,
+  maxSize: null,
+  typeName: g.ZodSet,
+  ..._(e)
+});
+class Le extends b {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    return this._def.getter()._parse({ data: t.data, path: t.path, parent: t });
+  }
+}
+Le.create = (a, e) => new Le({
+  getter: a,
+  typeName: g.ZodLazy,
+  ..._(e)
+});
+class we extends b {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const t = this._getOrReturnCtx(e);
+      return f(t, {
+        received: t.data,
+        code: l.invalid_literal,
+        expected: this._def.value
+      }), y;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+we.create = (a, e) => new we({
+  value: a,
+  typeName: g.ZodLiteral,
+  ..._(e)
+});
+function kt(a, e) {
+  return new J({
+    values: a,
+    typeName: g.ZodEnum,
+    ..._(e)
+  });
+}
+class J extends b {
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const t = this._getOrReturnCtx(e), r = this._def.values;
+      return f(t, {
+        expected: k.joinValues(r),
+        received: t.parsedType,
+        code: l.invalid_type
+      }), y;
+    }
+    if (this._cache || (this._cache = new Set(this._def.values)), !this._cache.has(e.data)) {
+      const t = this._getOrReturnCtx(e), r = this._def.values;
+      return f(t, {
+        received: t.data,
+        code: l.invalid_enum_value,
+        options: r
+      }), y;
+    }
+    return E(e.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  get Values() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  get Enum() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  extract(e, t = this._def) {
+    return J.create(e, {
+      ...this._def,
+      ...t
+    });
+  }
+  exclude(e, t = this._def) {
+    return J.create(this.options.filter((r) => !e.includes(r)), {
+      ...this._def,
+      ...t
+    });
+  }
+}
+J.create = kt;
+class $e extends b {
+  _parse(e) {
+    const t = k.getValidEnumValues(this._def.values), r = this._getOrReturnCtx(e);
+    if (r.parsedType !== m.string && r.parsedType !== m.number) {
+      const s = k.objectValues(t);
+      return f(r, {
+        expected: k.joinValues(s),
+        received: r.parsedType,
+        code: l.invalid_type
+      }), y;
+    }
+    if (this._cache || (this._cache = new Set(k.getValidEnumValues(this._def.values))), !this._cache.has(e.data)) {
+      const s = k.objectValues(t);
+      return f(r, {
+        received: r.data,
+        code: l.invalid_enum_value,
+        options: s
+      }), y;
+    }
+    return E(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+$e.create = (a, e) => new $e({
+  values: a,
+  typeName: g.ZodNativeEnum,
+  ..._(e)
+});
+class Ne extends b {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== m.promise && t.common.async === !1)
+      return f(t, {
+        code: l.invalid_type,
+        expected: m.promise,
+        received: t.parsedType
+      }), y;
+    const r = t.parsedType === m.promise ? t.data : Promise.resolve(t.data);
+    return E(r.then((s) => this._def.type.parseAsync(s, {
+      path: t.path,
+      errorMap: t.common.contextualErrorMap
+    })));
+  }
+}
+Ne.create = (a, e) => new Ne({
+  type: a,
+  typeName: g.ZodPromise,
+  ..._(e)
+});
+class Q extends b {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === g.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e), s = this._def.effect || null, i = {
+      addIssue: (n) => {
+        f(r, n), n.fatal ? t.abort() : t.dirty();
+      },
+      get path() {
+        return r.path;
+      }
+    };
+    if (i.addIssue = i.addIssue.bind(i), s.type === "preprocess") {
+      const n = s.transform(r.data, i);
+      if (r.common.async)
+        return Promise.resolve(n).then(async (o) => {
+          if (t.value === "aborted")
+            return y;
+          const d = await this._def.schema._parseAsync({
+            data: o,
+            path: r.path,
+            parent: r
+          });
+          return d.status === "aborted" ? y : d.status === "dirty" || t.value === "dirty" ? oe(d.value) : d;
+        });
+      {
+        if (t.value === "aborted")
+          return y;
+        const o = this._def.schema._parseSync({
+          data: n,
+          path: r.path,
+          parent: r
+        });
+        return o.status === "aborted" ? y : o.status === "dirty" || t.value === "dirty" ? oe(o.value) : o;
+      }
+    }
+    if (s.type === "refinement") {
+      const n = (o) => {
+        const d = s.refinement(o, i);
+        if (r.common.async)
+          return Promise.resolve(d);
+        if (d instanceof Promise)
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        return o;
+      };
+      if (r.common.async === !1) {
+        const o = this._def.schema._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        return o.status === "aborted" ? y : (o.status === "dirty" && t.dirty(), n(o.value), { status: t.value, value: o.value });
+      } else
+        return this._def.schema._parseAsync({ data: r.data, path: r.path, parent: r }).then((o) => o.status === "aborted" ? y : (o.status === "dirty" && t.dirty(), n(o.value).then(() => ({ status: t.value, value: o.value }))));
+    }
+    if (s.type === "transform")
+      if (r.common.async === !1) {
+        const n = this._def.schema._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        if (!re(n))
+          return y;
+        const o = s.transform(n.value, i);
+        if (o instanceof Promise)
+          throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+        return { status: t.value, value: o };
+      } else
+        return this._def.schema._parseAsync({ data: r.data, path: r.path, parent: r }).then((n) => re(n) ? Promise.resolve(s.transform(n.value, i)).then((o) => ({
+          status: t.value,
+          value: o
+        })) : y);
+    k.assertNever(s);
+  }
+}
+Q.create = (a, e, t) => new Q({
+  schema: a,
+  typeName: g.ZodEffects,
+  effect: e,
+  ..._(t)
+});
+Q.createWithPreprocess = (a, e, t) => new Q({
+  schema: e,
+  effect: { type: "preprocess", transform: a },
+  typeName: g.ZodEffects,
+  ..._(t)
+});
+class B extends b {
+  _parse(e) {
+    return this._getType(e) === m.undefined ? E(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+B.create = (a, e) => new B({
+  innerType: a,
+  typeName: g.ZodOptional,
+  ..._(e)
+});
+class G extends b {
+  _parse(e) {
+    return this._getType(e) === m.null ? E(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+G.create = (a, e) => new G({
+  innerType: a,
+  typeName: g.ZodNullable,
+  ..._(e)
+});
+class Ce extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    let r = t.data;
+    return t.parsedType === m.undefined && (r = this._def.defaultValue()), this._def.innerType._parse({
+      data: r,
+      path: t.path,
+      parent: t
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+Ce.create = (a, e) => new Ce({
+  innerType: a,
+  typeName: g.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ..._(e)
+});
+class Se extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), r = {
+      ...t,
+      common: {
+        ...t.common,
+        issues: []
+      }
+    }, s = this._def.innerType._parse({
+      data: r.data,
+      path: r.path,
+      parent: {
+        ...r
+      }
+    });
+    return ge(s) ? s.then((i) => ({
+      status: "valid",
+      value: i.status === "valid" ? i.value : this._def.catchValue({
+        get error() {
+          return new U(r.common.issues);
+        },
+        input: r.data
+      })
+    })) : {
+      status: "valid",
+      value: s.status === "valid" ? s.value : this._def.catchValue({
+        get error() {
+          return new U(r.common.issues);
+        },
+        input: r.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+Se.create = (a, e) => new Se({
+  innerType: a,
+  typeName: g.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ..._(e)
+});
+class mt extends b {
+  _parse(e) {
+    if (this._getType(e) !== m.nan) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: l.invalid_type,
+        expected: m.nan,
+        received: r.parsedType
+      }), y;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+mt.create = (a) => new mt({
+  typeName: g.ZodNaN,
+  ..._(a)
+});
+class wt extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), r = t.data;
+    return this._def.type._parse({
+      data: r,
+      path: t.path,
+      parent: t
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+}
+class Ue extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.common.async)
+      return (async () => {
+        const i = await this._def.in._parseAsync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        return i.status === "aborted" ? y : i.status === "dirty" ? (t.dirty(), oe(i.value)) : this._def.out._parseAsync({
+          data: i.value,
+          path: r.path,
+          parent: r
+        });
+      })();
+    {
+      const s = this._def.in._parseSync({
+        data: r.data,
+        path: r.path,
+        parent: r
+      });
+      return s.status === "aborted" ? y : s.status === "dirty" ? (t.dirty(), {
+        status: "dirty",
+        value: s.value
+      }) : this._def.out._parseSync({
+        data: s.value,
+        path: r.path,
+        parent: r
+      });
+    }
+  }
+  static create(e, t) {
+    return new Ue({
+      in: e,
+      out: t,
+      typeName: g.ZodPipeline
+    });
+  }
+}
+class Te extends b {
+  _parse(e) {
+    const t = this._def.innerType._parse(e), r = (s) => (re(s) && (s.value = Object.freeze(s.value)), s);
+    return ge(t) ? t.then((s) => r(s)) : r(t);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+Te.create = (a, e) => new Te({
+  innerType: a,
+  typeName: g.ZodReadonly,
+  ..._(e)
+});
+var g;
+(function(a) {
+  a.ZodString = "ZodString", a.ZodNumber = "ZodNumber", a.ZodNaN = "ZodNaN", a.ZodBigInt = "ZodBigInt", a.ZodBoolean = "ZodBoolean", a.ZodDate = "ZodDate", a.ZodSymbol = "ZodSymbol", a.ZodUndefined = "ZodUndefined", a.ZodNull = "ZodNull", a.ZodAny = "ZodAny", a.ZodUnknown = "ZodUnknown", a.ZodNever = "ZodNever", a.ZodVoid = "ZodVoid", a.ZodArray = "ZodArray", a.ZodObject = "ZodObject", a.ZodUnion = "ZodUnion", a.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", a.ZodIntersection = "ZodIntersection", a.ZodTuple = "ZodTuple", a.ZodRecord = "ZodRecord", a.ZodMap = "ZodMap", a.ZodSet = "ZodSet", a.ZodFunction = "ZodFunction", a.ZodLazy = "ZodLazy", a.ZodLiteral = "ZodLiteral", a.ZodEnum = "ZodEnum", a.ZodEffects = "ZodEffects", a.ZodNativeEnum = "ZodNativeEnum", a.ZodOptional = "ZodOptional", a.ZodNullable = "ZodNullable", a.ZodDefault = "ZodDefault", a.ZodCatch = "ZodCatch", a.ZodPromise = "ZodPromise", a.ZodBranded = "ZodBranded", a.ZodPipeline = "ZodPipeline", a.ZodReadonly = "ZodReadonly";
+})(g || (g = {}));
+const u = $.create, w = ae.create, j = Ze.create, Ve = _e.create, fe = Pe.create;
+z.create;
+const X = F.create, N = T.create, ze = xe.create, Tr = Be.create;
+be.create;
+K.create;
+const ue = ke.create, Ae = we.create, I = J.create;
+Ne.create;
+B.create;
+G.create;
+var le = {
+  colors: {
+    primary: "#6366f1",
+    primaryHover: "#4f46e5",
+    primaryLight: "#e0e7ff",
+    background: "#f8fafc",
+    backgroundSecondary: "#f1f5f9",
+    backgroundTertiary: "#e2e8f0",
+    surface: "#ffffff",
+    surfaceHover: "#f8fafc",
+    border: "#e2e8f0",
+    borderHover: "#a5b4fc",
+    textPrimary: "#0f172a",
+    textSecondary: "#475569",
+    textMuted: "#94a3b8",
+    textInverse: "#ffffff",
+    success: "#10b981",
+    successLight: "#d1fae5",
+    warning: "#f59e0b",
+    warningLight: "#fef3c7",
+    error: "#ef4444",
+    errorLight: "#fee2e2",
+    info: "#3b82f6",
+    infoLight: "#dbeafe"
+  }
+};
+({
+  ...le.colors
+}, {
+  ...le.colors
+}), {
+  ...le.colors
+}, {
+  ...le.colors
+};
+({
+  ...le.colors
+});
+var Dr = I([
+  "string",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "datetime",
+  "email",
+  "phone",
+  "url",
+  "enum"
+]), Nt = I([
+  "required",
+  "email",
+  "phone",
+  "url",
+  "date",
+  "number",
+  "integer",
+  "float",
+  "minLength",
+  "maxLength",
+  "min",
+  "max",
+  "pattern",
+  "enum",
+  "unique",
+  "custom"
+]), Ct = I(["error", "warning", "info"]), Ar = N({
+  type: Nt,
+  params: ue(fe()).optional(),
+  message: u().optional(),
+  severity: Ct.optional().default("error")
+}), Ir = I([
+  "trim",
+  "lowercase",
+  "uppercase",
+  "capitalize",
+  "toNumber",
+  "toDate",
+  "toBoolean",
+  "replace",
+  "custom"
+]), Or = N({
+  type: Ir,
+  params: ue(fe()).optional()
+}), Rr = N({
+  key: u().min(1).max(100),
+  label: u().min(1).max(200),
+  type: Dr,
+  required: j().optional().default(!1),
+  description: u().max(500).optional(),
+  validators: X(Ar).optional(),
+  transform: Or.optional()
+}), Er = N({
+  allowExtraColumns: j().optional().default(!1),
+  skipEmptyRows: j().optional().default(!0),
+  trimWhitespace: j().optional().default(!0),
+  dateFormat: u().optional(),
+  uniqueKeys: X(u()).optional(),
+  maxRows: w().int().positive().optional().default(1e5)
+}), Mr = N({
+  columns: X(Rr).min(1),
+  options: Er.optional()
+});
+I([
+  "created",
+  "file_uploaded",
+  "parsing",
+  "parsed",
+  "mapping",
+  "mapped",
+  "validating",
+  "validated",
+  "editing",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+N({
+  schema: Mr,
+  metadata: ue(fe()).optional()
+});
+var jr = N({
+  sourceColumn: u(),
+  targetKey: u().nullable(),
+  confidence: w().min(0).max(1),
+  isAutoMapped: j(),
+  reasoning: u().optional()
+});
+N({
+  sessionId: u().uuid(),
+  mappings: X(jr)
+});
+N({
+  rowIndex: w().int().nonnegative(),
+  columnKey: u(),
+  value: ze([u(), w(), j(), Ve()]),
+  severity: Ct,
+  validatorType: Nt,
+  message: u(),
+  suggestion: u().optional()
+});
+N({
+  sessionId: u().uuid(),
+  rowIndex: w().int().nonnegative(),
+  columnKey: u(),
+  value: ze([u(), w(), j(), Ve()])
+});
+N({
+  sessionId: u().uuid(),
+  updates: X(
+    N({
+      rowIndex: w().int().nonnegative(),
+      columnKey: u(),
+      value: ze([u(), w(), j(), Ve()])
+    })
+  )
+});
+N({
+  sessionId: u().uuid(),
+  skipInvalidRows: j().optional().default(!1),
+  acknowledgeWarnings: j().optional().default(!1)
+});
+var Zr = /^[ABCEGHJ-NPRSTVXY]\d[ABCEGHJ-NPRSTV-Z][ ]?\d[ABCEGHJ-NPRSTV-Z]\d$/i, Fr = /^[A-Z]{2}\d{6}$/, St = {
+  AB: {
+    code: "AB",
+    name: "Alberta",
+    nameInFrench: "Alberta",
+    isTerritory: !1,
+    licenseFormat: /^\d{6,9}$/,
+    licenseFormatDescription: "6-9 digits",
+    licenseExampleFormat: "123456789"
+  },
+  BC: {
+    code: "BC",
+    name: "British Columbia",
+    nameInFrench: "Colombie-Britannique",
+    isTerritory: !1,
+    licenseFormat: /^\d{7}$/,
+    licenseFormatDescription: "7 digits",
+    licenseExampleFormat: "1234567"
+  },
+  MB: {
+    code: "MB",
+    name: "Manitoba",
+    nameInFrench: "Manitoba",
+    isTerritory: !1,
+    licenseFormat: /^[A-Z]{2}\d{6}[A-Z]?$/,
+    licenseFormatDescription: "2 letters + 6 digits + optional letter",
+    licenseExampleFormat: "AB123456C"
+  },
+  NB: {
+    code: "NB",
+    name: "New Brunswick",
+    nameInFrench: "Nouveau-Brunswick",
+    isTerritory: !1,
+    licenseFormat: /^\d{7}$/,
+    licenseFormatDescription: "7 digits",
+    licenseExampleFormat: "1234567"
+  },
+  NL: {
+    code: "NL",
+    name: "Newfoundland and Labrador",
+    nameInFrench: "Terre-Neuve-et-Labrador",
+    isTerritory: !1,
+    licenseFormat: /^[A-Z]\d{9}$/,
+    licenseFormatDescription: "1 letter + 9 digits",
+    licenseExampleFormat: "A123456789"
+  },
+  NS: {
+    code: "NS",
+    name: "Nova Scotia",
+    nameInFrench: "Nouvelle-Écosse",
+    isTerritory: !1,
+    licenseFormat: /^[A-Z]{5}\d{9}$/,
+    licenseFormatDescription: "5 letters + 9 digits",
+    licenseExampleFormat: "ABCDE123456789"
+  },
+  NT: {
+    code: "NT",
+    name: "Northwest Territories",
+    nameInFrench: "Territoires du Nord-Ouest",
+    isTerritory: !0,
+    licenseFormat: /^\d{6}$/,
+    licenseFormatDescription: "6 digits",
+    licenseExampleFormat: "123456"
+  },
+  NU: {
+    code: "NU",
+    name: "Nunavut",
+    nameInFrench: "Nunavut",
+    isTerritory: !0,
+    licenseFormat: /^\d{6}$/,
+    licenseFormatDescription: "6 digits",
+    licenseExampleFormat: "123456"
+  },
+  ON: {
+    code: "ON",
+    name: "Ontario",
+    nameInFrench: "Ontario",
+    isTerritory: !1,
+    licenseFormat: /^[A-Z]\d{4}-\d{5}-\d{5}$|^[A-Z]\d{14}$/,
+    licenseFormatDescription: "1 letter + 14 digits (with or without dashes)",
+    licenseExampleFormat: "A1234-56789-01234"
+  },
+  PE: {
+    code: "PE",
+    name: "Prince Edward Island",
+    nameInFrench: "Île-du-Prince-Édouard",
+    isTerritory: !1,
+    licenseFormat: /^\d{5,6}$/,
+    licenseFormatDescription: "5-6 digits",
+    licenseExampleFormat: "123456"
+  },
+  QC: {
+    code: "QC",
+    name: "Quebec",
+    nameInFrench: "Québec",
+    isTerritory: !1,
+    licenseFormat: /^[A-Z]\d{12}$/,
+    licenseFormatDescription: "1 letter + 12 digits",
+    licenseExampleFormat: "A123456789012"
+  },
+  SK: {
+    code: "SK",
+    name: "Saskatchewan",
+    nameInFrench: "Saskatchewan",
+    isTerritory: !1,
+    licenseFormat: /^\d{8}$/,
+    licenseFormatDescription: "8 digits",
+    licenseExampleFormat: "12345678"
+  },
+  YT: {
+    code: "YT",
+    name: "Yukon",
+    nameInFrench: "Yukon",
+    isTerritory: !0,
+    licenseFormat: /^\d{6}$/,
+    licenseFormatDescription: "6 digits",
+    licenseExampleFormat: "123456"
+  }
+};
+Object.fromEntries(
+  Object.entries(St).map(([a, e]) => [a, e.name])
+);
+var Tt = I([
+  "AB",
+  "BC",
+  "MB",
+  "NB",
+  "NL",
+  "NS",
+  "NT",
+  "NU",
+  "ON",
+  "PE",
+  "QC",
+  "SK",
+  "YT"
+]), Dt = N({
+  streetLine1: u().min(1).max(200),
+  streetLine2: u().max(200).optional(),
+  city: u().min(1).max(100),
+  province: Tt,
+  postalCode: u().regex(Zr, "Invalid Canadian postal code format (A1A 1A1)"),
+  country: Ae("Canada")
+}), Ye = I(["passport", "drivers_license", "proof_of_address"]), Pr = I(["uploaded", "processing", "completed", "failed", "requires_review"]), qr = I(["excellent", "good", "fair", "poor"]), Lr = I(["tesseract", "textract", "gpt4vision"]), At = I(["M", "F", "X"]), $r = I([
+  "image_manipulation",
+  "poor_quality",
+  "inconsistent_data",
+  "expired_document",
+  "invalid_format",
+  "suspicious_pattern",
+  "missing_security_features",
+  "document_tampering"
+]), Br = I(["high", "medium", "low"]), Ur = N({
+  type: $r,
+  severity: Br,
+  message: u(),
+  field: u().optional(),
+  details: ue(fe()).optional()
+}), Vr = N({
+  fullName: w().min(0).max(1),
+  passportNumber: w().min(0).max(1),
+  dateOfBirth: w().min(0).max(1),
+  dateOfIssue: w().min(0).max(1),
+  dateOfExpiry: w().min(0).max(1),
+  placeOfBirth: w().min(0).max(1),
+  sex: w().min(0).max(1),
+  nationality: w().min(0).max(1)
+}), zr = N({
+  documentType: Ae("passport"),
+  fullName: u().min(1),
+  givenNames: u().min(1),
+  surname: u().min(1),
+  passportNumber: u().regex(Fr, "Invalid Canadian passport number (format: AB123456)"),
+  dateOfBirth: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+  dateOfIssue: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+  dateOfExpiry: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+  placeOfBirth: u().min(1),
+  sex: At,
+  nationality: u().min(1),
+  photoBase64: u().optional(),
+  mrzLine1: u().optional(),
+  mrzLine2: u().optional(),
+  confidence: Vr
+}), Yr = N({
+  fullName: w().min(0).max(1),
+  licenseNumber: w().min(0).max(1),
+  dateOfBirth: w().min(0).max(1),
+  expiryDate: w().min(0).max(1),
+  address: w().min(0).max(1),
+  province: w().min(0).max(1),
+  licenseClass: w().min(0).max(1)
+}), It = N({
+  documentType: Ae("drivers_license"),
+  fullName: u().min(1),
+  firstName: u().min(1),
+  lastName: u().min(1),
+  middleName: u().optional(),
+  licenseNumber: u().min(1),
+  dateOfBirth: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+  expiryDate: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+  issueDate: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional(),
+  address: Dt,
+  province: Tt,
+  licenseClass: u().min(1),
+  restrictions: u().optional(),
+  endorsements: u().optional(),
+  sex: At.optional(),
+  height: u().optional(),
+  eyeColor: u().optional(),
+  photoBase64: u().optional(),
+  confidence: Yr
+});
+It.refine(
+  (a) => St[a.province].licenseFormat.test(a.licenseNumber),
+  {
+    message: "License number format doesn't match the province requirements",
+    path: ["licenseNumber"]
+  }
+);
+var Wr = I([
+  "utility_bill",
+  "bank_statement",
+  "government_letter",
+  "tax_statement",
+  "lease_agreement",
+  "insurance_statement",
+  "other"
+]), Hr = N({
+  fullName: w().min(0).max(1),
+  address: w().min(0).max(1),
+  documentSubType: w().min(0).max(1),
+  issuer: w().min(0).max(1),
+  documentDate: w().min(0).max(1)
+}), Ot = N({
+  documentType: Ae("proof_of_address"),
+  fullName: u().min(1),
+  address: Dt,
+  documentSubType: Wr,
+  issuer: u().min(1),
+  documentDate: u().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+  accountNumber: u().max(4).optional(),
+  // Last 4 digits only
+  statementPeriod: N({
+    start: u(),
+    end: u()
+  }).optional(),
+  confidence: Hr
+});
+Ot.refine(
+  (a) => {
+    const e = new Date(a.documentDate);
+    return ((/* @__PURE__ */ new Date()).getTime() - e.getTime()) / (1e3 * 60 * 60 * 24) <= 90;
+  },
+  {
+    message: "Proof of address must be dated within the last 90 days",
+    path: ["documentDate"]
+  }
+);
+var Kr = Tr("documentType", [
+  zr,
+  It,
+  Ot
+]);
+I([
+  "created",
+  "documents_pending",
+  "processing",
+  "review_required",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+N({
+  requiredDocuments: X(Ye).min(1),
+  metadata: ue(fe()).optional()
+});
+N({
+  sessionId: u().uuid(),
+  documentType: Ye
+});
+N({
+  id: u().uuid(),
+  sessionId: u().uuid(),
+  type: Ye,
+  status: Pr,
+  uploadedAt: u().datetime(),
+  processedAt: u().datetime().optional(),
+  originalFilename: u(),
+  fileSize: w().int().positive(),
+  mimeType: u(),
+  s3Key: u(),
+  extractedData: Kr.optional(),
+  confidence: w().min(0).max(1),
+  ocrQuality: qr,
+  fraudFlags: X(Ur),
+  processingTimeMs: w().int().optional(),
+  ocrProvider: Lr.optional(),
+  aiModel: u().optional()
+});
+N({
+  sessionId: u().uuid(),
+  acceptWarnings: j().optional().default(!1)
+});
+var pt = ["payment", "payout", "subscription"], De = [
+  "credit_card",
+  "digital_cheque",
+  "etransfer_request_money",
+  "etransfer_standard",
+  "interac_online",
+  "online_banking",
+  "apple_pay",
+  "google_pay",
+  "ach_payment",
+  "etransfer_send_money",
+  "visa_direct",
+  "credit_send",
+  "master_card_send",
+  "direct_deposit",
+  "rtp_payout",
+  "ach_payout",
+  "wire_transfer"
+], ht = ["digital", "physical"], yt = ["daily", "weekly", "monthly", "yearly"], Rt = [
+  {
+    key: "sid",
+    label: "Site ID",
+    type: "integer",
+    required: !0,
+    description: "Your site's unique ID (whole number)",
+    validators: [
+      { type: "required", message: "Site ID is required" },
+      { type: "integer", message: "Site ID must be a whole number" },
+      { type: "min", params: { value: 1 }, message: "Site ID must be a positive number" }
+    ]
+  },
+  {
+    key: "type",
+    label: "Transaction Type",
+    type: "enum",
+    required: !0,
+    description: "Type of transaction: payment, payout, or subscription",
+    validators: [
+      { type: "required", message: "Transaction type is required" },
+      {
+        type: "enum",
+        params: { values: pt },
+        message: `Transaction type must be one of: ${pt.join(", ")}`
+      }
+    ],
+    transform: { type: "lowercase" }
+  },
+  {
+    key: "methods",
+    label: "Payment Methods",
+    type: "string",
+    required: !0,
+    description: "Payment methods (comma-separated): credit_card, interac_online, etc.",
+    validators: [
+      { type: "required", message: "At least one payment method is required" },
+      {
+        type: "custom",
+        params: {
+          validatorName: "commaSeparatedEnum",
+          allowedValues: De
+        },
+        message: `Payment methods must be comma-separated values from: ${De.join(", ")}`
+      }
+    ],
+    transform: { type: "lowercase" }
+  },
+  {
+    key: "email",
+    label: "Customer Email",
+    type: "email",
+    required: !0,
+    description: "Customer's email address",
+    validators: [
+      { type: "required", message: "Customer email is required" },
+      { type: "email", message: "Must be a valid email address" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "item_name",
+    label: "Item Name",
+    type: "string",
+    required: !0,
+    description: "Name of the product or service",
+    validators: [
+      { type: "required", message: "Item name is required" },
+      { type: "minLength", params: { value: 1 }, message: "Item name cannot be empty" },
+      { type: "maxLength", params: { value: 255 }, message: "Item name must be 255 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "item_quantity",
+    label: "Item Quantity",
+    type: "integer",
+    required: !0,
+    description: "Number of items (whole number)",
+    validators: [
+      { type: "required", message: "Item quantity is required" },
+      { type: "integer", message: "Item quantity must be a whole number" },
+      { type: "min", params: { value: 1 }, message: "Item quantity must be at least 1" }
+    ]
+  },
+  {
+    key: "item_unit_price",
+    label: "Item Unit Price",
+    type: "float",
+    required: !0,
+    description: "Price per item (decimal number, no currency symbols)",
+    validators: [
+      { type: "required", message: "Item unit price is required" },
+      { type: "float", message: "Item unit price must be a number" },
+      { type: "min", params: { value: 0 }, message: "Item unit price cannot be negative" },
+      {
+        type: "pattern",
+        params: { regex: "^[0-9]+(\\.[0-9]{1,2})?$" },
+        message: "Item unit price must be a number with up to 2 decimal places (no currency symbols)",
+        severity: "warning"
+      }
+    ]
+  },
+  {
+    key: "item_type",
+    label: "Item Type",
+    type: "enum",
+    required: !0,
+    description: "Type of item: digital or physical",
+    validators: [
+      { type: "required", message: "Item type is required" },
+      {
+        type: "enum",
+        params: { values: ht },
+        message: `Item type must be one of: ${ht.join(", ")}`
+      }
+    ],
+    transform: { type: "lowercase" }
+  },
+  {
+    key: "udf1",
+    label: "Custom Reference (UDF1)",
+    type: "string",
+    required: !0,
+    description: "Your internal reference (invoice number, order ID, etc.)",
+    validators: [
+      { type: "required", message: "Custom reference (UDF1) is required" },
+      { type: "maxLength", params: { value: 255 }, message: "Custom reference must be 255 characters or less" }
+    ],
+    transform: { type: "trim" }
+  }
+], Jr = [
+  {
+    key: "preferred_method",
+    label: "Preferred Payment Method",
+    type: "enum",
+    required: !1,
+    description: "Default payment method selected for customer",
+    validators: [
+      {
+        type: "enum",
+        params: { values: De },
+        message: `Preferred method must be one of: ${De.join(", ")}`
+      }
+    ],
+    transform: { type: "lowercase" }
+  }
+], Qr = [
+  {
+    key: "phone",
+    label: "Phone Number",
+    type: "phone",
+    required: !1,
+    description: "Customer phone number",
+    validators: [
+      { type: "phone", message: "Must be a valid phone number", severity: "warning" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_first_name",
+    label: "Billing First Name",
+    type: "string",
+    required: !1,
+    description: "Customer billing first name",
+    validators: [
+      { type: "maxLength", params: { value: 100 }, message: "First name must be 100 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_last_name",
+    label: "Billing Last Name",
+    type: "string",
+    required: !1,
+    description: "Customer billing last name",
+    validators: [
+      { type: "maxLength", params: { value: 100 }, message: "Last name must be 100 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_address",
+    label: "Billing Address",
+    type: "string",
+    required: !1,
+    description: "Customer billing street address",
+    validators: [
+      { type: "maxLength", params: { value: 255 }, message: "Address must be 255 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_unit_number",
+    label: "Billing Unit Number",
+    type: "string",
+    required: !1,
+    description: "Apartment, suite, or unit number",
+    validators: [
+      { type: "maxLength", params: { value: 50 }, message: "Unit number must be 50 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_city",
+    label: "Billing City",
+    type: "string",
+    required: !1,
+    description: "Customer billing city",
+    validators: [
+      { type: "maxLength", params: { value: 100 }, message: "City must be 100 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_state",
+    label: "Billing State/Province",
+    type: "string",
+    required: !1,
+    description: "State or province code (e.g., ON, BC, CA)",
+    validators: [
+      { type: "maxLength", params: { value: 50 }, message: "State/Province must be 50 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_country",
+    label: "Billing Country",
+    type: "string",
+    required: !1,
+    description: "Country name or code",
+    validators: [
+      { type: "maxLength", params: { value: 100 }, message: "Country must be 100 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_zip_code",
+    label: "Billing Postal/ZIP Code",
+    type: "string",
+    required: !1,
+    description: "Postal or ZIP code",
+    validators: [
+      { type: "maxLength", params: { value: 20 }, message: "Postal code must be 20 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_company",
+    label: "Billing Company",
+    type: "string",
+    required: !1,
+    description: "Company or business name",
+    validators: [
+      { type: "maxLength", params: { value: 255 }, message: "Company name must be 255 characters or less" }
+    ],
+    transform: { type: "trim" }
+  }
+], Gr = [
+  {
+    key: "shipping_first_name",
+    label: "Shipping First Name",
+    type: "string",
+    required: !1,
+    description: "Shipping recipient first name",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_last_name",
+    label: "Shipping Last Name",
+    type: "string",
+    required: !1,
+    description: "Shipping recipient last name",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_address",
+    label: "Shipping Address",
+    type: "string",
+    required: !1,
+    description: "Shipping street address",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_unit_number",
+    label: "Shipping Unit Number",
+    type: "string",
+    required: !1,
+    description: "Shipping apartment, suite, or unit number",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_city",
+    label: "Shipping City",
+    type: "string",
+    required: !1,
+    description: "Shipping city",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_state",
+    label: "Shipping State/Province",
+    type: "string",
+    required: !1,
+    description: "Shipping state or province",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_country",
+    label: "Shipping Country",
+    type: "string",
+    required: !1,
+    description: "Shipping country",
+    transform: { type: "trim" }
+  },
+  {
+    key: "shipping_zip_code",
+    label: "Shipping Postal/ZIP Code",
+    type: "string",
+    required: !1,
+    description: "Shipping postal or ZIP code",
+    transform: { type: "trim" }
+  }
+], Xr = [
+  {
+    key: "item_description",
+    label: "Item Description",
+    type: "string",
+    required: !1,
+    description: "Detailed description of the item",
+    validators: [
+      { type: "maxLength", params: { value: 1e3 }, message: "Description must be 1000 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "item_sku",
+    label: "Item SKU",
+    type: "string",
+    required: !1,
+    description: "Product SKU or identifier",
+    validators: [
+      { type: "maxLength", params: { value: 100 }, message: "SKU must be 100 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "item_image_url",
+    label: "Item Image URL",
+    type: "url",
+    required: !1,
+    description: "URL to product image (must start with http:// or https://)",
+    validators: [
+      { type: "url", message: "Must be a valid URL starting with http:// or https://" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "additional_items",
+    label: "Additional Items",
+    type: "string",
+    required: !1,
+    description: "Additional items in JSON format",
+    transform: { type: "trim" }
+  }
+], ea = [
+  {
+    key: "email_recipients",
+    label: "Email Recipients",
+    type: "string",
+    required: !1,
+    description: "Additional email recipients for notifications",
+    validators: [
+      {
+        type: "custom",
+        params: { validatorName: "commaSeparatedEmails" },
+        message: "Must be valid comma-separated email addresses",
+        severity: "warning"
+      }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "phone_recipients",
+    label: "Phone Recipients",
+    type: "string",
+    required: !1,
+    description: "SMS notification recipients",
+    transform: { type: "trim" }
+  },
+  {
+    key: "notification_info",
+    label: "Notification Info",
+    type: "string",
+    required: !1,
+    description: "Additional notification information",
+    transform: { type: "trim" }
+  }
+], ta = [
+  {
+    key: "subscription_amount",
+    label: "Subscription Amount",
+    type: "float",
+    required: !1,
+    description: "Recurring subscription amount",
+    validators: [
+      { type: "float", message: "Subscription amount must be a number" },
+      { type: "min", params: { value: 0 }, message: "Amount cannot be negative" }
+    ]
+  },
+  {
+    key: "billing_cycle_interval",
+    label: "Billing Cycle Interval",
+    type: "enum",
+    required: !1,
+    description: "Billing frequency: daily, weekly, monthly, yearly",
+    validators: [
+      {
+        type: "enum",
+        params: { values: yt },
+        message: `Billing interval must be one of: ${yt.join(", ")}`
+      }
+    ],
+    transform: { type: "lowercase" }
+  },
+  {
+    key: "billing_cycle_interval_count",
+    label: "Billing Cycle Count",
+    type: "integer",
+    required: !1,
+    description: "Number of intervals between billing",
+    validators: [
+      { type: "integer", message: "Must be a whole number" },
+      { type: "min", params: { value: 1 }, message: "Must be at least 1" }
+    ]
+  },
+  {
+    key: "billing_cycle_month",
+    label: "Billing Cycle Month",
+    type: "integer",
+    required: !1,
+    description: "Month for yearly billing (1-12)",
+    validators: [
+      { type: "integer", message: "Must be a whole number" },
+      { type: "min", params: { value: 1 }, message: "Month must be 1-12" },
+      { type: "max", params: { value: 12 }, message: "Month must be 1-12" }
+    ]
+  },
+  {
+    key: "billing_cycle_week",
+    label: "Billing Cycle Week",
+    type: "integer",
+    required: !1,
+    description: "Week number for billing",
+    validators: [
+      { type: "integer", message: "Must be a whole number" }
+    ]
+  },
+  {
+    key: "billing_cycle_day_of_month",
+    label: "Billing Day of Month",
+    type: "integer",
+    required: !1,
+    description: "Day of month for billing (1-31)",
+    validators: [
+      { type: "integer", message: "Must be a whole number" },
+      { type: "min", params: { value: 1 }, message: "Day must be 1-31" },
+      { type: "max", params: { value: 31 }, message: "Day must be 1-31" }
+    ]
+  },
+  {
+    key: "billing_cycle_day_of_week",
+    label: "Billing Day of Week",
+    type: "integer",
+    required: !1,
+    description: "Day of week for billing (0=Sunday, 6=Saturday)",
+    validators: [
+      { type: "integer", message: "Must be a whole number" },
+      { type: "min", params: { value: 0 }, message: "Day must be 0-6" },
+      { type: "max", params: { value: 6 }, message: "Day must be 0-6" }
+    ]
+  },
+  {
+    key: "billing_cycle_expression",
+    label: "Billing Cycle Expression",
+    type: "string",
+    required: !1,
+    description: "Cron expression for custom billing schedule",
+    transform: { type: "trim" }
+  },
+  {
+    key: "billing_cycle_weekday",
+    label: "Billing Cycle Weekday",
+    type: "boolean",
+    required: !1,
+    description: "Whether to bill only on weekdays"
+  },
+  {
+    key: "billing_cycle_start_at",
+    label: "Billing Cycle Start Date",
+    type: "datetime",
+    required: !1,
+    description: "Start date for billing cycle (ISO 8601 format)",
+    validators: [
+      { type: "date", message: "Must be a valid date/time" }
+    ]
+  }
+], ra = [
+  {
+    key: "return_url",
+    label: "Return URL",
+    type: "url",
+    required: !1,
+    description: "URL to redirect after successful payment",
+    validators: [
+      { type: "url", message: "Must be a valid URL starting with http:// or https://" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "failed_return_url",
+    label: "Failed Return URL",
+    type: "url",
+    required: !1,
+    description: "URL to redirect after failed payment",
+    validators: [
+      { type: "url", message: "Must be a valid URL starting with http:// or https://" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "merchant_ntf_url",
+    label: "Merchant Notification URL",
+    type: "url",
+    required: !1,
+    description: "Webhook URL for payment notifications",
+    validators: [
+      { type: "url", message: "Must be a valid URL starting with http:// or https://" }
+    ],
+    transform: { type: "trim" }
+  }
+], aa = [
+  {
+    key: "convinience_fee",
+    label: "Convenience Fee",
+    type: "float",
+    required: !1,
+    description: "Additional convenience fee amount",
+    validators: [
+      { type: "float", message: "Fee must be a number" },
+      { type: "min", params: { value: 0 }, message: "Fee cannot be negative" }
+    ]
+  },
+  {
+    key: "udf2",
+    label: "Custom Field 2 (UDF2)",
+    type: "string",
+    required: !1,
+    description: "Additional custom reference field",
+    validators: [
+      { type: "maxLength", params: { value: 255 }, message: "Must be 255 characters or less" }
+    ],
+    transform: { type: "trim" }
+  },
+  {
+    key: "udf3",
+    label: "Custom Field 3 (UDF3)",
+    type: "string",
+    required: !1,
+    description: "Additional custom reference field",
+    validators: [
+      { type: "maxLength", params: { value: 255 }, message: "Must be 255 characters or less" }
+    ],
+    transform: { type: "trim" }
+  }
+], sa = {
+  columns: [
+    ...Rt,
+    ...Jr,
+    ...Qr,
+    ...Gr,
+    ...Xr,
+    ...ea,
+    ...ta,
+    ...ra,
+    ...aa
+  ]
+};
+Rt.map((a) => a.key);
+sa.columns.map((a) => a.key);
+var We = {
+  passport: {
+    type: "passport",
+    label: "Canadian Passport",
+    description: "A valid Canadian passport (not expired)",
+    acceptedFormats: [".pdf", ".jpg", ".jpeg", ".png"],
+    maxFileSize: 10 * 1024 * 1024,
+    // 10MB
+    estimatedProcessingTime: 8,
+    requiredFields: [
+      "fullName",
+      "passportNumber",
+      "dateOfBirth",
+      "dateOfIssue",
+      "dateOfExpiry",
+      "placeOfBirth",
+      "sex",
+      "nationality"
+    ]
+  },
+  drivers_license: {
+    type: "drivers_license",
+    label: "Canadian Driver's License",
+    description: "A valid Canadian provincial or territorial driver's license",
+    acceptedFormats: [".pdf", ".jpg", ".jpeg", ".png"],
+    maxFileSize: 10 * 1024 * 1024,
+    // 10MB
+    estimatedProcessingTime: 8,
+    requiredFields: [
+      "fullName",
+      "licenseNumber",
+      "dateOfBirth",
+      "expiryDate",
+      "address",
+      "province",
+      "licenseClass"
+    ]
+  },
+  proof_of_address: {
+    type: "proof_of_address",
+    label: "Proof of Address",
+    description: "A document showing your current Canadian address (dated within 90 days)",
+    acceptedFormats: [".pdf", ".jpg", ".jpeg", ".png"],
+    maxFileSize: 10 * 1024 * 1024,
+    // 10MB
+    estimatedProcessingTime: 10,
+    requiredFields: ["fullName", "address", "documentSubType", "issuer", "documentDate"]
+  }
+};
+const ia = ({
+  documentType: a,
+  onFileSelect: e
+}) => {
+  const { documents: t, setDocumentFile: r, isLoading: s } = ye(), i = t.get(a), n = We[a], o = gt(
+    (D, He) => {
+      if (!(He.length > 0) && D.length > 0) {
+        const Z = D[0];
+        r(a, Z), e == null || e(Z);
+      }
+    },
+    [a, e, r]
+  ), { getRootProps: d, getInputProps: h, isDragActive: x } = Kt({
+    onDrop: o,
+    accept: {
+      "application/pdf": [".pdf"],
+      "image/jpeg": [".jpg", ".jpeg"],
+      "image/png": [".png"]
+    },
+    maxSize: n.maxFileSize,
+    multiple: !1,
+    disabled: s
+  }), M = (D) => D < 1024 ? `${D} B` : D < 1024 * 1024 ? `${(D / 1024).toFixed(1)} KB` : `${(D / (1024 * 1024)).toFixed(1)} MB`, ie = () => {
+    var D;
+    return ((D = i == null ? void 0 : i.file) == null ? void 0 : D.type) === "application/pdf" ? /* @__PURE__ */ c(_t, { className: "ff-w-6 ff-h-6" }) : /* @__PURE__ */ c(tr, { className: "ff-w-6 ff-h-6" });
+  }, Ie = (D) => {
+    D.stopPropagation(), ye.getState().clearDocumentPreview(a), r(a, null);
+  };
+  return i != null && i.file && i.previewUrl ? /* @__PURE__ */ v("div", { className: "ff-space-y-4", children: [
+    /* @__PURE__ */ c("div", { className: "ff-bg-primary-50 ff-border ff-border-primary-200 ff-rounded-lg ff-p-4", children: /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-gap-3", children: [
+      /* @__PURE__ */ c("div", { className: "ff-p-2 ff-bg-primary-100 ff-rounded-lg ff-text-primary-600", children: ie() }),
+      /* @__PURE__ */ v("div", { className: "ff-flex-1 ff-min-w-0", children: [
+        /* @__PURE__ */ c("p", { className: "ff-font-medium ff-text-primary-900 ff-truncate", children: i.file.name }),
+        /* @__PURE__ */ c("p", { className: "ff-text-sm ff-text-primary-600", children: M(i.file.size) })
+      ] }),
+      /* @__PURE__ */ c(
+        "button",
+        {
+          onClick: Ie,
+          className: "ff-p-1.5 ff-text-primary-600 hover:ff-text-primary-800 hover:ff-bg-primary-100 ff-rounded-full ff-transition-colors",
+          "aria-label": "Remove file",
+          children: /* @__PURE__ */ c(vt, { className: "ff-w-5 ff-h-5" })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ c("div", { className: "ff-document-preview ff-aspect-[3/4] ff-max-h-96", children: i.file.type === "application/pdf" ? /* @__PURE__ */ c(
+      "iframe",
+      {
+        src: i.previewUrl,
+        className: "ff-w-full ff-h-full ff-rounded-lg",
+        title: "Document preview"
+      }
+    ) : /* @__PURE__ */ c(
+      "img",
+      {
+        src: i.previewUrl,
+        alt: "Document preview",
+        className: "ff-w-full ff-h-full ff-object-contain ff-rounded-lg"
+      }
+    ) })
+  ] }) : /* @__PURE__ */ v("div", { className: "ff-space-y-4", children: [
+    /* @__PURE__ */ v("div", { className: "ff-text-center ff-mb-4", children: [
+      /* @__PURE__ */ c("h3", { className: "ff-text-lg ff-font-semibold ff-text-gray-900", children: n.label }),
+      /* @__PURE__ */ c("p", { className: "ff-text-sm ff-text-gray-500 ff-mt-1", children: n.description })
+    ] }),
+    /* @__PURE__ */ v(
+      "div",
+      {
+        ...d(),
+        className: R(
+          "ff-dropzone ff-min-h-[200px]",
+          x && "ff-dropzone-active",
+          s && "ff-opacity-50 ff-cursor-not-allowed"
+        ),
+        children: [
+          /* @__PURE__ */ c("input", { ...h() }),
+          /* @__PURE__ */ v("div", { className: "ff-flex ff-flex-col ff-items-center ff-gap-4", children: [
+            /* @__PURE__ */ c(
+              "div",
+              {
+                className: R(
+                  "ff-p-4 ff-rounded-full",
+                  x ? "ff-bg-primary-100" : "ff-bg-gray-100"
+                ),
+                children: /* @__PURE__ */ c(
+                  Jt,
+                  {
+                    className: R(
+                      "ff-w-10 ff-h-10",
+                      x ? "ff-text-primary-600" : "ff-text-gray-400"
+                    )
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ v("div", { className: "ff-text-center", children: [
+              /* @__PURE__ */ c("p", { className: "ff-text-base ff-font-medium ff-text-gray-700", children: x ? "Drop your document here" : "Upload your document" }),
+              /* @__PURE__ */ v("p", { className: "ff-text-sm ff-text-gray-500 ff-mt-1", children: [
+                "Drag & drop or",
+                " ",
+                /* @__PURE__ */ c("span", { className: "ff-text-primary-600 ff-font-medium", children: "browse files" })
+              ] })
+            ] }),
+            /* @__PURE__ */ v("div", { className: "ff-flex ff-flex-wrap ff-justify-center ff-gap-2 ff-text-xs ff-text-gray-400", children: [
+              n.acceptedFormats.map((D) => /* @__PURE__ */ c("span", { className: "ff-px-2 ff-py-1 ff-bg-gray-100 ff-rounded", children: D.toUpperCase() }, D)),
+              /* @__PURE__ */ v("span", { className: "ff-px-2 ff-py-1", children: [
+                "Max ",
+                M(n.maxFileSize)
+              ] })
+            ] })
+          ] })
+        ]
+      }
+    ),
+    (i == null ? void 0 : i.error) && /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-gap-2 ff-p-3 ff-bg-error-50 ff-text-error-700 ff-rounded-lg", children: [
+      /* @__PURE__ */ c(Qt, { className: "ff-w-4 ff-h-4 ff-flex-shrink-0" }),
+      /* @__PURE__ */ c("p", { className: "ff-text-sm", children: i.error })
+    ] }),
+    /* @__PURE__ */ v("div", { className: "ff-bg-gray-50 ff-rounded-lg ff-p-4", children: [
+      /* @__PURE__ */ c("h4", { className: "ff-text-sm ff-font-medium ff-text-gray-700 ff-mb-2", children: "Tips for best results:" }),
+      /* @__PURE__ */ v("ul", { className: "ff-text-sm ff-text-gray-500 ff-space-y-1 ff-list-disc ff-list-inside", children: [
+        /* @__PURE__ */ c("li", { children: "Ensure all text is clearly visible and readable" }),
+        /* @__PURE__ */ c("li", { children: "Avoid glare, shadows, or blurry images" }),
+        /* @__PURE__ */ c("li", { children: "Include all four corners of the document" }),
+        /* @__PURE__ */ c("li", { children: "Use good lighting when taking photos" })
+      ] })
+    ] })
+  ] });
+}, na = ({
+  documentType: a,
+  showDetails: e = !0
+}) => {
+  const { documents: t } = ye(), r = t.get(a), s = We[a], n = ((d) => {
+    switch (d) {
+      case "completed":
+        return {
+          icon: Me,
+          color: "ff-text-success-600",
+          bgColor: "ff-bg-success-100",
+          label: "Verified",
+          description: "Document successfully processed"
+        };
+      case "requires_review":
+        return {
+          icon: et,
+          color: "ff-text-warning-600",
+          bgColor: "ff-bg-warning-100",
+          label: "Review Required",
+          description: "Manual verification may be needed"
+        };
+      case "failed":
+        return {
+          icon: Xe,
+          color: "ff-text-error-600",
+          bgColor: "ff-bg-error-100",
+          label: "Failed",
+          description: "Unable to process document"
+        };
+      case "processing":
+        return {
+          icon: Ee,
+          color: "ff-text-primary-600",
+          bgColor: "ff-bg-primary-100",
+          label: "Processing",
+          description: "Analyzing document..."
+        };
+      case "uploaded":
+        return {
+          icon: tt,
+          color: "ff-text-gray-600",
+          bgColor: "ff-bg-gray-100",
+          label: "Pending",
+          description: "Waiting to be processed"
+        };
+      default:
+        return {
+          icon: tt,
+          color: "ff-text-gray-400",
+          bgColor: "ff-bg-gray-100",
+          label: "Not Uploaded",
+          description: "Upload document to continue"
+        };
+    }
+  })(r == null ? void 0 : r.status), o = n.icon;
+  return /* @__PURE__ */ v("div", { className: "ff-space-y-3", children: [
+    /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-gap-3", children: [
+      /* @__PURE__ */ c("div", { className: R("ff-p-2 ff-rounded-lg", n.bgColor), children: /* @__PURE__ */ c(
+        o,
+        {
+          className: R(
+            "ff-w-5 ff-h-5",
+            n.color,
+            (r == null ? void 0 : r.status) === "processing" && "ff-animate-spin"
+          )
+        }
+      ) }),
+      /* @__PURE__ */ v("div", { children: [
+        /* @__PURE__ */ c("p", { className: "ff-font-medium ff-text-gray-900", children: s.label }),
+        /* @__PURE__ */ c("p", { className: R("ff-text-sm", n.color), children: n.label })
+      ] })
+    ] }),
+    (r == null ? void 0 : r.confidence) !== void 0 && r.confidence > 0 && /* @__PURE__ */ v("div", { className: "ff-space-y-1", children: [
+      /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-justify-between ff-text-sm", children: [
+        /* @__PURE__ */ c("span", { className: "ff-text-gray-600", children: "Confidence" }),
+        /* @__PURE__ */ v(
+          "span",
+          {
+            className: R(
+              "ff-font-medium",
+              r.confidence >= 0.8 && "ff-text-success-600",
+              r.confidence >= 0.6 && r.confidence < 0.8 && "ff-text-warning-600",
+              r.confidence < 0.6 && "ff-text-error-600"
+            ),
+            children: [
+              Math.round(r.confidence * 100),
+              "%"
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ c("div", { className: "ff-progress", children: /* @__PURE__ */ c(
+        "div",
+        {
+          className: R(
+            "ff-progress-bar",
+            r.confidence >= 0.8 && "ff-bg-success-500",
+            r.confidence >= 0.6 && r.confidence < 0.8 && "ff-bg-warning-500",
+            r.confidence < 0.6 && "ff-bg-error-500"
+          ),
+          style: { width: `${r.confidence * 100}%` }
+        }
+      ) })
+    ] }),
+    e && (r == null ? void 0 : r.fraudFlags) && r.fraudFlags.length > 0 && /* @__PURE__ */ v("div", { className: "ff-space-y-2", children: [
+      /* @__PURE__ */ c("p", { className: "ff-text-sm ff-font-medium ff-text-gray-700", children: "Issues Detected" }),
+      /* @__PURE__ */ c("div", { className: "ff-space-y-1", children: r.fraudFlags.map((d, h) => /* @__PURE__ */ v(
+        "div",
+        {
+          className: R(
+            "ff-flex ff-items-start ff-gap-2 ff-p-2 ff-rounded ff-text-sm",
+            d.severity === "high" && "ff-bg-error-50 ff-text-error-700",
+            d.severity === "medium" && "ff-bg-warning-50 ff-text-warning-700",
+            d.severity === "low" && "ff-bg-gray-50 ff-text-gray-600"
+          ),
+          children: [
+            d.severity === "high" ? /* @__PURE__ */ c(Xe, { className: "ff-w-4 ff-h-4 ff-flex-shrink-0 ff-mt-0.5" }) : /* @__PURE__ */ c(et, { className: "ff-w-4 ff-h-4 ff-flex-shrink-0 ff-mt-0.5" }),
+            /* @__PURE__ */ c("span", { children: d.message })
+          ]
+        },
+        h
+      )) })
+    ] }),
+    e && (r == null ? void 0 : r.extractedData) && r.status === "completed" && /* @__PURE__ */ v("div", { className: "ff-bg-gray-50 ff-rounded-lg ff-p-3", children: [
+      /* @__PURE__ */ c("p", { className: "ff-text-sm ff-font-medium ff-text-gray-700 ff-mb-2", children: "Extracted Information" }),
+      /* @__PURE__ */ v("dl", { className: "ff-space-y-1 ff-text-sm", children: [
+        "fullName" in r.extractedData && /* @__PURE__ */ v("div", { className: "ff-flex ff-justify-between", children: [
+          /* @__PURE__ */ c("dt", { className: "ff-text-gray-500", children: "Name" }),
+          /* @__PURE__ */ c("dd", { className: "ff-text-gray-900 ff-font-medium", children: r.extractedData.fullName })
+        ] }),
+        "dateOfBirth" in r.extractedData && /* @__PURE__ */ v("div", { className: "ff-flex ff-justify-between", children: [
+          /* @__PURE__ */ c("dt", { className: "ff-text-gray-500", children: "Date of Birth" }),
+          /* @__PURE__ */ c("dd", { className: "ff-text-gray-900", children: r.extractedData.dateOfBirth })
+        ] }),
+        r.extractedData.documentType === "passport" && "passportNumber" in r.extractedData && /* @__PURE__ */ v("div", { className: "ff-flex ff-justify-between", children: [
+          /* @__PURE__ */ c("dt", { className: "ff-text-gray-500", children: "Passport #" }),
+          /* @__PURE__ */ c("dd", { className: "ff-text-gray-900 ff-font-mono", children: r.extractedData.passportNumber })
+        ] }),
+        r.extractedData.documentType === "drivers_license" && "licenseNumber" in r.extractedData && /* @__PURE__ */ v("div", { className: "ff-flex ff-justify-between", children: [
+          /* @__PURE__ */ c("dt", { className: "ff-text-gray-500", children: "License #" }),
+          /* @__PURE__ */ c("dd", { className: "ff-text-gray-900 ff-font-mono", children: r.extractedData.licenseNumber })
+        ] }),
+        "address" in r.extractedData && r.extractedData.address && /* @__PURE__ */ v("div", { className: "ff-flex ff-justify-between", children: [
+          /* @__PURE__ */ c("dt", { className: "ff-text-gray-500", children: "Address" }),
+          /* @__PURE__ */ v("dd", { className: "ff-text-gray-900 ff-text-right", children: [
+            r.extractedData.address.city,
+            ",",
+            " ",
+            r.extractedData.address.province
+          ] })
+        ] })
+      ] })
+    ] })
+  ] });
+}, oa = {
+  passport: _t,
+  drivers_license: Xt,
+  proof_of_address: er
+}, ma = ({
+  requiredDocuments: a,
+  onComplete: e,
+  onCancel: t,
+  onError: r
+}) => {
+  const {
+    sessionId: s,
+    step: i,
+    currentDocumentType: n,
+    documents: o,
+    isVerified: d,
+    verificationStatus: h,
+    isLoading: x,
+    error: M,
+    setSessionId: ie,
+    setRequiredDocuments: Ie,
+    setCurrentDocumentType: D,
+    setDocumentStatus: He,
+    setDocumentData: Z,
+    setStep: Y,
+    nextDocument: Et,
+    setVerificationStatus: Mt,
+    setVerified: jt,
+    setLoading: ee,
+    setError: me,
+    areAllDocumentsUploaded: Ke,
+    areAllDocumentsProcessed: Je,
+    reset: Zt
+  } = ye(), [la, W] = Yt(null);
+  Wt(() => (Ie(a), Ft(), () => {
+    W(null);
+  }), [a]);
+  const Ft = async () => {
+    try {
+      ee(!0);
+      const C = await he().createKYCSession(a);
+      ie(C.sessionId), Y("upload");
+    } catch (S) {
+      const C = S;
+      me(C.message), r == null || r(C);
+    } finally {
+      ee(!1);
+    }
+  }, Pt = gt(
+    async (S) => {
+      if (!(!s || !n))
+        try {
+          ee(!0), me(null);
+          const O = await he().uploadKYCDocument(s, n, S);
+          Z(n, {
+            id: O.documentId,
+            status: "processing"
+          }), W(O.documentId), qt(O.documentId);
+        } catch (C) {
+          const O = C;
+          Z(n, {
+            status: "failed",
+            error: O.message
+          }), r == null || r(O);
+        } finally {
+          ee(!1);
+        }
+    },
+    [s, n]
+  ), qt = async (S) => {
+    let H = 0, ne = 0;
+    const Oe = async () => {
+      var Qe;
+      if (H >= 30) {
+        W(null), n && Z(n, {
+          status: "failed",
+          error: "Processing timed out. Please try again."
+        });
+        return;
+      }
+      if (ne >= 3) {
+        W(null), n && Z(n, {
+          status: "failed",
+          error: "Failed to check document status. Please refresh and try again."
+        });
+        return;
+      }
+      try {
+        const q = (await he().getKYCDocument(S)).document;
+        ne = 0;
+        const Vt = q.type;
+        if (Z(Vt, {
+          id: q.id,
+          status: q.status,
+          extractedData: q.extractedData,
+          confidence: q.confidence,
+          fraudFlags: q.fraudFlags,
+          error: null
+          // Clear any previous errors
+        }), q.status === "completed" || q.status === "requires_review" || q.status === "failed") {
+          W(null), Ke() ? Je() && Y("review") : Et();
+          return;
+        }
+        H++, setTimeout(Oe, 2e3);
+      } catch (Ge) {
+        const pe = Ge;
+        if (ne++, H++, pe.status === 404 || (Qe = pe.message) != null && Qe.includes("not found")) {
+          W(null), n && Z(n, {
+            status: "failed",
+            error: "Session not found or invalid state"
+          });
+          return;
+        }
+        ne < 3 ? setTimeout(Oe, 3e3 * ne) : (W(null), n && Z(n, {
+          status: "failed",
+          error: pe.message || "Failed to process document"
+        }));
+      }
+    };
+    Oe();
+  }, Lt = async () => {
+    if (s)
+      try {
+        ee(!0), me(null);
+        const C = await he().verifyKYCSession(s, !0);
+        Mt(C.verificationStatus);
+        const O = C.verificationStatus;
+        jt(O.isVerified), Y("complete"), e == null || e(C);
+      } catch (S) {
+        const C = S;
+        me(C.message), r == null || r(C);
+      } finally {
+        ee(!1);
+      }
+  }, $t = () => {
+    Zt(), t == null || t();
+  }, Bt = (S) => {
+    D(S), Y("upload");
+  }, Ut = (S) => {
+    const C = o.get(S);
+    return (C == null ? void 0 : C.status) === "completed" || (C == null ? void 0 : C.status) === "requires_review";
+  };
+  return /* @__PURE__ */ v("div", { className: "ff-container ff-bg-white ff-rounded-xl ff-shadow-xl ff-overflow-hidden ff-flex ff-flex-col ff-max-h-[90vh]", children: [
+    /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-justify-between ff-px-6 ff-py-4 ff-border-b ff-border-gray-200 ff-bg-gray-50 ff-flex-shrink-0", children: [
+      /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-gap-3", children: [
+        /* @__PURE__ */ c(rt, { className: "ff-w-6 ff-h-6 ff-text-primary-600" }),
+        /* @__PURE__ */ c("h2", { className: "ff-text-xl ff-font-semibold ff-text-gray-900", children: "Identity Verification" })
+      ] }),
+      /* @__PURE__ */ c(
+        "button",
+        {
+          onClick: $t,
+          className: "ff-p-2 ff-text-gray-400 hover:ff-text-gray-600 ff-rounded-full hover:ff-bg-gray-100",
+          children: /* @__PURE__ */ c(vt, { className: "ff-w-5 ff-h-5" })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ v("div", { className: "ff-p-6 ff-overflow-y-auto ff-flex-1 ff-min-h-0", children: [
+      M && /* @__PURE__ */ c("div", { className: "ff-mb-4 ff-p-4 ff-bg-error-50 ff-border ff-border-error-200 ff-rounded-lg ff-text-error-700", children: M }),
+      i === "select" && /* @__PURE__ */ v("div", { className: "ff-space-y-4", children: [
+        /* @__PURE__ */ c("p", { className: "ff-text-gray-600 ff-text-center ff-mb-6", children: "Please upload the following documents to verify your identity" }),
+        /* @__PURE__ */ c("div", { className: "ff-grid ff-gap-4", children: a.map((S) => {
+          const C = oa[S], O = We[S];
+          o.get(S);
+          const H = Ut(S);
+          return /* @__PURE__ */ v(
+            "button",
+            {
+              onClick: () => Bt(S),
+              className: R(
+                "ff-flex ff-items-center ff-gap-4 ff-p-4 ff-rounded-lg ff-border-2 ff-text-left ff-transition-all",
+                H ? "ff-border-success-300 ff-bg-success-50" : "ff-border-gray-200 hover:ff-border-primary-300 hover:ff-bg-primary-50"
+              ),
+              children: [
+                /* @__PURE__ */ c(
+                  "div",
+                  {
+                    className: R(
+                      "ff-p-3 ff-rounded-lg",
+                      H ? "ff-bg-success-100" : "ff-bg-gray-100"
+                    ),
+                    children: H ? /* @__PURE__ */ c(Me, { className: "ff-w-6 ff-h-6 ff-text-success-600" }) : /* @__PURE__ */ c(C, { className: "ff-w-6 ff-h-6 ff-text-gray-600" })
+                  }
+                ),
+                /* @__PURE__ */ v("div", { className: "ff-flex-1", children: [
+                  /* @__PURE__ */ c("p", { className: "ff-font-medium ff-text-gray-900", children: O.label }),
+                  /* @__PURE__ */ c("p", { className: "ff-text-sm ff-text-gray-500", children: O.description })
+                ] }),
+                /* @__PURE__ */ c(Gt, { className: "ff-w-5 ff-h-5 ff-text-gray-400" })
+              ]
+            },
+            S
+          );
+        }) })
+      ] }),
+      i === "upload" && n && /* @__PURE__ */ c("div", { className: "ff-max-w-lg ff-mx-auto", children: /* @__PURE__ */ c(ia, { documentType: n, onFileSelect: Pt }) }),
+      i === "processing" && /* @__PURE__ */ v("div", { className: "ff-flex ff-flex-col ff-items-center ff-justify-center ff-py-12", children: [
+        /* @__PURE__ */ c(Ee, { className: "ff-w-12 ff-h-12 ff-text-primary-600 ff-animate-spin ff-mb-4" }),
+        /* @__PURE__ */ c("h3", { className: "ff-text-lg ff-font-semibold ff-text-gray-900 ff-mb-2", children: "Processing Documents" }),
+        /* @__PURE__ */ c("p", { className: "ff-text-gray-500 ff-text-center", children: "We're analyzing your documents. This may take a moment..." })
+      ] }),
+      i === "review" && /* @__PURE__ */ v("div", { className: "ff-space-y-6", children: [
+        /* @__PURE__ */ v("div", { className: "ff-text-center ff-mb-6", children: [
+          /* @__PURE__ */ c("h3", { className: "ff-text-lg ff-font-semibold ff-text-gray-900", children: "Review Your Documents" }),
+          /* @__PURE__ */ c("p", { className: "ff-text-gray-500", children: "Please review the extracted information before completing verification" })
+        ] }),
+        /* @__PURE__ */ c("div", { className: "ff-grid ff-gap-4", children: a.map((S) => /* @__PURE__ */ c(
+          "div",
+          {
+            className: "ff-border ff-border-gray-200 ff-rounded-lg ff-p-4",
+            children: /* @__PURE__ */ c(na, { documentType: S, showDetails: !0 })
+          },
+          S
+        )) })
+      ] }),
+      i === "complete" && /* @__PURE__ */ v("div", { className: "ff-flex ff-flex-col ff-items-center ff-justify-center ff-py-12", children: [
+        /* @__PURE__ */ c(
+          "div",
+          {
+            className: R(
+              "ff-w-16 ff-h-16 ff-rounded-full ff-flex ff-items-center ff-justify-center ff-mb-4",
+              d ? "ff-bg-success-100" : "ff-bg-warning-100"
+            ),
+            children: d ? /* @__PURE__ */ c(Me, { className: "ff-w-10 ff-h-10 ff-text-success-600" }) : /* @__PURE__ */ c(rt, { className: "ff-w-10 ff-h-10 ff-text-warning-600" })
+          }
+        ),
+        /* @__PURE__ */ c("h3", { className: "ff-text-xl ff-font-semibold ff-text-gray-900 ff-mb-2", children: d ? "Verification Complete!" : "Review Required" }),
+        /* @__PURE__ */ c("p", { className: "ff-text-gray-500 ff-text-center", children: d ? "Your identity has been successfully verified." : "Additional review may be required. We will contact you if needed." })
+      ] })
+    ] }),
+    i !== "complete" && /* @__PURE__ */ v("div", { className: "ff-flex ff-items-center ff-justify-between ff-px-6 ff-py-4 ff-border-t ff-border-gray-200 ff-bg-gray-50 ff-flex-shrink-0", children: [
+      /* @__PURE__ */ c(
+        "button",
+        {
+          onClick: () => {
+            (i === "upload" || i === "review") && Y("select");
+          },
+          disabled: x,
+          className: "ff-btn ff-btn-secondary",
+          children: "Back"
+        }
+      ),
+      i === "review" && /* @__PURE__ */ c(
+        "button",
+        {
+          onClick: Lt,
+          disabled: x || !Je(),
+          className: "ff-btn ff-btn-primary",
+          children: x ? /* @__PURE__ */ v(zt, { children: [
+            /* @__PURE__ */ c(Ee, { className: "ff-w-4 ff-h-4 ff-mr-2 ff-animate-spin" }),
+            "Verifying..."
+          ] }) : "Complete Verification"
+        }
+      ),
+      i === "select" && Ke() && /* @__PURE__ */ c(
+        "button",
+        {
+          onClick: () => Y("review"),
+          className: "ff-btn ff-btn-primary",
+          children: "Review & Verify"
+        }
+      )
+    ] })
+  ] });
+};
+export {
+  St as C,
+  ia as D,
+  ma as K,
+  na as a,
+  We as b,
+  ye as u
+};
+//# sourceMappingURL=KYCWizard-D3Leb4rK.mjs.map