@lombard.finance/sdk 4.1.0 → 4.2.0

package/dist/chunks/statusConstants-ZJia15m2.js

@@ -0,0 +1,4446 @@
+var Fe = Object.defineProperty;
+var je = (n, e, t) => e in n ? Fe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var I = (n, e, t) => je(n, typeof e != "symbol" ? e + "" : e, t);
+import { r as T } from "./index-CfcQ_g3t.js";
+import { A as V } from "./defi-registry-dhrQMy94.js";
+import { q as He, m as ze, w as qe, S as We, v as Ke, p as Ge, z as Ye, y as Je } from "./token-addresses-DmAr89jP.js";
+import * as me from "bitcoinjs-lib";
+import { M as Xe } from "./constants-CuT4axsy.js";
+const Qe = "4.2.0", nn = "@lombard.finance/sdk", sn = typeof window < "u" && typeof window.document < "u" ? "browser" : typeof process < "u" && process.versions && process.versions.node ? "node" : "unknown";
+var et = /* @__PURE__ */ ((n) => (n.UNKNOWN_ERROR = "unknown-error", n.INVALID_CONFIGURATION = "invalid-configuration", n.OPERATION_TIMEOUT = "operation-timeout", n.OPERATION_CANCELLED = "operation-cancelled", n))(et || {}), tt = /* @__PURE__ */ ((n) => (n.PROVIDER_MISSING = "provider-missing", n.PROVIDER_INITIALIZATION_FAILED = "provider-initialization-failed", n.PROVIDER_CALL_FAILED = "provider-call-failed", n.SIGNER_MISSING = "signer-missing", n.USER_REJECTED = "user-rejected", n.NETWORK_MISMATCH = "network-mismatch", n))(tt || {}), nt = /* @__PURE__ */ ((n) => (n.ROUTE_NOT_FOUND = "route-not-found", n.INVALID_ROUTE_DEFINITION = "invalid-route-definition", n.UNSUPPORTED_CHAIN = "unsupported-chain", n.UNSUPPORTED_ASSET = "unsupported-asset", n.INCOMPATIBLE_ROUTE = "incompatible-route", n.ENVIRONMENT_MISMATCH = "environment-mismatch", n))(nt || {}), Z = /* @__PURE__ */ ((n) => (n.INVALID_ADDRESS = "invalid-address", n.INVALID_AMOUNT = "invalid-amount", n.AMOUNT_TOO_SMALL = "amount-too-small", n.AMOUNT_TOO_LARGE = "amount-too-large", n.INSUFFICIENT_BALANCE = "insufficient-balance", n.INVALID_PARAMETER = "invalid-parameter", n.MISSING_REQUIRED_PARAMETER = "missing-required-parameter", n.INVALID_CHAIN = "invalid-chain", n.INVALID_STATE = "invalid-state", n.INVALID_ASSET = "invalid-asset", n))(Z || {}), st = /* @__PURE__ */ ((n) => (n.CONTRACT_CALL_FAILED = "contract-call-failed", n.TRANSACTION_FAILED = "transaction-failed", n.TRANSACTION_REVERTED = "transaction-reverted", n.APPROVAL_FAILED = "approval-failed", n.INSUFFICIENT_ALLOWANCE = "insufficient-allowance", n.GAS_ESTIMATION_FAILED = "gas-estimation-failed", n))(st || {}), at = /* @__PURE__ */ ((n) => (n.INSUFFICIENT_SHARES = "withdraw-insufficient-shares", n.INVALID_AMOUNT = "withdraw-invalid-amount", n.NO_PENDING_WITHDRAWAL = "withdraw-no-pending", n.WITHDRAWAL_ALREADY_FULFILLED = "withdraw-already-fulfilled", n.WITHDRAWAL_EXPIRED = "withdraw-expired", n.WITHDRAWAL_NOT_FOUND = "withdraw-not-found", n.PROTOCOL_NOT_SUPPORTED = "withdraw-protocol-not-supported", n.INSUFFICIENT_LIQUIDITY = "withdraw-insufficient-liquidity", n))(at || {});
+class E extends Error {
+  constructor(t, s, a) {
+    super(s);
+    /** Machine-readable error code */
+    I(this, "code");
+    /** Additional metadata for debugging */
+    I(this, "metadata");
+    /** SDK version when error occurred (for debugging) */
+    I(this, "sdkVersion", Qe);
+    /** Timestamp when error occurred */
+    I(this, "timestamp", (/* @__PURE__ */ new Date()).toISOString());
+    this.name = "LombardError", this.code = t, this.metadata = a, Error.captureStackTrace && Error.captureStackTrace(this, E);
+  }
+  /**
+   * Serialize error to JSON for logging
+   *
+   * Includes all context needed for debugging: code, message, metadata,
+   * SDK version, timestamp, and stack trace.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await action.execute();
+   * } catch (error) {
+   *   if (error instanceof LombardError) {
+   *     console.log(JSON.stringify(error.toJSON(), null, 2));
+   *   }
+   * }
+   * ```
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      sdkVersion: this.sdkVersion,
+      timestamp: this.timestamp,
+      ...this.metadata && { metadata: this.metadata },
+      ...this.stack && { stack: this.stack }
+    };
+  }
+  /**
+   * Get Sentry-compatible context for error reporting
+   *
+   * Returns an object suitable for Sentry's `extra` or `contexts` fields.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await action.execute();
+   * } catch (error) {
+   *   if (error instanceof LombardError) {
+   *     Sentry.captureException(error, {
+   *       contexts: { lombard: error.toSentryContext() },
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  toSentryContext() {
+    return {
+      "sdk.version": this.sdkVersion,
+      "error.code": this.code,
+      "error.timestamp": this.timestamp,
+      ...this.metadata
+    };
+  }
+  /**
+   * Factory: Invalid configuration error
+   */
+  static invalidConfiguration(t) {
+    return new E("invalid-configuration", t);
+  }
+  /**
+   * Factory: Provider missing error
+   */
+  static providerMissing(t, s) {
+    return new E(
+      "provider-missing",
+      `${s} provider not configured for chain ${t}. Please provide a provider via SDK initialization.`,
+      { chain: t, providerType: s }
+    );
+  }
+  static moduleMissing(t) {
+    return new E(
+      "invalid-parameter",
+      `Module "${t}" is not registered. Install and register the corresponding package via createConfig({ modules: [...] }).`,
+      { moduleId: t }
+    );
+  }
+  /**
+   * Factory: Provider call failed error
+   */
+  static providerCallFailed(t, s) {
+    const a = s instanceof Error ? s.message : s;
+    return new E(
+      "provider-call-failed",
+      `Provider method ${t} failed: ${a}`,
+      { method: t, cause: a }
+    );
+  }
+  /**
+   * Factory: User rejected transaction
+   */
+  static userRejected(t) {
+    return new E(
+      "user-rejected",
+      `User rejected ${t}. Please try again and approve the transaction in your wallet.`,
+      { operation: t }
+    );
+  }
+  /**
+   * Factory: Route not found in registry
+   */
+  static routeNotFound(t) {
+    return new E(
+      "route-not-found",
+      "No route found matching the provided parameters. Please verify the asset and chain combination is supported.",
+      t
+    );
+  }
+  /**
+   * Factory: Invalid route definition
+   */
+  static invalidRouteDefinition(t) {
+    return new E(
+      "invalid-route-definition",
+      `Invalid route definition: ${t}`,
+      { reason: t }
+    );
+  }
+  /**
+   * Factory: Unsupported chain
+   */
+  static unsupportedChain(t) {
+    return new E(
+      "unsupported-chain",
+      `Chain ${t} is not supported in the current environment.`,
+      { chain: t }
+    );
+  }
+  /**
+   * Factory: Invalid parameter
+   */
+  static invalidParameter(t, s) {
+    return new E("invalid-parameter", s, {
+      parameter: t
+    });
+  }
+  /**
+   * Factory: Invalid address
+   */
+  static invalidAddress(t, s) {
+    return new E(
+      "invalid-address",
+      `Invalid address format: ${t}${s ? ` for chain ${s}` : ""}`,
+      { address: t, chain: s }
+    );
+  }
+  /**
+   * Factory: Invalid amount
+   */
+  static invalidAmount(t) {
+    return new E("invalid-amount", t, {
+      reason: t
+    });
+  }
+  /**
+   * Factory: Amount too small
+   */
+  static amountTooSmall(t, s, a) {
+    return new E(
+      "amount-too-small",
+      `Amount ${t} is below minimum ${s} ${a}`,
+      { amount: t, minimum: s, asset: a }
+    );
+  }
+  /**
+   * Factory: Insufficient balance
+   */
+  static insufficientBalance(t, s, a) {
+    return new E(
+      "insufficient-balance",
+      `Insufficient ${a} balance. Required: ${t}, Available: ${s}`,
+      { required: t, available: s, asset: a }
+    );
+  }
+  /**
+   * Factory: Missing required parameter
+   */
+  static missingParameter(t) {
+    return new E(
+      "missing-required-parameter",
+      `Required parameter "${t}" is missing`,
+      { parameterName: t }
+    );
+  }
+  /**
+   * Factory: Transaction failed
+   */
+  static transactionFailed(t, s) {
+    return new E(
+      "transaction-failed",
+      `Transaction failed: ${s}`,
+      { txHash: t, reason: s }
+    );
+  }
+  /**
+   * Factory: Transaction reverted
+   */
+  static transactionReverted(t, s) {
+    return new E(
+      "transaction-reverted",
+      `Transaction reverted${s ? `: ${s}` : ""}`,
+      { txHash: t, revertReason: s }
+    );
+  }
+  /**
+   * Factory: Approval failed
+   */
+  static approvalFailed(t, s) {
+    return new E(
+      "approval-failed",
+      `Failed to approve ${t} for spender ${s}`,
+      { token: t, spender: s }
+    );
+  }
+}
+function rt(n) {
+  return n instanceof E;
+}
+function pe(n) {
+  return rt(n) ? n : n instanceof Error ? new E("unknown-error", n.message, {
+    originalError: n.stack
+  }) : new E("unknown-error", String(n), {
+    originalValue: n
+  });
+}
+const p = {
+  // Official CAIP-2 namespaces
+  BIP122: "bip122",
+  EIP155: "eip155",
+  SOLANA: "solana",
+  STARKNET: "starknet",
+  // Unofficial namespaces (internal use)
+  SUI: "sui",
+  ZCASH: "zcash",
+  RIPPLE: "ripple",
+  DOGECOIN: "dogecoin",
+  HYPERLIQUID: "hyperliquid"
+}, fe = ":", g = (n, e) => `${n}${fe}${e}`, o = {
+  // Bitcoin chains (BIP122: first 32 chars of genesis block hash in little-endian)
+  BITCOIN_MAINNET: g(
+    p.BIP122,
+    "000000000019d6689c085ae165831e93"
+  ),
+  BITCOIN_SIGNET: g(
+    p.BIP122,
+    "00000008819873e925422c1ff0f99f7c"
+  ),
+  // EVM chains (EIP155: numeric chain ID)
+  ETHEREUM: g(p.EIP155, 1),
+  BASE: g(p.EIP155, 8453),
+  BASE_SEPOLIA: g(p.EIP155, 84532),
+  OPTIMISM: g(p.EIP155, 10),
+  POLYGON: g(p.EIP155, 137),
+  BSC: g(p.EIP155, 56),
+  BSC_TESTNET: g(p.EIP155, 97),
+  AVALANCHE: g(p.EIP155, 43114),
+  AVALANCHE_FUJI: g(p.EIP155, 43113),
+  BERACHAIN: g(p.EIP155, 80094),
+  BERACHAIN_BARTIO: g(p.EIP155, 80084),
+  BOB: g(p.EIP155, 60808),
+  CORN: g(p.EIP155, 21e6),
+  ETHERLINK: g(p.EIP155, 42793),
+  KATANA: g(p.EIP155, 747474),
+  KATANA_TATARA: g(p.EIP155, 129399),
+  MORPH: g(p.EIP155, 2818),
+  SONIC: g(p.EIP155, 146),
+  SONIC_TESTNET: g(p.EIP155, 57054),
+  SONIC_BLAZE_TESTNET: g(p.EIP155, 57054),
+  // Alias
+  SWELL: g(p.EIP155, 1923),
+  TAC: g(p.EIP155, 239),
+  SEPOLIA: g(p.EIP155, 11155111),
+  HOLESKY: g(p.EIP155, 17e3),
+  MEGAETH: g(p.EIP155, 4326),
+  MONAD: g(p.EIP155, 143),
+  STABLE: g(p.EIP155, 988),
+  // Solana chains (first 32 chars of genesis hash)
+  SOLANA_MAINNET: g(
+    p.SOLANA,
+    "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+  ),
+  SOLANA_DEVNET: g(
+    p.SOLANA,
+    "EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+  ),
+  SOLANA_TESTNET: g(
+    p.SOLANA,
+    "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z"
+  ),
+  // Sui chains (unofficial namespace, using cluster names)
+  SUI_MAINNET: g(p.SUI, "mainnet"),
+  SUI_TESTNET: g(p.SUI, "testnet"),
+  SUI_DEVNET: g(p.SUI, "devnet"),
+  // Starknet chains (uses network identifiers)
+  STARKNET_MAINNET: g(p.STARKNET, "SN_MAIN"),
+  STARKNET_SEPOLIA: g(p.STARKNET, "SN_SEPOLIA"),
+  // Zcash (unofficial namespace)
+  ZCASH_MAINNET: g(p.ZCASH, "mainnet"),
+  ZCASH_TESTNET: g(p.ZCASH, "testnet"),
+  // Ripple (unofficial namespace)
+  RIPPLE_MAINNET: g(p.RIPPLE, "mainnet"),
+  RIPPLE_TESTNET: g(p.RIPPLE, "testnet"),
+  // Dogecoin (unofficial namespace)
+  DOGECOIN_MAINNET: g(p.DOGECOIN, "mainnet"),
+  DOGECOIN_TESTNET: g(p.DOGECOIN, "testnet"),
+  // Custodial (unofficial namespace)
+  HYPERLIQUID: g(p.HYPERLIQUID, "mainnet")
+};
+function an(n) {
+  return Object.keys(o).find(
+    (e) => o[e] === n
+  ) ?? "";
+}
+function rn(n) {
+  return typeof n == "string" && Object.values(o).includes(n);
+}
+const G = {
+  // ─────────────────────────────────────────────────────────────────────────
+  // Bitcoin
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.BITCOIN_MAINNET]: {
+    name: "Bitcoin",
+    type: "bitcoin",
+    isTestnet: !1,
+    explorerUrl: "https://mempool.space",
+    nativeCurrency: "BTC",
+    badgeVariant: "warning"
+  },
+  [o.BITCOIN_SIGNET]: {
+    name: "Bitcoin Signet",
+    type: "bitcoin",
+    isTestnet: !0,
+    explorerUrl: "https://mempool.space/signet",
+    nativeCurrency: "BTC",
+    badgeVariant: "warning"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // EVM Mainnets
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.ETHEREUM]: {
+    name: "Ethereum",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://etherscan.io",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.BASE]: {
+    name: "Base",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://basescan.org",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.OPTIMISM]: {
+    name: "Optimism",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://optimistic.etherscan.io",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.POLYGON]: {
+    name: "Polygon",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://polygonscan.com",
+    nativeCurrency: "MATIC",
+    badgeVariant: "info"
+  },
+  [o.BSC]: {
+    name: "BNB Chain",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://bscscan.com",
+    nativeCurrency: "BNB",
+    badgeVariant: "info"
+  },
+  [o.AVALANCHE]: {
+    name: "Avalanche",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://snowtrace.io",
+    nativeCurrency: "AVAX",
+    badgeVariant: "info"
+  },
+  [o.BERACHAIN]: {
+    name: "Berachain",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://beratrail.io",
+    nativeCurrency: "BERA",
+    badgeVariant: "info"
+  },
+  [o.BOB]: {
+    name: "BOB",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://explorer.gobob.xyz",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.CORN]: {
+    name: "Corn",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://cornscan.io",
+    nativeCurrency: "BTCN",
+    badgeVariant: "info"
+  },
+  [o.ETHERLINK]: {
+    name: "Etherlink",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://explorer.etherlink.com",
+    nativeCurrency: "XTZ",
+    badgeVariant: "info"
+  },
+  [o.KATANA]: {
+    name: "Katana",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://explorer.katanarpc.com",
+    nativeCurrency: "BTC.b",
+    badgeVariant: "info"
+  },
+  [o.MORPH]: {
+    name: "Morph",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://explorer.morphl2.io",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.SONIC]: {
+    name: "Sonic",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://sonicscan.org",
+    nativeCurrency: "S",
+    badgeVariant: "info"
+  },
+  [o.SWELL]: {
+    name: "Swell",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://explorer.swellnetwork.io",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.TAC]: {
+    name: "TAC",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://explorer.tac.build",
+    nativeCurrency: "TAC",
+    badgeVariant: "info"
+  },
+  [o.MEGAETH]: {
+    name: "MegaETH",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://megaeth-testnet-v3.blockscout.com",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.MONAD]: {
+    name: "Monad",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://monadvision.com",
+    nativeCurrency: "MONAD",
+    badgeVariant: "info"
+  },
+  [o.STABLE]: {
+    name: "Stable",
+    type: "evm",
+    isTestnet: !1,
+    explorerUrl: "https://stablescan.xyz",
+    nativeCurrency: "USD",
+    badgeVariant: "info"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // EVM Testnets
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.BASE_SEPOLIA]: {
+    name: "Base Sepolia",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://sepolia.basescan.org",
+    nativeCurrency: "ETH",
+    badgeVariant: "secondary"
+  },
+  [o.BSC_TESTNET]: {
+    name: "BNB Testnet",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://testnet.bscscan.com",
+    nativeCurrency: "BNB",
+    badgeVariant: "secondary"
+  },
+  [o.AVALANCHE_FUJI]: {
+    name: "Avalanche Fuji",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://testnet.snowtrace.io",
+    nativeCurrency: "AVAX",
+    badgeVariant: "secondary"
+  },
+  [o.BERACHAIN_BARTIO]: {
+    name: "Berachain Bartio",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://bartio.beratrail.io",
+    nativeCurrency: "BERA",
+    badgeVariant: "secondary"
+  },
+  [o.KATANA_TATARA]: {
+    name: "Katana Tatara",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://explorer.tatara.katanarpc.com",
+    nativeCurrency: "BTC.b",
+    badgeVariant: "secondary"
+  },
+  // Note: SONIC_TESTNET and SONIC_BLAZE_TESTNET are the same chain (eip155:57054)
+  [o.SONIC_TESTNET]: {
+    name: "Sonic Blaze Testnet",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://testnet.sonicscan.org",
+    nativeCurrency: "S",
+    badgeVariant: "secondary"
+  },
+  [o.SEPOLIA]: {
+    name: "Sepolia",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://sepolia.etherscan.io",
+    nativeCurrency: "ETH",
+    badgeVariant: "secondary"
+  },
+  [o.HOLESKY]: {
+    name: "Holesky",
+    type: "evm",
+    isTestnet: !0,
+    explorerUrl: "https://holesky.etherscan.io",
+    nativeCurrency: "ETH",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Solana
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.SOLANA_MAINNET]: {
+    name: "Solana",
+    type: "solana",
+    isTestnet: !1,
+    explorerUrl: "https://solscan.io",
+    nativeCurrency: "SOL",
+    badgeVariant: "success"
+  },
+  [o.SOLANA_DEVNET]: {
+    name: "Solana Devnet",
+    type: "solana",
+    isTestnet: !0,
+    explorerUrl: "https://solscan.io?cluster=devnet",
+    nativeCurrency: "SOL",
+    badgeVariant: "secondary"
+  },
+  [o.SOLANA_TESTNET]: {
+    name: "Solana Testnet",
+    type: "solana",
+    isTestnet: !0,
+    explorerUrl: "https://solscan.io?cluster=testnet",
+    nativeCurrency: "SOL",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Sui
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.SUI_MAINNET]: {
+    name: "Sui",
+    type: "sui",
+    isTestnet: !1,
+    explorerUrl: "https://suiscan.xyz",
+    nativeCurrency: "SUI",
+    badgeVariant: "info"
+  },
+  [o.SUI_TESTNET]: {
+    name: "Sui Testnet",
+    type: "sui",
+    isTestnet: !0,
+    explorerUrl: "https://suiscan.xyz/testnet",
+    nativeCurrency: "SUI",
+    badgeVariant: "secondary"
+  },
+  [o.SUI_DEVNET]: {
+    name: "Sui Devnet",
+    type: "sui",
+    isTestnet: !0,
+    explorerUrl: "https://suiscan.xyz/devnet",
+    nativeCurrency: "SUI",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Starknet
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.STARKNET_MAINNET]: {
+    name: "Starknet",
+    type: "starknet",
+    isTestnet: !1,
+    explorerUrl: "https://starkscan.co",
+    nativeCurrency: "ETH",
+    badgeVariant: "info"
+  },
+  [o.STARKNET_SEPOLIA]: {
+    name: "Starknet Sepolia",
+    type: "starknet",
+    isTestnet: !0,
+    explorerUrl: "https://sepolia.starkscan.co",
+    nativeCurrency: "ETH",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Zcash
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.ZCASH_MAINNET]: {
+    name: "Zcash",
+    type: "zcash",
+    isTestnet: !1,
+    explorerUrl: "https://zcashblockexplorer.com",
+    nativeCurrency: "ZEC",
+    badgeVariant: "warning"
+  },
+  [o.ZCASH_TESTNET]: {
+    name: "Zcash Testnet",
+    type: "zcash",
+    isTestnet: !0,
+    nativeCurrency: "ZEC",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Ripple
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.RIPPLE_MAINNET]: {
+    name: "XRP Ledger",
+    type: "ripple",
+    isTestnet: !1,
+    explorerUrl: "https://xrpscan.com",
+    nativeCurrency: "XRP",
+    badgeVariant: "secondary"
+  },
+  [o.RIPPLE_TESTNET]: {
+    name: "XRP Testnet",
+    type: "ripple",
+    isTestnet: !0,
+    nativeCurrency: "XRP",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Dogecoin
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.DOGECOIN_MAINNET]: {
+    name: "Dogecoin",
+    type: "dogecoin",
+    isTestnet: !1,
+    explorerUrl: "https://dogechain.info",
+    nativeCurrency: "DOGE",
+    badgeVariant: "warning"
+  },
+  [o.DOGECOIN_TESTNET]: {
+    name: "Dogecoin Testnet",
+    type: "dogecoin",
+    isTestnet: !0,
+    nativeCurrency: "DOGE",
+    badgeVariant: "secondary"
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Other
+  // ─────────────────────────────────────────────────────────────────────────
+  [o.HYPERLIQUID]: {
+    name: "Hyperliquid",
+    type: "hyperliquid",
+    isTestnet: !1,
+    nativeCurrency: "USDC",
+    badgeVariant: "secondary"
+  }
+}, it = {
+  "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": Ke,
+  EtWTRABZaYq6iMfeYKouRu166VU2xqa1: We,
+  "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z": qe
+}, ct = {
+  SN_MAIN: Je,
+  SN_SEPOLIA: Ye
+};
+function ot(n) {
+  return ct[n];
+}
+function cn(n) {
+  return G[n];
+}
+function on(n) {
+  return G[n].name;
+}
+function dn(n) {
+  return G[n].type;
+}
+function un(n) {
+  return G[n].isTestnet;
+}
+function ln(n) {
+  return !G[n].isTestnet;
+}
+function Le(n) {
+  return G[n].type === "evm";
+}
+const Q = (n) => `${n}${fe}`;
+function fn(n) {
+  const e = Q(p.EIP155);
+  if (n.startsWith(e)) {
+    const r = Number.parseInt(n.slice(e.length), 10);
+    if (He(r)) return r;
+    throw new E(
+      Z.INVALID_CHAIN,
+      `Invalid EVM chain: ${n}`
+    );
+  }
+  const t = Q(p.SOLANA);
+  if (n.startsWith(t)) {
+    const r = n.slice(t.length), i = `solana:${r}`;
+    if (ze(i)) return i;
+    const c = it[r];
+    if (c) return c;
+    throw new E(
+      Z.INVALID_CHAIN,
+      `Invalid Solana chain: ${n}`
+    );
+  }
+  const s = Q(p.SUI);
+  if (n.startsWith(s)) {
+    if (Ge(n)) return n;
+    throw new E(
+      Z.INVALID_CHAIN,
+      `Invalid Sui chain: ${n}`
+    );
+  }
+  const a = Q(p.STARKNET);
+  if (n.startsWith(a)) {
+    const r = n.slice(a.length), i = ot(r);
+    if (i) return i;
+    throw new E(
+      Z.INVALID_CHAIN,
+      `Invalid Starknet chain: ${n}`
+    );
+  }
+  throw new E(
+    Z.INVALID_CHAIN,
+    `Invalid chain: ${n}`
+  );
+}
+function hn(n) {
+  return `${p.EIP155}${fe}${n}`;
+}
+const S = {
+  version: "1.0.0",
+  assets: {
+    // ═══════════════════════════════════════════════════════════════════════
+    // LBTC - Lombard BTC
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.LBTC]: {
+      decimals: 8,
+      symbol: "LBTC",
+      name: "Lombard BTC",
+      deployments: [
+        // Production
+        {
+          env: T.prod,
+          chain: o.ETHEREUM,
+          address: "0x8236a87084f8b84306f72007f36f2618a5634494"
+        },
+        {
+          env: T.prod,
+          chains: [
+            o.BASE,
+            o.BSC,
+            o.BERACHAIN,
+            o.CORN,
+            o.KATANA,
+            o.MORPH,
+            o.SONIC,
+            o.SWELL,
+            o.TAC,
+            o.MONAD,
+            o.STABLE
+          ],
+          address: "0xecAc9C5F704e954931349Da37F60E39f515c11c1"
+        },
+        {
+          env: T.prod,
+          chain: o.BOB,
+          address: "0xA45d4121b3D47719FF57a947A9d961539Ba33204"
+        },
+        {
+          env: T.prod,
+          chain: o.SOLANA_MAINNET,
+          address: "LomP48F7bLbKyMRHHsDVt7wuHaUQvQnVVspjcbfuAek"
+        },
+        {
+          env: T.prod,
+          chain: o.SUI_MAINNET,
+          address: "0x3e8e9423d80e1774a7ca128fccd8bf5f1f7753be658c5e645929037f7c819040"
+        },
+        {
+          env: T.prod,
+          chain: o.STARKNET_MAINNET,
+          address: "0x036834a40984312f7f7de8d31e3f6305b325389eaeea5b1c0664b2fb936461a4",
+          assetRouter: "0x05b1886d0f844ab930fc0ee066f1655a873437f15a5d2c41ee3e884fd5299976"
+        },
+        // Testnet
+        {
+          env: T.testnet,
+          chain: o.SEPOLIA,
+          address: "0xc47e4b3124597fdf8dd07843d4a7052f2ee80c30"
+        },
+        {
+          env: T.testnet,
+          chains: [
+            o.AVALANCHE_FUJI,
+            o.BASE_SEPOLIA,
+            o.BSC_TESTNET
+          ],
+          address: "0x107Fc7d90484534704dD2A9e24c7BD45DB4dD1B5"
+        },
+        {
+          env: T.testnet,
+          chain: o.SOLANA_TESTNET,
+          address: "79cscM6J9Af24TGGWcXyDf56fDLoodkyXdVy4R9aZ6C6"
+        },
+        {
+          env: T.testnet,
+          chain: o.SUI_TESTNET,
+          address: "0x50454d0b0fbad1288a6ab74f2e8ce0905a3317870673ab7787ebcf6f322b45fa"
+        },
+        {
+          env: T.testnet,
+          chain: o.STARKNET_SEPOLIA,
+          address: "0x00456a829ab75ba5e97534dc70d7fc617cfda244f8dcda47b11624de67c6e70c",
+          assetRouter: "0x063b7b5c8b114ebd5b9602fbd5d0ffd2cc3a598f1d91c6904cc0997cd8fea760"
+        },
+        // Stage
+        // Note: Avalanche Fuji is only supported on testnet (Gastald), not stage
+        {
+          env: T.stage,
+          chains: [
+            o.BASE_SEPOLIA,
+            o.BSC_TESTNET,
+            o.SEPOLIA
+          ],
+          address: "0x731eFa688F3679688cf60A3993b8658138953ED6"
+        },
+        {
+          env: T.stage,
+          chain: o.SOLANA_DEVNET,
+          address: "HEY7PCJe3GB27UWdopuYb1xDbB5SNtTcYPxRjntvfBSA"
+        },
+        {
+          env: T.stage,
+          chain: o.SUI_TESTNET,
+          address: "0x2d66430a27565b912f21be970e5ae1e8c0359f0b518c3235b751c75976791ce0"
+        },
+        {
+          env: T.stage,
+          chain: o.STARKNET_SEPOLIA,
+          address: "0x00b442f5420860e937a99659326e81a97e07bfd538b3cee65b90029c9da38a5f",
+          assetRouter: "0x01d27f156092746d0d7cd9d9deec5e937f27c3c7c1c28365e9e5efac459880b3"
+        },
+        // Dev
+        {
+          env: T.dev,
+          chain: o.SEPOLIA,
+          address: "0x93283b6B889C591893dB0dc93baD71656D5d8923"
+        },
+        {
+          env: T.dev,
+          chains: [
+            o.AVALANCHE_FUJI,
+            o.BASE_SEPOLIA,
+            o.BERACHAIN_BARTIO,
+            o.BSC_TESTNET
+          ],
+          address: "0xc47e4b3124597FDF8DD07843D4a7052F2eE80C30"
+        },
+        {
+          env: T.dev,
+          chain: o.STARKNET_SEPOLIA,
+          address: "0x0723de0c550b7bfbb5051dade72966d71a08bef952c0197462a5244497eb57c1",
+          assetRouter: "0x04838a05c798dc57e01e85526979841c84f1f3c732a525cff53adb3e8bee3d24"
+        }
+      ]
+    },
+    // ═══════════════════════════════════════════════════════════════════════
+    // BTC.b - Lombard's Native BTC Wrapper
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.BTCb]: {
+      decimals: 8,
+      symbol: "BTC.b",
+      name: "BTC.b",
+      deployments: [
+        // Production
+        {
+          env: T.prod,
+          chains: [
+            o.KATANA,
+            o.MEGAETH,
+            o.MONAD,
+            o.STABLE
+          ],
+          address: "0xB0F70C0bD6FD87dbEb7C10dC692a2a6106817072"
+        },
+        {
+          env: T.prod,
+          chain: o.AVALANCHE,
+          address: "0x152b9d0FdC40C096757F570A51E494bd4b943E50",
+          bridgeAdapter: "0x85D1D52e11290F174444d21C2a167bEDBE36e4d2"
+        },
+        // Testnet
+        {
+          env: T.testnet,
+          chain: o.SEPOLIA,
+          address: "0x20eA7b8ABb4B583788F1DFC738C709a2d9675681"
+        },
+        {
+          env: T.testnet,
+          chain: o.AVALANCHE_FUJI,
+          address: "0x7FbdC44BfEBDe80C970ba622B678daB36cee31f6",
+          bridgeAdapter: "0x0A65C37d07c32E5eA8ea40495b7f249cdE26935e"
+        },
+        // Stage
+        // Note: Avalanche Fuji is only supported on testnet (Gastald), not stage
+        {
+          env: T.stage,
+          chain: o.SEPOLIA,
+          address: "0x600e4006278EB11FA1691cA0FE6C5fcfC4992d58"
+        },
+        // Dev
+        {
+          env: T.dev,
+          chain: o.SEPOLIA,
+          address: "0x195219A262423d209E126BD21cf4F4F9AA796927"
+        },
+        {
+          env: T.dev,
+          chain: o.BSC_TESTNET,
+          address: "0xea3F66E5f2928dB9673103BfA01a2153A57a8050"
+        },
+        {
+          env: T.dev,
+          chain: o.AVALANCHE_FUJI,
+          address: "0x7FbdC44BfEBDe80C970ba622B678daB36cee31f6",
+          bridgeAdapter: "0x0A65C37d07c32E5eA8ea40495b7f249cdE26935e"
+        },
+        // IBC
+        {
+          env: T.ibc,
+          chain: o.AVALANCHE_FUJI,
+          address: "0x71ba2b8dc58e7ca1b6d81a60729e31aefa37ae02",
+          bridgeAdapter: "0x1391f9AC408cf13214DDB71d359002658eaF9ebb"
+        }
+      ]
+    },
+    // ═══════════════════════════════════════════════════════════════════════
+    // BTCBinance (BTCB) - Binance-Peg BTCB
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.BTCBinance]: {
+      decimals: 18,
+      symbol: "BTCB",
+      name: "Binance-Peg BTCB",
+      deployments: [
+        {
+          env: T.prod,
+          chain: o.BSC,
+          address: "0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+          publicMarketMaker: "0xE4ff44a615dF38e37cdF475833c1d57774CC9D4A"
+        },
+        {
+          env: T.testnet,
+          chain: o.BSC_TESTNET,
+          address: "0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+          publicMarketMaker: "0x63749Acfc2527A8406E8BC8c93A80f29FDD75e27"
+        },
+        {
+          env: T.stage,
+          chain: o.BSC_TESTNET,
+          address: "0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+          publicMarketMaker: "0x440362b55D4a255EBA3c27C650d2dC1a91Db85bA"
+        },
+        {
+          env: T.dev,
+          chain: o.BSC_TESTNET,
+          address: "0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+          publicMarketMaker: "0x440362b55D4a255EBA3c27C650d2dC1a91Db85bA"
+        }
+      ]
+    },
+    // ═══════════════════════════════════════════════════════════════════════
+    // cbBTC - Coinbase Wrapped BTC
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.cbBTC]: {
+      decimals: 8,
+      symbol: "cbBTC",
+      name: "Coinbase Wrapped BTC",
+      deployments: [
+        {
+          env: T.prod,
+          chains: [o.ETHEREUM, o.BASE],
+          address: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+          publicMarketMaker: "0x92c01FC0F59857c6E920EdFf1139904b2Bb74c7c"
+        }
+      ]
+    },
+    // ═══════════════════════════════════════════════════════════════════════
+    // eBTC
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.eBTC]: {
+      decimals: 8,
+      symbol: "eBTC",
+      deployments: [
+        {
+          env: T.prod,
+          chain: o.ETHEREUM,
+          address: "0x657e8c867d8b37dcc18fa4caead9c45eb088c642"
+        }
+      ]
+    },
+    // ═══════════════════════════════════════════════════════════════════════
+    // WBTC - Wrapped BTC
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.WBTC]: {
+      decimals: 8,
+      symbol: "WBTC",
+      deployments: [
+        {
+          env: T.prod,
+          chain: o.ETHEREUM,
+          address: "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599"
+        }
+      ]
+    },
+    // ═══════════════════════════════════════════════════════════════════════
+    // wBTCN - Wrapped BTCN on Corn
+    // ═══════════════════════════════════════════════════════════════════════
+    [V.WBTCN]: {
+      decimals: 8,
+      symbol: "wBTCN",
+      deployments: [
+        {
+          env: T.prod,
+          chain: o.CORN,
+          address: "0xda5dDd7270381A7C2717aD10D1c0ecB19e3CDFb2"
+        }
+      ]
+    }
+  }
+}, dt = 8;
+function Y(n, e, t, s) {
+  const a = n.assets[e];
+  if (a)
+    return a.deployments.find(
+      (r) => {
+        var i;
+        return r.env === t && (r.chain === s || ((i = r.chains) == null ? void 0 : i.includes(s)));
+      }
+    );
+}
+function mn(n, e, t, s = S) {
+  var a;
+  return (a = Y(s, n, e, t)) == null ? void 0 : a.address;
+}
+function pn(n, e = S) {
+  var t;
+  return ((t = e.assets[n]) == null ? void 0 : t.decimals) ?? dt;
+}
+function gn(n, e, t, s = S) {
+  var a;
+  return (a = Y(s, n, e, t)) == null ? void 0 : a.assetRouter;
+}
+function vn(n, e, t, s = S) {
+  var a;
+  return !!((a = Y(s, n, e, t)) != null && a.assetRouter);
+}
+function yn(n, e, t, s = S) {
+  var a;
+  return (a = Y(s, n, e, t)) == null ? void 0 : a.bridgeAdapter;
+}
+function _n(n, e, t, s = S) {
+  var a;
+  return (a = Y(s, n, e, t)) == null ? void 0 : a.publicMarketMaker;
+}
+function An(n, e, t, s = S) {
+  return !!Y(s, n, e, t);
+}
+function Tn(n, e, t, s = S) {
+  const a = n.toLowerCase();
+  for (const [r, i] of Object.entries(s.assets)) {
+    if (!i) continue;
+    if (i.deployments.find(
+      (u) => {
+        var h;
+        return u.env === e && (u.chain === t || ((h = u.chains) == null ? void 0 : h.includes(t))) && u.address.toLowerCase() === a;
+      }
+    )) return r;
+  }
+}
+function En(n, e, t = S) {
+  const s = t.assets[n];
+  if (!s) return [];
+  const a = [];
+  for (const r of s.deployments)
+    r.env === e && (r.chain && a.push(r.chain), r.chains && a.push(...r.chains));
+  return a;
+}
+function bn(n, e, t = S) {
+  var r;
+  const s = t.assets[n];
+  if (!s) return [];
+  const a = /* @__PURE__ */ new Set();
+  for (const i of s.deployments)
+    (i.chain === e || (r = i.chains) != null && r.includes(e)) && a.add(i.env);
+  return Array.from(a);
+}
+function xn(n = S) {
+  return Object.keys(n.assets);
+}
+function Nn(n, e = S) {
+  const t = e.assets[n];
+  if (!t) return [];
+  const s = /* @__PURE__ */ new Set();
+  for (const a of t.deployments)
+    a.chain && s.add(a.chain), a.chains && a.chains.forEach((r) => s.add(r));
+  return Array.from(s);
+}
+function ie(n, e, t = S) {
+  const s = t.assets[n];
+  if (!s) return [];
+  const a = /* @__PURE__ */ new Set();
+  for (const r of s.deployments)
+    e.includes(r.env) && (r.chain && a.add(r.chain), r.chains && r.chains.forEach((i) => a.add(i)));
+  return Array.from(a);
+}
+function Sn(n, e = S) {
+  const t = e.assets[n];
+  if (t)
+    return { decimals: t.decimals, symbol: t.symbol, name: t.name };
+}
+function In(n, e, t = S) {
+  return ie(n, e, t).filter(
+    (s) => Le(s)
+  );
+}
+function ut(n, e, t = S) {
+  if (n.length === 0) return [];
+  const s = new Set(ie(n[0], e, t));
+  for (let a = 1; a < n.length; a++) {
+    const r = new Set(ie(n[a], e, t));
+    for (const i of s)
+      r.has(i) || s.delete(i);
+  }
+  return Array.from(s);
+}
+function kn(n, e, t = S) {
+  return ut(n, e, t).filter(
+    (s) => Le(s)
+  );
+}
+class lt {
+  constructor(e) {
+    I(this, "config");
+    this.config = e;
+  }
+  /**
+   * Get partner ID
+   */
+  getPartnerId() {
+    var e;
+    return (e = this.config) == null ? void 0 : e.partnerId;
+  }
+  /**
+   * Check if partner is configured
+   */
+  isConfigured() {
+    return this.config !== void 0;
+  }
+  /**
+   * Update partner configuration
+   *
+   * @param config - New partner configuration
+   */
+  update(e) {
+    this.config = e;
+  }
+  /**
+   * Clear partner configuration
+   */
+  clear() {
+    this.config = void 0;
+  }
+}
+function De(n, e) {
+  let t;
+  switch (e) {
+    case "evm":
+      t = n.evm;
+      break;
+    case "bitcoin":
+      t = n.bitcoin;
+      break;
+    case "solana":
+      t = n.solana;
+      break;
+    case "sui":
+      t = n.sui;
+      break;
+    case "starknet":
+      t = n.starknet;
+      break;
+    default:
+      t = void 0;
+  }
+  return t;
+}
+class ft {
+  constructor(e, t) {
+    I(this, "modules", /* @__PURE__ */ new Map());
+    I(this, "services", /* @__PURE__ */ new Map());
+    I(this, "shared", /* @__PURE__ */ new Map());
+    this.config = t, e.forEach((s) => this.modules.set(s.id, s));
+  }
+  /**
+   * Require a module service
+   *
+   * Throws LombardError.moduleMissing if module not installed.
+   *
+   * @param id - Module identifier
+   * @returns Module service
+   */
+  require(e) {
+    const t = this.modules.get(e);
+    if (!t)
+      throw E.moduleMissing(e);
+    return this.services.has(t.id) || this.services.set(t.id, t.register(this.createContext())), this.services.get(t.id);
+  }
+  /**
+   * Optionally get a module service
+   *
+   * Returns null if module not installed (no error thrown).
+   *
+   * @param id - Module identifier
+   * @returns Module service or null
+   */
+  optional(e) {
+    const t = this.modules.get(e);
+    return t ? (this.services.has(t.id) || this.services.set(t.id, t.register(this.createContext())), this.services.get(t.id)) : null;
+  }
+  /**
+   * Create registration context for modules
+   *
+   * Provides modules with access to config-based services.
+   */
+  createContext() {
+    return {
+      env: this.config.env,
+      getProvider: async (e) => {
+        const t = De(this.config.providers, e);
+        if (t)
+          return await t();
+      },
+      getShared: (e) => this.shared.get(e),
+      setShared: (e, t) => {
+        this.shared.set(e, t);
+      }
+    };
+  }
+}
+function ht(n) {
+  return async (e) => {
+    const t = De(n.providers, e);
+    if (t)
+      return t();
+  };
+}
+const ge = /* @__PURE__ */ new WeakMap();
+function Pe(n) {
+  let e = ge.get(n);
+  return e || (e = new ft(n.modules, n), ge.set(n, e)), e;
+}
+function Be(n) {
+  return {
+    env: n.env,
+    partner: new lt(n.partner),
+    getProvider: ht(n),
+    logger: void 0
+  };
+}
+function Cn(n) {
+  const e = Be(n), t = Pe(n), s = t.require("btc"), a = t.require("api");
+  return {
+    ...e,
+    btc: s,
+    api: a,
+    capabilities: t
+  };
+}
+function wn(n) {
+  const e = Be(n), s = Pe(n).require("evm");
+  return {
+    ...e,
+    evm: s
+  };
+}
+const On = {
+  IDLE: "idle",
+  PREPARING: "preparing",
+  READY: "ready",
+  EXECUTING: "executing",
+  COMPLETED: "completed",
+  FAILED: "failed"
+}, Rn = {
+  IDLE: "idle",
+  PENDING: "pending",
+  COMPLETE: "complete",
+  FAILED: "failed"
+};
+var x;
+(function(n) {
+  n.assertEqual = (a) => {
+  };
+  function e(a) {
+  }
+  n.assertIs = e;
+  function t(a) {
+    throw new Error();
+  }
+  n.assertNever = t, n.arrayToEnum = (a) => {
+    const r = {};
+    for (const i of a)
+      r[i] = i;
+    return r;
+  }, n.getValidEnumValues = (a) => {
+    const r = n.objectKeys(a).filter((c) => typeof a[a[c]] != "number"), i = {};
+    for (const c of r)
+      i[c] = a[c];
+    return n.objectValues(i);
+  }, n.objectValues = (a) => n.objectKeys(a).map(function(r) {
+    return a[r];
+  }), n.objectKeys = typeof Object.keys == "function" ? (a) => Object.keys(a) : (a) => {
+    const r = [];
+    for (const i in a)
+      Object.prototype.hasOwnProperty.call(a, i) && r.push(i);
+    return r;
+  }, n.find = (a, r) => {
+    for (const i of a)
+      if (r(i))
+        return i;
+  }, n.isInteger = typeof Number.isInteger == "function" ? (a) => Number.isInteger(a) : (a) => typeof a == "number" && Number.isFinite(a) && Math.floor(a) === a;
+  function s(a, r = " | ") {
+    return a.map((i) => typeof i == "string" ? `'${i}'` : i).join(r);
+  }
+  n.joinValues = s, n.jsonStringifyReplacer = (a, r) => typeof r == "bigint" ? r.toString() : r;
+})(x || (x = {}));
+var ve;
+(function(n) {
+  n.mergeShapes = (e, t) => ({
+    ...e,
+    ...t
+    // second overwrites first
+  });
+})(ve || (ve = {}));
+const f = x.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), D = (n) => {
+  switch (typeof n) {
+    case "undefined":
+      return f.undefined;
+    case "string":
+      return f.string;
+    case "number":
+      return Number.isNaN(n) ? f.nan : f.number;
+    case "boolean":
+      return f.boolean;
+    case "function":
+      return f.function;
+    case "bigint":
+      return f.bigint;
+    case "symbol":
+      return f.symbol;
+    case "object":
+      return Array.isArray(n) ? f.array : n === null ? f.null : n.then && typeof n.then == "function" && n.catch && typeof n.catch == "function" ? f.promise : typeof Map < "u" && n instanceof Map ? f.map : typeof Set < "u" && n instanceof Set ? f.set : typeof Date < "u" && n instanceof Date ? f.date : f.object;
+    default:
+      return f.unknown;
+  }
+}, d = x.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 R extends Error {
+  get errors() {
+    return this.issues;
+  }
+  constructor(e) {
+    super(), this.issues = [], this.addIssue = (s) => {
+      this.issues = [...this.issues, s];
+    }, this.addIssues = (s = []) => {
+      this.issues = [...this.issues, ...s];
+    };
+    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(r) {
+      return r.message;
+    }, s = { _errors: [] }, a = (r) => {
+      for (const i of r.issues)
+        if (i.code === "invalid_union")
+          i.unionErrors.map(a);
+        else if (i.code === "invalid_return_type")
+          a(i.returnTypeError);
+        else if (i.code === "invalid_arguments")
+          a(i.argumentsError);
+        else if (i.path.length === 0)
+          s._errors.push(t(i));
+        else {
+          let c = s, u = 0;
+          for (; u < i.path.length; ) {
+            const h = i.path[u];
+            u === i.path.length - 1 ? (c[h] = c[h] || { _errors: [] }, c[h]._errors.push(t(i))) : c[h] = c[h] || { _errors: [] }, c = c[h], u++;
+          }
+        }
+    };
+    return a(this), s;
+  }
+  static assert(e) {
+    if (!(e instanceof R))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, x.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (t) => t.message) {
+    const t = {}, s = [];
+    for (const a of this.issues)
+      if (a.path.length > 0) {
+        const r = a.path[0];
+        t[r] = t[r] || [], t[r].push(e(a));
+      } else
+        s.push(e(a));
+    return { formErrors: s, fieldErrors: t };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+R.create = (n) => new R(n);
+const ce = (n, e) => {
+  let t;
+  switch (n.code) {
+    case d.invalid_type:
+      n.received === f.undefined ? t = "Required" : t = `Expected ${n.expected}, received ${n.received}`;
+      break;
+    case d.invalid_literal:
+      t = `Invalid literal value, expected ${JSON.stringify(n.expected, x.jsonStringifyReplacer)}`;
+      break;
+    case d.unrecognized_keys:
+      t = `Unrecognized key(s) in object: ${x.joinValues(n.keys, ", ")}`;
+      break;
+    case d.invalid_union:
+      t = "Invalid input";
+      break;
+    case d.invalid_union_discriminator:
+      t = `Invalid discriminator value. Expected ${x.joinValues(n.options)}`;
+      break;
+    case d.invalid_enum_value:
+      t = `Invalid enum value. Expected ${x.joinValues(n.options)}, received '${n.received}'`;
+      break;
+    case d.invalid_arguments:
+      t = "Invalid function arguments";
+      break;
+    case d.invalid_return_type:
+      t = "Invalid function return type";
+      break;
+    case d.invalid_date:
+      t = "Invalid date";
+      break;
+    case d.invalid_string:
+      typeof n.validation == "object" ? "includes" in n.validation ? (t = `Invalid input: must include "${n.validation.includes}"`, typeof n.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${n.validation.position}`)) : "startsWith" in n.validation ? t = `Invalid input: must start with "${n.validation.startsWith}"` : "endsWith" in n.validation ? t = `Invalid input: must end with "${n.validation.endsWith}"` : x.assertNever(n.validation) : n.validation !== "regex" ? t = `Invalid ${n.validation}` : t = "Invalid";
+      break;
+    case d.too_small:
+      n.type === "array" ? t = `Array must contain ${n.exact ? "exactly" : n.inclusive ? "at least" : "more than"} ${n.minimum} element(s)` : n.type === "string" ? t = `String must contain ${n.exact ? "exactly" : n.inclusive ? "at least" : "over"} ${n.minimum} character(s)` : n.type === "number" ? t = `Number must be ${n.exact ? "exactly equal to " : n.inclusive ? "greater than or equal to " : "greater than "}${n.minimum}` : n.type === "bigint" ? t = `Number must be ${n.exact ? "exactly equal to " : n.inclusive ? "greater than or equal to " : "greater than "}${n.minimum}` : n.type === "date" ? t = `Date must be ${n.exact ? "exactly equal to " : n.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(n.minimum))}` : t = "Invalid input";
+      break;
+    case d.too_big:
+      n.type === "array" ? t = `Array must contain ${n.exact ? "exactly" : n.inclusive ? "at most" : "less than"} ${n.maximum} element(s)` : n.type === "string" ? t = `String must contain ${n.exact ? "exactly" : n.inclusive ? "at most" : "under"} ${n.maximum} character(s)` : n.type === "number" ? t = `Number must be ${n.exact ? "exactly" : n.inclusive ? "less than or equal to" : "less than"} ${n.maximum}` : n.type === "bigint" ? t = `BigInt must be ${n.exact ? "exactly" : n.inclusive ? "less than or equal to" : "less than"} ${n.maximum}` : n.type === "date" ? t = `Date must be ${n.exact ? "exactly" : n.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(n.maximum))}` : t = "Invalid input";
+      break;
+    case d.custom:
+      t = "Invalid input";
+      break;
+    case d.invalid_intersection_types:
+      t = "Intersection results could not be merged";
+      break;
+    case d.not_multiple_of:
+      t = `Number must be a multiple of ${n.multipleOf}`;
+      break;
+    case d.not_finite:
+      t = "Number must be finite";
+      break;
+    default:
+      t = e.defaultError, x.assertNever(n);
+  }
+  return { message: t };
+};
+let mt = ce;
+function pt() {
+  return mt;
+}
+const gt = (n) => {
+  const { data: e, path: t, errorMaps: s, issueData: a } = n, r = [...t, ...a.path || []], i = {
+    ...a,
+    path: r
+  };
+  if (a.message !== void 0)
+    return {
+      ...a,
+      path: r,
+      message: a.message
+    };
+  let c = "";
+  const u = s.filter((h) => !!h).slice().reverse();
+  for (const h of u)
+    c = h(i, { data: e, defaultError: c }).message;
+  return {
+    ...a,
+    path: r,
+    message: c
+  };
+};
+function l(n, e) {
+  const t = pt(), s = gt({
+    issueData: e,
+    data: n.data,
+    path: n.path,
+    errorMaps: [
+      n.common.contextualErrorMap,
+      // contextual error map is first priority
+      n.schemaErrorMap,
+      // then schema-bound map if available
+      t,
+      // then global override map
+      t === ce ? void 0 : ce
+      // then global default map
+    ].filter((a) => !!a)
+  });
+  n.common.issues.push(s);
+}
+class k {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    this.value === "valid" && (this.value = "dirty");
+  }
+  abort() {
+    this.value !== "aborted" && (this.value = "aborted");
+  }
+  static mergeArray(e, t) {
+    const s = [];
+    for (const a of t) {
+      if (a.status === "aborted")
+        return v;
+      a.status === "dirty" && e.dirty(), s.push(a.value);
+    }
+    return { status: e.value, value: s };
+  }
+  static async mergeObjectAsync(e, t) {
+    const s = [];
+    for (const a of t) {
+      const r = await a.key, i = await a.value;
+      s.push({
+        key: r,
+        value: i
+      });
+    }
+    return k.mergeObjectSync(e, s);
+  }
+  static mergeObjectSync(e, t) {
+    const s = {};
+    for (const a of t) {
+      const { key: r, value: i } = a;
+      if (r.status === "aborted" || i.status === "aborted")
+        return v;
+      r.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), r.value !== "__proto__" && (typeof i.value < "u" || a.alwaysSet) && (s[r.value] = i.value);
+    }
+    return { status: e.value, value: s };
+  }
+}
+const v = Object.freeze({
+  status: "aborted"
+}), J = (n) => ({ status: "dirty", value: n }), C = (n) => ({ status: "valid", value: n }), ye = (n) => n.status === "aborted", _e = (n) => n.status === "dirty", j = (n) => n.status === "valid", ee = (n) => typeof Promise < "u" && n instanceof Promise;
+var m;
+(function(n) {
+  n.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, n.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(m || (m = {}));
+class M {
+  constructor(e, t, s, a) {
+    this._cachedPath = [], this.parent = e, this.data = t, this._path = s, this._key = a;
+  }
+  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 Ae = (n, e) => {
+  if (j(e))
+    return { success: !0, data: e.value };
+  if (!n.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 R(n.common.issues);
+      return this._error = t, this._error;
+    }
+  };
+};
+function _(n) {
+  if (!n)
+    return {};
+  const { errorMap: e, invalid_type_error: t, required_error: s, description: a } = n;
+  if (e && (t || s))
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  return e ? { errorMap: e, description: a } : { errorMap: (i, c) => {
+    const { message: u } = n;
+    return i.code === "invalid_enum_value" ? { message: u ?? c.defaultError } : typeof c.data > "u" ? { message: u ?? s ?? c.defaultError } : i.code !== "invalid_type" ? { message: c.defaultError } : { message: u ?? t ?? c.defaultError };
+  }, description: a };
+}
+class b {
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return D(e.data);
+  }
+  _getOrReturnCtx(e, t) {
+    return t || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: D(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new k(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: D(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const t = this._parse(e);
+    if (ee(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 s = this.safeParse(e, t);
+    if (s.success)
+      return s.data;
+    throw s.error;
+  }
+  safeParse(e, t) {
+    const s = {
+      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: D(e)
+    }, a = this._parseSync({ data: e, path: s.path, parent: s });
+    return Ae(s, a);
+  }
+  "~validate"(e) {
+    var s, a;
+    const t = {
+      common: {
+        issues: [],
+        async: !!this["~standard"].async
+      },
+      path: [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: D(e)
+    };
+    if (!this["~standard"].async)
+      try {
+        const r = this._parseSync({ data: e, path: [], parent: t });
+        return j(r) ? {
+          value: r.value
+        } : {
+          issues: t.common.issues
+        };
+      } catch (r) {
+        (a = (s = r == null ? void 0 : r.message) == null ? void 0 : s.toLowerCase()) != null && a.includes("encountered") && (this["~standard"].async = !0), t.common = {
+          issues: [],
+          async: !0
+        };
+      }
+    return this._parseAsync({ data: e, path: [], parent: t }).then((r) => j(r) ? {
+      value: r.value
+    } : {
+      issues: t.common.issues
+    });
+  }
+  async parseAsync(e, t) {
+    const s = await this.safeParseAsync(e, t);
+    if (s.success)
+      return s.data;
+    throw s.error;
+  }
+  async safeParseAsync(e, t) {
+    const s = {
+      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: D(e)
+    }, a = this._parse({ data: e, path: s.path, parent: s }), r = await (ee(a) ? a : Promise.resolve(a));
+    return Ae(s, r);
+  }
+  refine(e, t) {
+    const s = (a) => typeof t == "string" || typeof t > "u" ? { message: t } : typeof t == "function" ? t(a) : t;
+    return this._refinement((a, r) => {
+      const i = e(a), c = () => r.addIssue({
+        code: d.custom,
+        ...s(a)
+      });
+      return typeof Promise < "u" && i instanceof Promise ? i.then((u) => u ? !0 : (c(), !1)) : i ? !0 : (c(), !1);
+    });
+  }
+  refinement(e, t) {
+    return this._refinement((s, a) => e(s) ? !0 : (a.addIssue(typeof t == "function" ? t(s, a) : t), !1));
+  }
+  _refinement(e) {
+    return new W({
+      schema: this,
+      typeName: y.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 K.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return O.create(this);
+  }
+  promise() {
+    return ae.create(this, this._def);
+  }
+  or(e) {
+    return ne.create([this, e], this._def);
+  }
+  and(e) {
+    return se.create(this, e, this._def);
+  }
+  transform(e) {
+    return new W({
+      ..._(this._def),
+      schema: this,
+      typeName: y.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new de({
+      ..._(this._def),
+      innerType: this,
+      defaultValue: t,
+      typeName: y.ZodDefault
+    });
+  }
+  brand() {
+    return new Vt({
+      typeName: y.ZodBranded,
+      type: this,
+      ..._(this._def)
+    });
+  }
+  catch(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new ue({
+      ..._(this._def),
+      innerType: this,
+      catchValue: t,
+      typeName: y.ZodCatch
+    });
+  }
+  describe(e) {
+    const t = this.constructor;
+    return new t({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return he.create(this, e);
+  }
+  readonly() {
+    return le.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const vt = /^c[^\s-]{8,}$/i, yt = /^[0-9a-z]+$/, _t = /^[0-9A-HJKMNP-TV-Z]{26}$/i, At = /^[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, Tt = /^[a-z0-9_-]{21}$/i, Et = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, bt = /^[-+]?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)?)??$/, xt = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, Nt = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let re;
+const St = /^(?:(?: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])$/, It = /^(?:(?: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])$/, kt = /^(([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]))$/, Ct = /^(([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])$/, wt = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, Ot = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, Me = "((\\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])))", Rt = new RegExp(`^${Me}$`);
+function Ue(n) {
+  let e = "[0-5]\\d";
+  n.precision ? e = `${e}\\.\\d{${n.precision}}` : n.precision == null && (e = `${e}(\\.\\d+)?`);
+  const t = n.precision ? "+" : "?";
+  return `([01]\\d|2[0-3]):[0-5]\\d(:${e})${t}`;
+}
+function Lt(n) {
+  return new RegExp(`^${Ue(n)}$`);
+}
+function Dt(n) {
+  let e = `${Me}T${Ue(n)}`;
+  const t = [];
+  return t.push(n.local ? "Z?" : "Z"), n.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
+}
+function Pt(n, e) {
+  return !!((e === "v4" || !e) && St.test(n) || (e === "v6" || !e) && kt.test(n));
+}
+function Bt(n, e) {
+  if (!Et.test(n))
+    return !1;
+  try {
+    const [t] = n.split(".");
+    if (!t)
+      return !1;
+    const s = t.replace(/-/g, "+").replace(/_/g, "/").padEnd(t.length + (4 - t.length % 4) % 4, "="), a = JSON.parse(atob(s));
+    return !(typeof a != "object" || a === null || "typ" in a && (a == null ? void 0 : a.typ) !== "JWT" || !a.alg || e && a.alg !== e);
+  } catch {
+    return !1;
+  }
+}
+function Mt(n, e) {
+  return !!((e === "v4" || !e) && It.test(n) || (e === "v6" || !e) && Ct.test(n));
+}
+class P extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== f.string) {
+      const r = this._getOrReturnCtx(e);
+      return l(r, {
+        code: d.invalid_type,
+        expected: f.string,
+        received: r.parsedType
+      }), v;
+    }
+    const s = new k();
+    let a;
+    for (const r of this._def.checks)
+      if (r.kind === "min")
+        e.data.length < r.value && (a = this._getOrReturnCtx(e, a), l(a, {
+          code: d.too_small,
+          minimum: r.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "max")
+        e.data.length > r.value && (a = this._getOrReturnCtx(e, a), l(a, {
+          code: d.too_big,
+          maximum: r.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "length") {
+        const i = e.data.length > r.value, c = e.data.length < r.value;
+        (i || c) && (a = this._getOrReturnCtx(e, a), i ? l(a, {
+          code: d.too_big,
+          maximum: r.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: r.message
+        }) : c && l(a, {
+          code: d.too_small,
+          minimum: r.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: r.message
+        }), s.dirty());
+      } else if (r.kind === "email")
+        xt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "email",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "emoji")
+        re || (re = new RegExp(Nt, "u")), re.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "emoji",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "uuid")
+        At.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "uuid",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "nanoid")
+        Tt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "nanoid",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "cuid")
+        vt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "cuid",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "cuid2")
+        yt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "cuid2",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "ulid")
+        _t.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+          validation: "ulid",
+          code: d.invalid_string,
+          message: r.message
+        }), s.dirty());
+      else if (r.kind === "url")
+        try {
+          new URL(e.data);
+        } catch {
+          a = this._getOrReturnCtx(e, a), l(a, {
+            validation: "url",
+            code: d.invalid_string,
+            message: r.message
+          }), s.dirty();
+        }
+      else r.kind === "regex" ? (r.regex.lastIndex = 0, r.regex.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "regex",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty())) : r.kind === "trim" ? e.data = e.data.trim() : r.kind === "includes" ? e.data.includes(r.value, r.position) || (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.invalid_string,
+        validation: { includes: r.value, position: r.position },
+        message: r.message
+      }), s.dirty()) : r.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : r.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : r.kind === "startsWith" ? e.data.startsWith(r.value) || (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.invalid_string,
+        validation: { startsWith: r.value },
+        message: r.message
+      }), s.dirty()) : r.kind === "endsWith" ? e.data.endsWith(r.value) || (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.invalid_string,
+        validation: { endsWith: r.value },
+        message: r.message
+      }), s.dirty()) : r.kind === "datetime" ? Dt(r).test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.invalid_string,
+        validation: "datetime",
+        message: r.message
+      }), s.dirty()) : r.kind === "date" ? Rt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.invalid_string,
+        validation: "date",
+        message: r.message
+      }), s.dirty()) : r.kind === "time" ? Lt(r).test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.invalid_string,
+        validation: "time",
+        message: r.message
+      }), s.dirty()) : r.kind === "duration" ? bt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "duration",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty()) : r.kind === "ip" ? Pt(e.data, r.version) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "ip",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty()) : r.kind === "jwt" ? Bt(e.data, r.alg) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "jwt",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty()) : r.kind === "cidr" ? Mt(e.data, r.version) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "cidr",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty()) : r.kind === "base64" ? wt.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "base64",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty()) : r.kind === "base64url" ? Ot.test(e.data) || (a = this._getOrReturnCtx(e, a), l(a, {
+        validation: "base64url",
+        code: d.invalid_string,
+        message: r.message
+      }), s.dirty()) : x.assertNever(r);
+    return { status: s.value, value: e.data };
+  }
+  _regex(e, t, s) {
+    return this.refinement((a) => e.test(a), {
+      validation: t,
+      code: d.invalid_string,
+      ...m.errToObj(s)
+    });
+  }
+  _addCheck(e) {
+    return new P({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...m.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...m.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...m.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...m.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...m.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...m.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...m.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...m.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...m.errToObj(e) });
+  }
+  base64url(e) {
+    return this._addCheck({
+      kind: "base64url",
+      ...m.errToObj(e)
+    });
+  }
+  jwt(e) {
+    return this._addCheck({ kind: "jwt", ...m.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...m.errToObj(e) });
+  }
+  cidr(e) {
+    return this._addCheck({ kind: "cidr", ...m.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,
+      ...m.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,
+      ...m.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...m.errToObj(e) });
+  }
+  regex(e, t) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...m.errToObj(t)
+    });
+  }
+  includes(e, t) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: t == null ? void 0 : t.position,
+      ...m.errToObj(t == null ? void 0 : t.message)
+    });
+  }
+  startsWith(e, t) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...m.errToObj(t)
+    });
+  }
+  endsWith(e, t) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...m.errToObj(t)
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...m.errToObj(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...m.errToObj(t)
+    });
+  }
+  length(e, t) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...m.errToObj(t)
+    });
+  }
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(e) {
+    return this.min(1, m.errToObj(e));
+  }
+  trim() {
+    return new P({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new P({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new P({
+      ...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;
+  }
+}
+P.create = (n) => new P({
+  checks: [],
+  typeName: y.ZodString,
+  coerce: (n == null ? void 0 : n.coerce) ?? !1,
+  ..._(n)
+});
+function Ut(n, e) {
+  const t = (n.toString().split(".")[1] || "").length, s = (e.toString().split(".")[1] || "").length, a = t > s ? t : s, r = Number.parseInt(n.toFixed(a).replace(".", "")), i = Number.parseInt(e.toFixed(a).replace(".", ""));
+  return r % i / 10 ** a;
+}
+class H 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) !== f.number) {
+      const r = this._getOrReturnCtx(e);
+      return l(r, {
+        code: d.invalid_type,
+        expected: f.number,
+        received: r.parsedType
+      }), v;
+    }
+    let s;
+    const a = new k();
+    for (const r of this._def.checks)
+      r.kind === "int" ? x.isInteger(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: r.message
+      }), a.dirty()) : r.kind === "min" ? (r.inclusive ? e.data < r.value : e.data <= r.value) && (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.too_small,
+        minimum: r.value,
+        type: "number",
+        inclusive: r.inclusive,
+        exact: !1,
+        message: r.message
+      }), a.dirty()) : r.kind === "max" ? (r.inclusive ? e.data > r.value : e.data >= r.value) && (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.too_big,
+        maximum: r.value,
+        type: "number",
+        inclusive: r.inclusive,
+        exact: !1,
+        message: r.message
+      }), a.dirty()) : r.kind === "multipleOf" ? Ut(e.data, r.value) !== 0 && (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.not_multiple_of,
+        multipleOf: r.value,
+        message: r.message
+      }), a.dirty()) : r.kind === "finite" ? Number.isFinite(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.not_finite,
+        message: r.message
+      }), a.dirty()) : x.assertNever(r);
+    return { status: a.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, m.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, m.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, m.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, m.toString(t));
+  }
+  setLimit(e, t, s, a) {
+    return new H({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: s,
+          message: m.toString(a)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new H({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: m.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: m.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: m.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: m.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: m.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: m.toString(t)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: m.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: m.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: m.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" && x.isInteger(e.value));
+  }
+  get isFinite() {
+    let e = null, t = null;
+    for (const s of this._def.checks) {
+      if (s.kind === "finite" || s.kind === "int" || s.kind === "multipleOf")
+        return !0;
+      s.kind === "min" ? (t === null || s.value > t) && (t = s.value) : s.kind === "max" && (e === null || s.value < e) && (e = s.value);
+    }
+    return Number.isFinite(t) && Number.isFinite(e);
+  }
+}
+H.create = (n) => new H({
+  checks: [],
+  typeName: y.ZodNumber,
+  coerce: (n == null ? void 0 : n.coerce) || !1,
+  ..._(n)
+});
+class z 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) !== f.bigint)
+      return this._getInvalidInput(e);
+    let s;
+    const a = new k();
+    for (const r of this._def.checks)
+      r.kind === "min" ? (r.inclusive ? e.data < r.value : e.data <= r.value) && (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.too_small,
+        type: "bigint",
+        minimum: r.value,
+        inclusive: r.inclusive,
+        message: r.message
+      }), a.dirty()) : r.kind === "max" ? (r.inclusive ? e.data > r.value : e.data >= r.value) && (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.too_big,
+        type: "bigint",
+        maximum: r.value,
+        inclusive: r.inclusive,
+        message: r.message
+      }), a.dirty()) : r.kind === "multipleOf" ? e.data % r.value !== BigInt(0) && (s = this._getOrReturnCtx(e, s), l(s, {
+        code: d.not_multiple_of,
+        multipleOf: r.value,
+        message: r.message
+      }), a.dirty()) : x.assertNever(r);
+    return { status: a.value, value: e.data };
+  }
+  _getInvalidInput(e) {
+    const t = this._getOrReturnCtx(e);
+    return l(t, {
+      code: d.invalid_type,
+      expected: f.bigint,
+      received: t.parsedType
+    }), v;
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, m.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, m.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, m.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, m.toString(t));
+  }
+  setLimit(e, t, s, a) {
+    return new z({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: s,
+          message: m.toString(a)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new z({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: m.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: m.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: m.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: m.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: m.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;
+  }
+}
+z.create = (n) => new z({
+  checks: [],
+  typeName: y.ZodBigInt,
+  coerce: (n == null ? void 0 : n.coerce) ?? !1,
+  ..._(n)
+});
+class Te extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== f.boolean) {
+      const s = this._getOrReturnCtx(e);
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.boolean,
+        received: s.parsedType
+      }), v;
+    }
+    return C(e.data);
+  }
+}
+Te.create = (n) => new Te({
+  typeName: y.ZodBoolean,
+  coerce: (n == null ? void 0 : n.coerce) || !1,
+  ..._(n)
+});
+class te extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== f.date) {
+      const r = this._getOrReturnCtx(e);
+      return l(r, {
+        code: d.invalid_type,
+        expected: f.date,
+        received: r.parsedType
+      }), v;
+    }
+    if (Number.isNaN(e.data.getTime())) {
+      const r = this._getOrReturnCtx(e);
+      return l(r, {
+        code: d.invalid_date
+      }), v;
+    }
+    const s = new k();
+    let a;
+    for (const r of this._def.checks)
+      r.kind === "min" ? e.data.getTime() < r.value && (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.too_small,
+        message: r.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: r.value,
+        type: "date"
+      }), s.dirty()) : r.kind === "max" ? e.data.getTime() > r.value && (a = this._getOrReturnCtx(e, a), l(a, {
+        code: d.too_big,
+        message: r.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: r.value,
+        type: "date"
+      }), s.dirty()) : x.assertNever(r);
+    return {
+      status: s.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new te({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: m.toString(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: m.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;
+  }
+}
+te.create = (n) => new te({
+  checks: [],
+  coerce: (n == null ? void 0 : n.coerce) || !1,
+  typeName: y.ZodDate,
+  ..._(n)
+});
+class Ee extends b {
+  _parse(e) {
+    if (this._getType(e) !== f.symbol) {
+      const s = this._getOrReturnCtx(e);
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.symbol,
+        received: s.parsedType
+      }), v;
+    }
+    return C(e.data);
+  }
+}
+Ee.create = (n) => new Ee({
+  typeName: y.ZodSymbol,
+  ..._(n)
+});
+class be extends b {
+  _parse(e) {
+    if (this._getType(e) !== f.undefined) {
+      const s = this._getOrReturnCtx(e);
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.undefined,
+        received: s.parsedType
+      }), v;
+    }
+    return C(e.data);
+  }
+}
+be.create = (n) => new be({
+  typeName: y.ZodUndefined,
+  ..._(n)
+});
+class xe extends b {
+  _parse(e) {
+    if (this._getType(e) !== f.null) {
+      const s = this._getOrReturnCtx(e);
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.null,
+        received: s.parsedType
+      }), v;
+    }
+    return C(e.data);
+  }
+}
+xe.create = (n) => new xe({
+  typeName: y.ZodNull,
+  ..._(n)
+});
+class Ne extends b {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return C(e.data);
+  }
+}
+Ne.create = (n) => new Ne({
+  typeName: y.ZodAny,
+  ..._(n)
+});
+class Se extends b {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return C(e.data);
+  }
+}
+Se.create = (n) => new Se({
+  typeName: y.ZodUnknown,
+  ..._(n)
+});
+class U extends b {
+  _parse(e) {
+    const t = this._getOrReturnCtx(e);
+    return l(t, {
+      code: d.invalid_type,
+      expected: f.never,
+      received: t.parsedType
+    }), v;
+  }
+}
+U.create = (n) => new U({
+  typeName: y.ZodNever,
+  ..._(n)
+});
+class Ie extends b {
+  _parse(e) {
+    if (this._getType(e) !== f.undefined) {
+      const s = this._getOrReturnCtx(e);
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.void,
+        received: s.parsedType
+      }), v;
+    }
+    return C(e.data);
+  }
+}
+Ie.create = (n) => new Ie({
+  typeName: y.ZodVoid,
+  ..._(n)
+});
+class O extends b {
+  _parse(e) {
+    const { ctx: t, status: s } = this._processInputParams(e), a = this._def;
+    if (t.parsedType !== f.array)
+      return l(t, {
+        code: d.invalid_type,
+        expected: f.array,
+        received: t.parsedType
+      }), v;
+    if (a.exactLength !== null) {
+      const i = t.data.length > a.exactLength.value, c = t.data.length < a.exactLength.value;
+      (i || c) && (l(t, {
+        code: i ? d.too_big : d.too_small,
+        minimum: c ? a.exactLength.value : void 0,
+        maximum: i ? a.exactLength.value : void 0,
+        type: "array",
+        inclusive: !0,
+        exact: !0,
+        message: a.exactLength.message
+      }), s.dirty());
+    }
+    if (a.minLength !== null && t.data.length < a.minLength.value && (l(t, {
+      code: d.too_small,
+      minimum: a.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: a.minLength.message
+    }), s.dirty()), a.maxLength !== null && t.data.length > a.maxLength.value && (l(t, {
+      code: d.too_big,
+      maximum: a.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: a.maxLength.message
+    }), s.dirty()), t.common.async)
+      return Promise.all([...t.data].map((i, c) => a.type._parseAsync(new M(t, i, t.path, c)))).then((i) => k.mergeArray(s, i));
+    const r = [...t.data].map((i, c) => a.type._parseSync(new M(t, i, t.path, c)));
+    return k.mergeArray(s, r);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, t) {
+    return new O({
+      ...this._def,
+      minLength: { value: e, message: m.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new O({
+      ...this._def,
+      maxLength: { value: e, message: m.toString(t) }
+    });
+  }
+  length(e, t) {
+    return new O({
+      ...this._def,
+      exactLength: { value: e, message: m.toString(t) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+O.create = (n, e) => new O({
+  type: n,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: y.ZodArray,
+  ..._(e)
+});
+function F(n) {
+  if (n instanceof N) {
+    const e = {};
+    for (const t in n.shape) {
+      const s = n.shape[t];
+      e[t] = B.create(F(s));
+    }
+    return new N({
+      ...n._def,
+      shape: () => e
+    });
+  } else return n instanceof O ? new O({
+    ...n._def,
+    type: F(n.element)
+  }) : n instanceof B ? B.create(F(n.unwrap())) : n instanceof K ? K.create(F(n.unwrap())) : n instanceof $ ? $.create(n.items.map((e) => F(e))) : n;
+}
+class N 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 = x.objectKeys(e);
+    return this._cached = { shape: e, keys: t }, this._cached;
+  }
+  _parse(e) {
+    if (this._getType(e) !== f.object) {
+      const h = this._getOrReturnCtx(e);
+      return l(h, {
+        code: d.invalid_type,
+        expected: f.object,
+        received: h.parsedType
+      }), v;
+    }
+    const { status: s, ctx: a } = this._processInputParams(e), { shape: r, keys: i } = this._getCached(), c = [];
+    if (!(this._def.catchall instanceof U && this._def.unknownKeys === "strip"))
+      for (const h in a.data)
+        i.includes(h) || c.push(h);
+    const u = [];
+    for (const h of i) {
+      const A = r[h], w = a.data[h];
+      u.push({
+        key: { status: "valid", value: h },
+        value: A._parse(new M(a, w, a.path, h)),
+        alwaysSet: h in a.data
+      });
+    }
+    if (this._def.catchall instanceof U) {
+      const h = this._def.unknownKeys;
+      if (h === "passthrough")
+        for (const A of c)
+          u.push({
+            key: { status: "valid", value: A },
+            value: { status: "valid", value: a.data[A] }
+          });
+      else if (h === "strict")
+        c.length > 0 && (l(a, {
+          code: d.unrecognized_keys,
+          keys: c
+        }), s.dirty());
+      else if (h !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const h = this._def.catchall;
+      for (const A of c) {
+        const w = a.data[A];
+        u.push({
+          key: { status: "valid", value: A },
+          value: h._parse(
+            new M(a, w, a.path, A)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: A in a.data
+        });
+      }
+    }
+    return a.common.async ? Promise.resolve().then(async () => {
+      const h = [];
+      for (const A of u) {
+        const w = await A.key, $e = await A.value;
+        h.push({
+          key: w,
+          value: $e,
+          alwaysSet: A.alwaysSet
+        });
+      }
+      return h;
+    }).then((h) => k.mergeObjectSync(s, h)) : k.mergeObjectSync(s, u);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return m.errToObj, new N({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (t, s) => {
+          var r, i;
+          const a = ((i = (r = this._def).errorMap) == null ? void 0 : i.call(r, t, s).message) ?? s.defaultError;
+          return t.code === "unrecognized_keys" ? {
+            message: m.errToObj(e).message ?? a
+          } : {
+            message: a
+          };
+        }
+      } : {}
+    });
+  }
+  strip() {
+    return new N({
+      ...this._def,
+      unknownKeys: "strip"
+    });
+  }
+  passthrough() {
+    return new N({
+      ...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 N({
+      ...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 N({
+      unknownKeys: e._def.unknownKeys,
+      catchall: e._def.catchall,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e._def.shape()
+      }),
+      typeName: y.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 N({
+      ...this._def,
+      catchall: e
+    });
+  }
+  pick(e) {
+    const t = {};
+    for (const s of x.objectKeys(e))
+      e[s] && this.shape[s] && (t[s] = this.shape[s]);
+    return new N({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  omit(e) {
+    const t = {};
+    for (const s of x.objectKeys(this.shape))
+      e[s] || (t[s] = this.shape[s]);
+    return new N({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return F(this);
+  }
+  partial(e) {
+    const t = {};
+    for (const s of x.objectKeys(this.shape)) {
+      const a = this.shape[s];
+      e && !e[s] ? t[s] = a : t[s] = a.optional();
+    }
+    return new N({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  required(e) {
+    const t = {};
+    for (const s of x.objectKeys(this.shape))
+      if (e && !e[s])
+        t[s] = this.shape[s];
+      else {
+        let r = this.shape[s];
+        for (; r instanceof B; )
+          r = r._def.innerType;
+        t[s] = r;
+      }
+    return new N({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  keyof() {
+    return Ve(x.objectKeys(this.shape));
+  }
+}
+N.create = (n, e) => new N({
+  shape: () => n,
+  unknownKeys: "strip",
+  catchall: U.create(),
+  typeName: y.ZodObject,
+  ..._(e)
+});
+N.strictCreate = (n, e) => new N({
+  shape: () => n,
+  unknownKeys: "strict",
+  catchall: U.create(),
+  typeName: y.ZodObject,
+  ..._(e)
+});
+N.lazycreate = (n, e) => new N({
+  shape: n,
+  unknownKeys: "strip",
+  catchall: U.create(),
+  typeName: y.ZodObject,
+  ..._(e)
+});
+class ne extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), s = this._def.options;
+    function a(r) {
+      for (const c of r)
+        if (c.result.status === "valid")
+          return c.result;
+      for (const c of r)
+        if (c.result.status === "dirty")
+          return t.common.issues.push(...c.ctx.common.issues), c.result;
+      const i = r.map((c) => new R(c.ctx.common.issues));
+      return l(t, {
+        code: d.invalid_union,
+        unionErrors: i
+      }), v;
+    }
+    if (t.common.async)
+      return Promise.all(s.map(async (r) => {
+        const i = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await r._parseAsync({
+            data: t.data,
+            path: t.path,
+            parent: i
+          }),
+          ctx: i
+        };
+      })).then(a);
+    {
+      let r;
+      const i = [];
+      for (const u of s) {
+        const h = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        }, A = u._parseSync({
+          data: t.data,
+          path: t.path,
+          parent: h
+        });
+        if (A.status === "valid")
+          return A;
+        A.status === "dirty" && !r && (r = { result: A, ctx: h }), h.common.issues.length && i.push(h.common.issues);
+      }
+      if (r)
+        return t.common.issues.push(...r.ctx.common.issues), r.result;
+      const c = i.map((u) => new R(u));
+      return l(t, {
+        code: d.invalid_union,
+        unionErrors: c
+      }), v;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+ne.create = (n, e) => new ne({
+  options: n,
+  typeName: y.ZodUnion,
+  ..._(e)
+});
+function oe(n, e) {
+  const t = D(n), s = D(e);
+  if (n === e)
+    return { valid: !0, data: n };
+  if (t === f.object && s === f.object) {
+    const a = x.objectKeys(e), r = x.objectKeys(n).filter((c) => a.indexOf(c) !== -1), i = { ...n, ...e };
+    for (const c of r) {
+      const u = oe(n[c], e[c]);
+      if (!u.valid)
+        return { valid: !1 };
+      i[c] = u.data;
+    }
+    return { valid: !0, data: i };
+  } else if (t === f.array && s === f.array) {
+    if (n.length !== e.length)
+      return { valid: !1 };
+    const a = [];
+    for (let r = 0; r < n.length; r++) {
+      const i = n[r], c = e[r], u = oe(i, c);
+      if (!u.valid)
+        return { valid: !1 };
+      a.push(u.data);
+    }
+    return { valid: !0, data: a };
+  } else return t === f.date && s === f.date && +n == +e ? { valid: !0, data: n } : { valid: !1 };
+}
+class se extends b {
+  _parse(e) {
+    const { status: t, ctx: s } = this._processInputParams(e), a = (r, i) => {
+      if (ye(r) || ye(i))
+        return v;
+      const c = oe(r.value, i.value);
+      return c.valid ? ((_e(r) || _e(i)) && t.dirty(), { status: t.value, value: c.data }) : (l(s, {
+        code: d.invalid_intersection_types
+      }), v);
+    };
+    return s.common.async ? Promise.all([
+      this._def.left._parseAsync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      }),
+      this._def.right._parseAsync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      })
+    ]).then(([r, i]) => a(r, i)) : a(this._def.left._parseSync({
+      data: s.data,
+      path: s.path,
+      parent: s
+    }), this._def.right._parseSync({
+      data: s.data,
+      path: s.path,
+      parent: s
+    }));
+  }
+}
+se.create = (n, e, t) => new se({
+  left: n,
+  right: e,
+  typeName: y.ZodIntersection,
+  ..._(t)
+});
+class $ extends b {
+  _parse(e) {
+    const { status: t, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== f.array)
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.array,
+        received: s.parsedType
+      }), v;
+    if (s.data.length < this._def.items.length)
+      return l(s, {
+        code: d.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), v;
+    !this._def.rest && s.data.length > this._def.items.length && (l(s, {
+      code: d.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), t.dirty());
+    const r = [...s.data].map((i, c) => {
+      const u = this._def.items[c] || this._def.rest;
+      return u ? u._parse(new M(s, i, s.path, c)) : null;
+    }).filter((i) => !!i);
+    return s.common.async ? Promise.all(r).then((i) => k.mergeArray(t, i)) : k.mergeArray(t, r);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new $({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+$.create = (n, e) => {
+  if (!Array.isArray(n))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new $({
+    items: n,
+    typeName: y.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: s } = this._processInputParams(e);
+    if (s.parsedType !== f.map)
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.map,
+        received: s.parsedType
+      }), v;
+    const a = this._def.keyType, r = this._def.valueType, i = [...s.data.entries()].map(([c, u], h) => ({
+      key: a._parse(new M(s, c, s.path, [h, "key"])),
+      value: r._parse(new M(s, u, s.path, [h, "value"]))
+    }));
+    if (s.common.async) {
+      const c = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const u of i) {
+          const h = await u.key, A = await u.value;
+          if (h.status === "aborted" || A.status === "aborted")
+            return v;
+          (h.status === "dirty" || A.status === "dirty") && t.dirty(), c.set(h.value, A.value);
+        }
+        return { status: t.value, value: c };
+      });
+    } else {
+      const c = /* @__PURE__ */ new Map();
+      for (const u of i) {
+        const h = u.key, A = u.value;
+        if (h.status === "aborted" || A.status === "aborted")
+          return v;
+        (h.status === "dirty" || A.status === "dirty") && t.dirty(), c.set(h.value, A.value);
+      }
+      return { status: t.value, value: c };
+    }
+  }
+}
+ke.create = (n, e, t) => new ke({
+  valueType: e,
+  keyType: n,
+  typeName: y.ZodMap,
+  ..._(t)
+});
+class X extends b {
+  _parse(e) {
+    const { status: t, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== f.set)
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.set,
+        received: s.parsedType
+      }), v;
+    const a = this._def;
+    a.minSize !== null && s.data.size < a.minSize.value && (l(s, {
+      code: d.too_small,
+      minimum: a.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: a.minSize.message
+    }), t.dirty()), a.maxSize !== null && s.data.size > a.maxSize.value && (l(s, {
+      code: d.too_big,
+      maximum: a.maxSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: a.maxSize.message
+    }), t.dirty());
+    const r = this._def.valueType;
+    function i(u) {
+      const h = /* @__PURE__ */ new Set();
+      for (const A of u) {
+        if (A.status === "aborted")
+          return v;
+        A.status === "dirty" && t.dirty(), h.add(A.value);
+      }
+      return { status: t.value, value: h };
+    }
+    const c = [...s.data.values()].map((u, h) => r._parse(new M(s, u, s.path, h)));
+    return s.common.async ? Promise.all(c).then((u) => i(u)) : i(c);
+  }
+  min(e, t) {
+    return new X({
+      ...this._def,
+      minSize: { value: e, message: m.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new X({
+      ...this._def,
+      maxSize: { value: e, message: m.toString(t) }
+    });
+  }
+  size(e, t) {
+    return this.min(e, t).max(e, t);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+X.create = (n, e) => new X({
+  valueType: n,
+  minSize: null,
+  maxSize: null,
+  typeName: y.ZodSet,
+  ..._(e)
+});
+class Ce 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 });
+  }
+}
+Ce.create = (n, e) => new Ce({
+  getter: n,
+  typeName: y.ZodLazy,
+  ..._(e)
+});
+class we extends b {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const t = this._getOrReturnCtx(e);
+      return l(t, {
+        received: t.data,
+        code: d.invalid_literal,
+        expected: this._def.value
+      }), v;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+we.create = (n, e) => new we({
+  value: n,
+  typeName: y.ZodLiteral,
+  ..._(e)
+});
+function Ve(n, e) {
+  return new q({
+    values: n,
+    typeName: y.ZodEnum,
+    ..._(e)
+  });
+}
+class q extends b {
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const t = this._getOrReturnCtx(e), s = this._def.values;
+      return l(t, {
+        expected: x.joinValues(s),
+        received: t.parsedType,
+        code: d.invalid_type
+      }), v;
+    }
+    if (this._cache || (this._cache = new Set(this._def.values)), !this._cache.has(e.data)) {
+      const t = this._getOrReturnCtx(e), s = this._def.values;
+      return l(t, {
+        received: t.data,
+        code: d.invalid_enum_value,
+        options: s
+      }), v;
+    }
+    return C(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 q.create(e, {
+      ...this._def,
+      ...t
+    });
+  }
+  exclude(e, t = this._def) {
+    return q.create(this.options.filter((s) => !e.includes(s)), {
+      ...this._def,
+      ...t
+    });
+  }
+}
+q.create = Ve;
+class Oe extends b {
+  _parse(e) {
+    const t = x.getValidEnumValues(this._def.values), s = this._getOrReturnCtx(e);
+    if (s.parsedType !== f.string && s.parsedType !== f.number) {
+      const a = x.objectValues(t);
+      return l(s, {
+        expected: x.joinValues(a),
+        received: s.parsedType,
+        code: d.invalid_type
+      }), v;
+    }
+    if (this._cache || (this._cache = new Set(x.getValidEnumValues(this._def.values))), !this._cache.has(e.data)) {
+      const a = x.objectValues(t);
+      return l(s, {
+        received: s.data,
+        code: d.invalid_enum_value,
+        options: a
+      }), v;
+    }
+    return C(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+Oe.create = (n, e) => new Oe({
+  values: n,
+  typeName: y.ZodNativeEnum,
+  ..._(e)
+});
+class ae extends b {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== f.promise && t.common.async === !1)
+      return l(t, {
+        code: d.invalid_type,
+        expected: f.promise,
+        received: t.parsedType
+      }), v;
+    const s = t.parsedType === f.promise ? t.data : Promise.resolve(t.data);
+    return C(s.then((a) => this._def.type.parseAsync(a, {
+      path: t.path,
+      errorMap: t.common.contextualErrorMap
+    })));
+  }
+}
+ae.create = (n, e) => new ae({
+  type: n,
+  typeName: y.ZodPromise,
+  ..._(e)
+});
+class W extends b {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === y.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: t, ctx: s } = this._processInputParams(e), a = this._def.effect || null, r = {
+      addIssue: (i) => {
+        l(s, i), i.fatal ? t.abort() : t.dirty();
+      },
+      get path() {
+        return s.path;
+      }
+    };
+    if (r.addIssue = r.addIssue.bind(r), a.type === "preprocess") {
+      const i = a.transform(s.data, r);
+      if (s.common.async)
+        return Promise.resolve(i).then(async (c) => {
+          if (t.value === "aborted")
+            return v;
+          const u = await this._def.schema._parseAsync({
+            data: c,
+            path: s.path,
+            parent: s
+          });
+          return u.status === "aborted" ? v : u.status === "dirty" || t.value === "dirty" ? J(u.value) : u;
+        });
+      {
+        if (t.value === "aborted")
+          return v;
+        const c = this._def.schema._parseSync({
+          data: i,
+          path: s.path,
+          parent: s
+        });
+        return c.status === "aborted" ? v : c.status === "dirty" || t.value === "dirty" ? J(c.value) : c;
+      }
+    }
+    if (a.type === "refinement") {
+      const i = (c) => {
+        const u = a.refinement(c, r);
+        if (s.common.async)
+          return Promise.resolve(u);
+        if (u instanceof Promise)
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        return c;
+      };
+      if (s.common.async === !1) {
+        const c = this._def.schema._parseSync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        return c.status === "aborted" ? v : (c.status === "dirty" && t.dirty(), i(c.value), { status: t.value, value: c.value });
+      } else
+        return this._def.schema._parseAsync({ data: s.data, path: s.path, parent: s }).then((c) => c.status === "aborted" ? v : (c.status === "dirty" && t.dirty(), i(c.value).then(() => ({ status: t.value, value: c.value }))));
+    }
+    if (a.type === "transform")
+      if (s.common.async === !1) {
+        const i = this._def.schema._parseSync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        if (!j(i))
+          return v;
+        const c = a.transform(i.value, r);
+        if (c instanceof Promise)
+          throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+        return { status: t.value, value: c };
+      } else
+        return this._def.schema._parseAsync({ data: s.data, path: s.path, parent: s }).then((i) => j(i) ? Promise.resolve(a.transform(i.value, r)).then((c) => ({
+          status: t.value,
+          value: c
+        })) : v);
+    x.assertNever(a);
+  }
+}
+W.create = (n, e, t) => new W({
+  schema: n,
+  typeName: y.ZodEffects,
+  effect: e,
+  ..._(t)
+});
+W.createWithPreprocess = (n, e, t) => new W({
+  schema: e,
+  effect: { type: "preprocess", transform: n },
+  typeName: y.ZodEffects,
+  ..._(t)
+});
+class B extends b {
+  _parse(e) {
+    return this._getType(e) === f.undefined ? C(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+B.create = (n, e) => new B({
+  innerType: n,
+  typeName: y.ZodOptional,
+  ..._(e)
+});
+class K extends b {
+  _parse(e) {
+    return this._getType(e) === f.null ? C(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+K.create = (n, e) => new K({
+  innerType: n,
+  typeName: y.ZodNullable,
+  ..._(e)
+});
+class de extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    let s = t.data;
+    return t.parsedType === f.undefined && (s = this._def.defaultValue()), this._def.innerType._parse({
+      data: s,
+      path: t.path,
+      parent: t
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+de.create = (n, e) => new de({
+  innerType: n,
+  typeName: y.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ..._(e)
+});
+class ue extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), s = {
+      ...t,
+      common: {
+        ...t.common,
+        issues: []
+      }
+    }, a = this._def.innerType._parse({
+      data: s.data,
+      path: s.path,
+      parent: {
+        ...s
+      }
+    });
+    return ee(a) ? a.then((r) => ({
+      status: "valid",
+      value: r.status === "valid" ? r.value : this._def.catchValue({
+        get error() {
+          return new R(s.common.issues);
+        },
+        input: s.data
+      })
+    })) : {
+      status: "valid",
+      value: a.status === "valid" ? a.value : this._def.catchValue({
+        get error() {
+          return new R(s.common.issues);
+        },
+        input: s.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+ue.create = (n, e) => new ue({
+  innerType: n,
+  typeName: y.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ..._(e)
+});
+class Re extends b {
+  _parse(e) {
+    if (this._getType(e) !== f.nan) {
+      const s = this._getOrReturnCtx(e);
+      return l(s, {
+        code: d.invalid_type,
+        expected: f.nan,
+        received: s.parsedType
+      }), v;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+Re.create = (n) => new Re({
+  typeName: y.ZodNaN,
+  ..._(n)
+});
+class Vt extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), s = t.data;
+    return this._def.type._parse({
+      data: s,
+      path: t.path,
+      parent: t
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+}
+class he extends b {
+  _parse(e) {
+    const { status: t, ctx: s } = this._processInputParams(e);
+    if (s.common.async)
+      return (async () => {
+        const r = await this._def.in._parseAsync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        return r.status === "aborted" ? v : r.status === "dirty" ? (t.dirty(), J(r.value)) : this._def.out._parseAsync({
+          data: r.value,
+          path: s.path,
+          parent: s
+        });
+      })();
+    {
+      const a = this._def.in._parseSync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      });
+      return a.status === "aborted" ? v : a.status === "dirty" ? (t.dirty(), {
+        status: "dirty",
+        value: a.value
+      }) : this._def.out._parseSync({
+        data: a.value,
+        path: s.path,
+        parent: s
+      });
+    }
+  }
+  static create(e, t) {
+    return new he({
+      in: e,
+      out: t,
+      typeName: y.ZodPipeline
+    });
+  }
+}
+class le extends b {
+  _parse(e) {
+    const t = this._def.innerType._parse(e), s = (a) => (j(a) && (a.value = Object.freeze(a.value)), a);
+    return ee(t) ? t.then((a) => s(a)) : s(t);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+le.create = (n, e) => new le({
+  innerType: n,
+  typeName: y.ZodReadonly,
+  ..._(e)
+});
+var y;
+(function(n) {
+  n.ZodString = "ZodString", n.ZodNumber = "ZodNumber", n.ZodNaN = "ZodNaN", n.ZodBigInt = "ZodBigInt", n.ZodBoolean = "ZodBoolean", n.ZodDate = "ZodDate", n.ZodSymbol = "ZodSymbol", n.ZodUndefined = "ZodUndefined", n.ZodNull = "ZodNull", n.ZodAny = "ZodAny", n.ZodUnknown = "ZodUnknown", n.ZodNever = "ZodNever", n.ZodVoid = "ZodVoid", n.ZodArray = "ZodArray", n.ZodObject = "ZodObject", n.ZodUnion = "ZodUnion", n.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", n.ZodIntersection = "ZodIntersection", n.ZodTuple = "ZodTuple", n.ZodRecord = "ZodRecord", n.ZodMap = "ZodMap", n.ZodSet = "ZodSet", n.ZodFunction = "ZodFunction", n.ZodLazy = "ZodLazy", n.ZodLiteral = "ZodLiteral", n.ZodEnum = "ZodEnum", n.ZodEffects = "ZodEffects", n.ZodNativeEnum = "ZodNativeEnum", n.ZodOptional = "ZodOptional", n.ZodNullable = "ZodNullable", n.ZodDefault = "ZodDefault", n.ZodCatch = "ZodCatch", n.ZodPromise = "ZodPromise", n.ZodBranded = "ZodBranded", n.ZodPipeline = "ZodPipeline", n.ZodReadonly = "ZodReadonly";
+})(y || (y = {}));
+const L = P.create, Zt = H.create, $t = z.create;
+U.create;
+O.create;
+const Ft = N.create, jt = ne.create;
+se.create;
+$.create;
+q.create;
+ae.create;
+B.create;
+K.create;
+function Ht() {
+  const n = /* @__PURE__ */ new Map();
+  return {
+    on(e, t) {
+      let s = n.get(e);
+      return s || (s = /* @__PURE__ */ new Set(), n.set(e, s)), s.add(t), () => {
+        s == null || s.delete(t), s && s.size === 0 && n.delete(e);
+      };
+    },
+    emit(e, ...t) {
+      const s = n.get(e);
+      if (!(!s || s.size === 0))
+        for (const a of s)
+          try {
+            a(...t);
+          } catch (r) {
+            console.error(
+              `Error in event handler for "${String(e)}":`,
+              r
+            );
+          }
+    },
+    off(e, t) {
+      const s = n.get(e);
+      s && (s.delete(t), s.size === 0 && n.delete(e));
+    },
+    clear() {
+      n.clear();
+    }
+  };
+}
+class Ln {
+  constructor(e, t) {
+    /** Event emitter for this action */
+    I(this, "eventEmitter");
+    /** Current status (step in the flow) */
+    I(this, "_status");
+    /** Tracked error - null means no error */
+    I(this, "_error", null);
+    /** Loading state - true when an async operation is in progress */
+    I(this, "_isLoading", !1);
+    /** Optional logger for debugging and monitoring */
+    I(this, "logger");
+    /** Operation timing for performance monitoring */
+    I(this, "_timing", /* @__PURE__ */ new Map());
+    this.eventEmitter = Ht(), this._status = e, this.logger = t;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Logging
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Log a message with context
+   *
+   * Automatically includes action name and current status.
+   * No-op if logger is not configured.
+   *
+   * Uses explicit switch to avoid dynamic property access (security best practice).
+   */
+  log(e, t, s) {
+    if (!this.logger) return;
+    const a = {
+      action: this.constructor.name,
+      status: this._status,
+      ...s
+    };
+    switch (e) {
+      case "debug":
+        this.logger.debug(t, a);
+        break;
+      case "info":
+        this.logger.info(t, a);
+        break;
+      case "warn":
+        this.logger.warn(t, a);
+        break;
+      case "error":
+        this.logger.error(t, a);
+        break;
+    }
+  }
+  /**
+   * Get timing for an operation
+   */
+  getTiming(e) {
+    return this._timing.get(e);
+  }
+  /**
+   * Get all operation timings
+   */
+  getAllTimings() {
+    return Object.fromEntries(this._timing);
+  }
+  /**
+   * Record timing for an operation
+   */
+  recordTiming(e, t) {
+    this._timing.set(e, t);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Current action status (which step in the flow) */
+  get status() {
+    return this._status;
+  }
+  /** Error that occurred (if any) - null means no error */
+  get error() {
+    return this._error;
+  }
+  /** Whether the action has failed (derived from error !== null) */
+  get isFailed() {
+    return this._error !== null;
+  }
+  /** Whether an async operation is in progress */
+  get isLoading() {
+    return this._isLoading;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Status Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Update the action status and emit status-change event
+   */
+  updateStatus(e) {
+    this._status = e, this.emitStatusChange(e);
+  }
+  /**
+   * Assert the action is in an expected status
+   *
+   * @param expected - Single status or array of allowed statuses
+   * @param action - Name of the action being performed (for error message)
+   * @throws LombardError if current status is not in expected list
+   */
+  assertStatus(e, t) {
+    const s = Array.isArray(e) ? e : [e];
+    if (!s.includes(this._status))
+      throw new E(
+        Z.INVALID_STATE,
+        `Cannot ${t} while status is ${this._status}, allowed: ${s.join(", ")}`
+      );
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Error Handling
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Clear any previous error
+   *
+   * Call this at the start of retry attempts to reset error state.
+   */
+  clearError() {
+    this._error = null;
+  }
+  /**
+   * Handle action failure
+   *
+   * Stores error, emits events, and throws.
+   * Status is NOT changed - it stays at the step where the error occurred.
+   * This allows callers to know exactly where the failure happened.
+   *
+   * @param error - The error that occurred
+   * @throws The wrapped LombardError
+   */
+  handleFailure(e) {
+    throw this._error = e instanceof E ? e : pe(e), this.emitError(this._error), this.emitFailed(), this._error;
+  }
+  /**
+   * Set loading state and emit event
+   */
+  setLoading(e) {
+    this._isLoading = e, this.emitLoading(e);
+  }
+  /**
+   * Perform an async operation with automatic state management
+   *
+   * This is the primary method for wrapping async operations in actions.
+   * Handles loading state, errors, and status transitions automatically.
+   *
+   * ## Automatic Behaviors
+   *
+   * - **isLoading**: Set to true before operation, false after (success or failure)
+   * - **error**: Cleared on start, set on failure
+   * - **status**: Optionally transitions to `successStatus` on success
+   *
+   * ## Design Philosophy: Orthogonal Concerns
+   *
+   * Status, loading, and error are independent:
+   * - `status` = "What step are you at?" (IDLE, NEEDS_AUTH, READY, etc.)
+   * - `isLoading` = "Is an operation in progress?" (true/false)
+   * - `error` = "Did something go wrong?" (Error | null)
+   *
+   * No transitional statuses (PREPARING, AUTHORIZING, etc.) needed!
+   * The UI can derive the display state:
+   * - IDLE + isLoading → "Preparing..."
+   * - NEEDS_AUTH + isLoading → "Authorizing..."
+   * - READY + isLoading → "Generating..."
+   *
+   * @param fn - Async function to execute
+   * @param successStatus - Status to transition to on success (optional)
+   * @returns Result of the operation
+   *
+   * @example Simple operation (no status change)
+   * ```typescript
+   * async execute() {
+   *   return this.act(async () => {
+   *     return this.depositAddress;
+   *   });
+   * }
+   * ```
+   *
+   * @example Operation with status transition
+   * ```typescript
+   * async authorize(): Promise<void> {
+   *   this.assertStatus([Status.NEEDS_AUTH, Status.READY], 'authorize');
+   *   if (this.status === Status.READY) return;
+   *
+   *   return this.act(
+   *     async () => {
+   *       const result = await this.signTransaction();
+   *       this.authState.signature = result.signature;
+   *     },
+   *     Status.READY
+   *   );
+   * }
+   * ```
+   *
+   * @example Flow visualization
+   * ```
+   * Success flow:
+   *   status: NEEDS_AUTH          -> NEEDS_AUTH          -> READY
+   *   isLoading: false -> true                   -> false
+   *
+   * Failure flow:
+   *   status: NEEDS_AUTH          -> NEEDS_AUTH (unchanged!)
+   *   isLoading: false -> true    -> false
+   *   error: null                 -> "User rejected"
+   * ```
+   */
+  async act(e, t) {
+    const s = performance.now(), a = t ?? "operation";
+    this.log("debug", `Starting ${a}`, { step: String(a) }), this.clearError(), this.setLoading(!0);
+    try {
+      const r = await e(), i = performance.now() - s;
+      return this.recordTiming(String(a), i), this.log("info", `Completed ${a}`, {
+        step: String(a),
+        duration: Math.round(i)
+      }), t !== void 0 && this.updateStatus(t), r;
+    } catch (r) {
+      const i = performance.now() - s, c = r instanceof E ? r : pe(r);
+      return this.recordTiming(String(a), i), this.log("error", `Failed ${a}`, {
+        step: String(a),
+        duration: Math.round(i),
+        errorCode: c.code,
+        errorMessage: c.message
+      }), this.handleFailure(r);
+    } finally {
+      this.setLoading(!1);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Event Handlers
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Register an event handler
+   *
+   * @param event - Event to listen for
+   * @param handler - Handler function
+   * @returns Unsubscribe function
+   */
+  on(e, t) {
+    return this.eventEmitter.on(e, t);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Event Emission
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Emit a progress update */
+  emitProgress(e) {
+    this.eventEmitter.emit("progress", e);
+  }
+  /** Emit a status change */
+  emitStatusChange(e) {
+    this.eventEmitter.emit("status-change", e);
+  }
+  /** Emit completion event */
+  emitCompleted() {
+    this.eventEmitter.emit("completed");
+  }
+  /** Emit failed event */
+  emitFailed() {
+    this.eventEmitter.emit("failed");
+  }
+  /** Emit error event */
+  emitError(e) {
+    this.eventEmitter.emit("error", e);
+  }
+  /** Emit loading state change */
+  emitLoading(e) {
+    this.eventEmitter.emit("loading", e);
+  }
+  /** Clear all event listeners */
+  clearListeners() {
+    this.eventEmitter.clear();
+  }
+}
+function zt(n) {
+  if (!n || typeof n != "string")
+    return !1;
+  if (n.startsWith("bc1") || n.startsWith("tb1"))
+    try {
+      return me.address.fromBech32(n), !0;
+    } catch {
+      return !1;
+    }
+  try {
+    return me.address.fromBase58Check(n), !0;
+  } catch {
+    return !1;
+  }
+}
+function qt(n) {
+  const e = /^[1-9A-HJ-NP-Za-km-z]+$/;
+  if (!n || typeof n != "string" || !e.test(n) || n.length < 32 || n.length > 44)
+    return !1;
+  try {
+    return Wt(n).length === 32;
+  } catch {
+    return !1;
+  }
+}
+function Wt(n) {
+  const e = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", t = {};
+  for (let u = 0; u < e.length; u++)
+    t[e[u]] = u;
+  if (n.length === 0)
+    return new Uint8Array(0);
+  let s = 0;
+  for (let u = 0; u < n.length && n[u] === "1"; u++)
+    s++;
+  const a = Math.ceil(n.length * Math.log(58) / Math.log(256)), r = new Uint8Array(a);
+  for (let u = s; u < n.length; u++) {
+    const h = t[n[u]];
+    if (h === void 0)
+      throw new Error(`Invalid base58 character: ${n[u]}`);
+    let A = h;
+    for (let w = a - 1; w >= 0; w--)
+      A += 58 * r[w], r[w] = A % 256, A = Math.floor(A / 256);
+  }
+  let i = 0;
+  for (; i < r.length && r[i] === 0; )
+    i++;
+  const c = new Uint8Array(s + (r.length - i));
+  return c.fill(0, 0, s), c.set(r.subarray(i), s), c;
+}
+function Ze(n) {
+  const e = L({ message: "Amount is required" }).min(1, "Amount is required").refine((t) => t !== "0", {
+    message: "Amount must be greater than 0"
+  }).refine(
+    (t) => {
+      const s = Number.parseFloat(t);
+      return !Number.isNaN(s) && s > 0;
+    },
+    { message: "Invalid amount format" }
+  );
+  return n !== void 0 && n > 0 ? e.refine(
+    (t) => Number.parseFloat(t) >= n,
+    { message: `Amount must be at least ${n}` }
+  ) : e;
+}
+const Kt = Ze(), Gt = Ze(Xe), Dn = Kt;
+jt([$t(), Zt()]).refine((n) => n > 0, { message: "Amount must be greater than 0" });
+const Pn = L({ message: "Address is required" }).regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address format"), Bn = L({ message: "Address is required" }).refine(qt, { message: "Invalid Solana address format" }), Mn = L({ message: "Address is required" }).regex(/^0x[a-fA-F0-9]{64}$/, "Invalid Sui address format"), Un = L({ message: "Address is required" }).regex(/^0x[a-fA-F0-9]{1,64}$/, "Invalid Starknet address format"), Vn = L({ message: "Address is required" }).refine(zt, { message: "Invalid Bitcoin address format" }), Yt = L().optional();
+L().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid transaction hash");
+Ft({
+  amount: Gt,
+  recipient: L({ message: "Recipient is required" }).min(1, "Recipient is required"),
+  referralCode: Yt
+});
+function Zn(n, e, t = {}) {
+  const s = n.safeParse(e);
+  if (!s.success) {
+    const a = s.error.issues[0], r = a == null ? void 0 : a.path[0], i = (a == null ? void 0 : a.message) ?? "Invalid parameter";
+    throw r === "amount" ? E.invalidAmount(i) : r === "recipient" ? E.invalidAddress(
+      e == null ? void 0 : e.recipient,
+      t.destChain
+    ) : E.invalidParameter(String(r), i);
+  }
+  return s.data;
+}
+const $n = {
+  /** Initial state - ready for prepare() */
+  IDLE: "idle",
+  // Authorization states (mutually exclusive - action uses one based on config)
+  /** User needs to sign fee authorization (EVM stake/deposit to Ethereum) */
+  NEEDS_FEE_AUTHORIZATION: "needs_fee_authorization",
+  /** User needs to confirm destination address (non-Ethereum destinations) */
+  NEEDS_ADDRESS_CONFIRMATION: "needs_address_confirmation",
+  /** User needs to sign vault deploy authorization (stake-and-deploy, deposit-and-deploy) */
+  NEEDS_DEPLOY_AUTHORIZATION: "needs_deploy_authorization",
+  /** Authorization complete - ready to generate address */
+  READY: "ready",
+  /** Deposit address generated - awaiting BTC deposit */
+  ADDRESS_READY: "address_ready"
+}, Fn = {
+  IDLE: "idle",
+  /** User needs to sign fee authorization (Ethereum/Sepolia only) */
+  NEEDS_FEE_AUTHORIZATION: "needs_fee_authorization",
+  /** User needs to approve token spending */
+  NEEDS_APPROVAL: "needs-approval",
+  READY: "ready",
+  CONFIRMING: "confirming",
+  COMPLETED: "completed"
+}, jn = {
+  IDLE: "idle",
+  READY: "ready",
+  CONFIRMING: "confirming",
+  COMPLETED: "completed"
+};
+export {
+  In as $,
+  Ft as A,
+  $n as B,
+  o as C,
+  Kt as D,
+  Fn as E,
+  ft as F,
+  De as G,
+  S as H,
+  pn as I,
+  Sn as J,
+  vn as K,
+  E as L,
+  gn as M,
+  jn as N,
+  yn as O,
+  lt as P,
+  _n as Q,
+  nt as R,
+  nn as S,
+  Tn as T,
+  bn as U,
+  Z as V,
+  xn as W,
+  fn as X,
+  L as Y,
+  Dn as Z,
+  Pn as _,
+  sn as a,
+  kn as a0,
+  at as a1,
+  wn as a2,
+  Yt as a3,
+  Gt as a4,
+  fe as a5,
+  p as a6,
+  Bn as a7,
+  Un as a8,
+  Mn as a9,
+  dn as aa,
+  Cn as ab,
+  Qe as b,
+  G as c,
+  an as d,
+  hn as e,
+  mn as f,
+  Nn as g,
+  En as h,
+  ie as i,
+  cn as j,
+  on as k,
+  An as l,
+  rn as m,
+  Le as n,
+  ln as o,
+  un as p,
+  Rn as q,
+  On as r,
+  st as s,
+  et as t,
+  rt as u,
+  tt as v,
+  pe as w,
+  Vn as x,
+  Ln as y,
+  Zn as z
+};
+//# sourceMappingURL=statusConstants-ZJia15m2.js.map