@klappay/types 3.0.0 → 3.0.2

package/dist/index.js

@@ -20,8 +20,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALT_TOKEN_ADDRESSES: () => ALT_TOKEN_ADDRESSES,
+  ALT_TOKEN_DECIMALS: () => ALT_TOKEN_DECIMALS,
   API_KEY_SCOPES: () => API_KEY_SCOPES,
   AcceptedPaymentSchema: () => AcceptedPaymentSchema,
+  AltTokenSchema: () => AltTokenSchema,
   ApiKeyScopeSchema: () => ApiKeyScopeSchema,
   CHARGE_ACCEPTED_PAYMENTS_MAX: () => CHARGE_ACCEPTED_PAYMENTS_MAX,
   CHARGE_AMOUNT_MAX: () => CHARGE_AMOUNT_MAX,
@@ -40,6 +43,7 @@ __export(index_exports, {
   CheckoutProductSchema: () => CheckoutProductSchema,
   CreateChargeSchema: () => CreateChargeSchema,
   CreateRecipientSchema: () => CreateRecipientSchema,
+  CreateSwapQuoteSchema: () => CreateSwapQuoteSchema,
   CreateWebhookSchema: () => CreateWebhookSchema,
   DistributionsDateFieldSchema: () => DistributionsDateFieldSchema,
   DistributionsMetricFieldSchema: () => DistributionsMetricFieldSchema,
@@ -89,6 +93,8 @@ __export(index_exports, {
   SplitDistributionStatusSchema: () => SplitDistributionStatusSchema,
   SplitRecipientInputSchema: () => SplitRecipientInputSchema,
   SplitRecipientSchema: () => SplitRecipientSchema,
+  SwapAlternativeSchema: () => SwapAlternativeSchema,
+  SwapQuoteSchema: () => SwapQuoteSchema,
   TOKEN_ADDRESSES: () => TOKEN_ADDRESSES,
   TOKEN_DECIMALS: () => TOKEN_DECIMALS,
   TimelineEventSchema: () => TimelineEventSchema,
@@ -110,6 +116,7 @@ __export(index_exports, {
   WebhookPayloadSchema: () => WebhookPayloadSchema,
   WebhookSchema: () => WebhookSchema,
   findConflictingScopes: () => findConflictingScopes,
+  listSwapAlternatives: () => listSwapAlternatives,
   paginatedSchema: () => paginatedSchema
 });
 module.exports = __toCommonJS(index_exports);
@@ -264,51 +271,88 @@ var TOKEN_ADDRESSES = {
   }
 };
 
+// src/alt-tokens.ts
+var import_zod7 = require("zod");
+var AltTokenSchema = import_zod7.z.enum(["ETH", "BNB", "MATIC", "AVAX", "BTC"]).describe(
+  "A non-stablecoin cryptocurrency Klappay trusts as swap input for a charge, via the 0x Swap API \u2014 swapped to one of the charge's `acceptedPayments` tokens before it ever reaches the merchant, so the merchant always receives USDC/USDT regardless of what the payer sent. Only a network's own native currency, plus `BTC` (wrapped) on the networks with deep, reputably-custodied liquidity, is trusted today (see `ALT_TOKEN_ADDRESSES`) \u2014 never assume every value here is available on every network."
+);
+var ALT_TOKEN_DECIMALS = {
+  ETH: 18,
+  BNB: 18,
+  MATIC: 18,
+  AVAX: 18,
+  BTC: 8
+};
+var ALT_TOKEN_ADDRESSES = {
+  base: { ETH: "native", BTC: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf" },
+  optimism: { ETH: "native", BTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095" },
+  ethereum: { ETH: "native", BTC: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599" },
+  arbitrum: { ETH: "native", BTC: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f" },
+  polygon: { MATIC: "native", BTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6" },
+  avalanche: { AVAX: "native" },
+  bnb: { BNB: "native" }
+};
+var SwapAlternativeSchema = import_zod7.z.object({
+  token: AltTokenSchema,
+  network: NetworkSchema.describe(
+    "Which network to send `token` on \u2014 pass both as `inputToken`/`inputNetwork` to `POST /v1/charges/{id}/quote`. The same token can appear more than once here, once per network that trusts it and that this charge accepts payment on."
+  )
+});
+function listSwapAlternatives(networks) {
+  const alternatives = [];
+  for (const network of new Set(networks)) {
+    for (const token of Object.keys(ALT_TOKEN_ADDRESSES[network] ?? {})) {
+      alternatives.push({ token, network });
+    }
+  }
+  return alternatives;
+}
+
 // src/charges.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/checkout-metadata.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var CHECKOUT_PRODUCTS_MAX = 20;
-var CheckoutProductSchema = import_zod7.z.object({
-  name: import_zod7.z.string().min(1).max(200).describe("What the payer is buying, shown as-is on the hosted checkout page."),
-  quantity: import_zod7.z.number().int().positive().max(9999).optional().describe("How many of this item. Omit for a single, unquantified item."),
-  imageUrl: import_zod7.z.string().url().max(2048).refine((value) => /^https?:\/\//.test(value), "must use http or https").optional().describe(
+var CheckoutProductSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1).max(200).describe("What the payer is buying, shown as-is on the hosted checkout page."),
+  quantity: import_zod8.z.number().int().positive().max(9999).optional().describe("How many of this item. Omit for a single, unquantified item."),
+  imageUrl: import_zod8.z.string().url().max(2048).refine((value) => /^https?:\/\//.test(value), "must use http or https").optional().describe(
     "Product image, fetched only by the payer's own browser \u2014 Klappay never fetches it server-side. Must be `http(s)`."
   )
 });
-var KlappayCheckoutMetadataSchema = import_zod7.z.object({
-  products: import_zod7.z.array(CheckoutProductSchema).max(CHECKOUT_PRODUCTS_MAX).optional().describe(
+var KlappayCheckoutMetadataSchema = import_zod8.z.object({
+  products: import_zod8.z.array(CheckoutProductSchema).max(CHECKOUT_PRODUCTS_MAX).optional().describe(
     `What the payer is buying, shown on the hosted checkout page \u2014 up to ${CHECKOUT_PRODUCTS_MAX} items. Purely informational: never validated against \`amount\`, never used by any payment or distribution logic.`
   )
 }).describe(
   "Reserved for Klappay \u2014 the one namespace inside `metadata` whose format is defined and enforced by Klappay, not by you. A `metadata.klappay` that does not match this shape is rejected outright (`400 validation_error`), unlike every other key in `metadata`, which accepts absolutely anything and never fails validation."
 );
-var MetadataWithKlappaySchema = import_zod7.z.object({ klappay: KlappayCheckoutMetadataSchema.optional() }).catchall(import_zod7.z.unknown()).describe(
+var MetadataWithKlappaySchema = import_zod8.z.object({ klappay: KlappayCheckoutMetadataSchema.optional() }).catchall(import_zod8.z.unknown()).describe(
   "Arbitrary key/value data, returned as-is on every read. Put whatever you want in here \u2014 none of it is validated, except the `klappay` key, which is reserved for Klappay: if present, it must match `KlappayCheckoutMetadataSchema` exactly, or the whole request is rejected with `400 validation_error`."
 );
 
 // src/charges.ts
-var ChargeStatusSchema = import_zod8.z.enum(["pending", "partially_paid", "confirmed", "expired", "underpaid"]).describe(
+var ChargeStatusSchema = import_zod9.z.enum(["pending", "partially_paid", "confirmed", "expired", "underpaid"]).describe(
   "Payment progress, from the payer side. `pending`: created, nothing received yet. `partially_paid`: some funds received, less than `amount`. `confirmed`: full amount received (or more \u2014 see `isOverpaid`). `expired`: `expiresAt` passed with zero funds received. `underpaid`: `expiresAt` passed while `partially_paid`. Every status is reached automatically, on its own timeline \u2014 there is no merchant-initiated cancellation. This never reflects whether funds actually reached the merchant \u2014 see `settlementStatus` for that."
 );
-var SettlementStatusSchema = import_zod8.z.enum(["pending", "completed", "failed"]).describe(
+var SettlementStatusSchema = import_zod9.z.enum(["pending", "completed", "failed"]).describe(
   "Progress of the payout to the merchant's wallet, a separate step from `status` \u2014 `status: confirmed` only means the payment was detected on-chain, not that the merchant has been paid yet. `pending`: payment detected, payout not yet attempted. `completed`: the merchant's wallet has the funds. `failed`: the payout attempt failed and retries were exhausted (rare; contact support). `null` on the parent `Charge` means no payout has been attempted yet \u2014 nothing has been received, or the charge is still in progress."
 );
 var CHARGE_EXPIRES_IN_MIN_SECONDS = 60;
 var CHARGE_EXPIRES_IN_MAX_SECONDS = 3600;
 var CHARGE_ACCEPTED_PAYMENTS_MAX = 14;
-var AcceptedPaymentSchema = import_zod8.z.object({
+var AcceptedPaymentSchema = import_zod9.z.object({
   token: TokenSchema,
   network: NetworkSchema
 });
-var AcceptedPaymentsSchema = import_zod8.z.array(AcceptedPaymentSchema).min(1, "At least one accepted payment is required.").max(CHARGE_ACCEPTED_PAYMENTS_MAX).superRefine((pairs, ctx) => {
+var AcceptedPaymentsSchema = import_zod9.z.array(AcceptedPaymentSchema).min(1, "At least one accepted payment is required.").max(CHARGE_ACCEPTED_PAYMENTS_MAX).superRefine((pairs, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   pairs.forEach((pair, index) => {
     const key = `${pair.token}:${pair.network}`;
     if (seen.has(key)) {
       ctx.addIssue({
-        code: import_zod8.z.ZodIssueCode.custom,
+        code: import_zod9.z.ZodIssueCode.custom,
         message: `Duplicate accepted payment: ${pair.token} on ${pair.network}.`,
         path: [index]
       });
@@ -316,7 +360,7 @@ var AcceptedPaymentsSchema = import_zod8.z.array(AcceptedPaymentSchema).min(1, "
     seen.add(key);
     if (!OPERATIONAL_NETWORKS.includes(pair.network)) {
       ctx.addIssue({
-        code: import_zod8.z.ZodIssueCode.custom,
+        code: import_zod9.z.ZodIssueCode.custom,
         message: `Network "${pair.network}" isn't live yet \u2014 only ${OPERATIONAL_NETWORKS.join(", ")} today.`,
         path: [index, "network"]
       });
@@ -326,32 +370,32 @@ var AcceptedPaymentsSchema = import_zod8.z.array(AcceptedPaymentSchema).min(1, "
   `Every \`(token, network)\` pair the payer is allowed to pay with \u2014 at least one, up to ${CHARGE_ACCEPTED_PAYMENTS_MAX}. This list is also the only restriction knob: the payer can use any combination of the pairs listed here, and every transfer on one of them is credited and sums toward the charge total (see \`paidWith\`) \u2014 e.g. a charge accepting USDC and USDT can be confirmed by $9 in USDC plus $1 in USDT, or by USDC arriving on two different accepted networks. To require payment in one specific token on one specific network, list only that single pair \u2014 a transfer on any pair not in this list is still recorded (for audit) but never credited. Each network must be live (see \`GET /v1/networks\` for the current matrix) \u2014 an unconfigured \`(token, network)\` combination for your environment is rejected with \`422 token_not_supported\`.`
 );
 var CHARGE_SPLIT_RECIPIENTS_MAX = 5;
-var SplitRecipientSchema = import_zod8.z.object({
-  address: import_zod8.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a 20-byte hex address").describe("EVM address to send a slice of this charge to."),
-  percent: import_zod8.z.number().positive().max(100).describe(
+var SplitRecipientSchema = import_zod9.z.object({
+  address: import_zod9.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a 20-byte hex address").describe("EVM address to send a slice of this charge to."),
+  percent: import_zod9.z.number().positive().max(100).describe(
     "Percent of *your own* net share (i.e. of `100 - feePercent`, not of the charge's gross `amount`) to route to this address instead of your own payout wallet. Klappay's fee is computed on the gross amount first and is never diluted by how you choose to split what's left \u2014 see `docs/payments.md`'s \"Settling the payout\" section for the exact math."
   ),
-  label: import_zod8.z.string().min(1).max(64).optional().describe(
+  label: import_zod9.z.string().min(1).max(64).optional().describe(
     'Free-form label for your own bookkeeping (e.g. `"supplier"`, `"sales rep"`) \u2014 echoed back unchanged, never interpreted by Klappay.'
   )
 });
-var SplitRecipientInputSchema = import_zod8.z.object({
-  recipientId: import_zod8.z.string().describe(
+var SplitRecipientInputSchema = import_zod9.z.object({
+  recipientId: import_zod9.z.string().describe(
     "id of a `Recipient` you already registered via `POST /v1/recipients` (not a raw address) \u2014 see `recipients:write`/`charges:split_write` scopes. A leaked `charges:write`-only key can never redirect payout to a brand new address this way, only reference one already trusted."
   ),
-  percent: import_zod8.z.number().positive().max(100).describe(
+  percent: import_zod9.z.number().positive().max(100).describe(
     "Percent of *your own* net share (i.e. of `100 - feePercent`, not of the charge's gross `amount`) to route to this recipient instead of your own payout wallet. Klappay's fee is computed on the gross amount first and is never diluted by how you choose to split what's left \u2014 see `docs/payments.md`'s \"Settling the payout\" section for the exact math."
   ),
-  label: import_zod8.z.string().min(1).max(64).optional().describe(
+  label: import_zod9.z.string().min(1).max(64).optional().describe(
     'Free-form label for your own bookkeeping (e.g. `"supplier"`, `"sales rep"`) \u2014 echoed back unchanged, never interpreted by Klappay. Independent of the label the recipient was registered with.'
   )
 });
-var SplitRecipientsInputSchema = import_zod8.z.array(SplitRecipientInputSchema).max(CHARGE_SPLIT_RECIPIENTS_MAX).superRefine((recipients, ctx) => {
+var SplitRecipientsInputSchema = import_zod9.z.array(SplitRecipientInputSchema).max(CHARGE_SPLIT_RECIPIENTS_MAX).superRefine((recipients, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   recipients.forEach((recipient, index) => {
     if (seen.has(recipient.recipientId)) {
       ctx.addIssue({
-        code: import_zod8.z.ZodIssueCode.custom,
+        code: import_zod9.z.ZodIssueCode.custom,
         message: `Duplicate split recipientId: ${recipient.recipientId}.`,
         path: [index, "recipientId"]
       });
@@ -362,79 +406,82 @@ var SplitRecipientsInputSchema = import_zod8.z.array(SplitRecipientInputSchema).
   `Optional extra recipients for this charge's split \u2014 e.g. a supplier or the sales rep who closed the deal \u2014 up to ${CHARGE_SPLIT_RECIPIENTS_MAX}, each referenced by \`recipientId\` (see \`POST /v1/recipients\`), never a raw address. Requires the \`charges:split_write\` scope in addition to \`charges:write\`. Frozen at creation exactly like everything else that shapes the split address; cannot be changed afterward. The sum of every \`percent\` here must fit within \`100 - feePercent\` (your own net share) \u2014 a request that doesn't is rejected with \`422 split_recipients_exceed_available_percent\`.`
 );
 var CHARGE_AMOUNT_MAX = 999999999999;
-var CreateChargeSchema = import_zod8.z.object({
-  amount: import_zod8.z.number().positive().max(CHARGE_AMOUNT_MAX).describe(
+var CreateChargeSchema = import_zod9.z.object({
+  amount: import_zod9.z.number().positive().max(CHARGE_AMOUNT_MAX).describe(
     "Amount to charge, in `currency` units (e.g. `49.9` = $49.90) \u2014 up to 6 decimal places; anything more precise is silently truncated. Required \u2014 every charge has a target amount, the first credited transfer that reaches it confirms the charge."
   ),
-  currency: import_zod8.z.literal("USD").default("USD").describe("Always `USD` today \u2014 the only supported currency."),
+  currency: import_zod9.z.literal("USD").default("USD").describe("Always `USD` today \u2014 the only supported currency."),
   acceptedPayments: AcceptedPaymentsSchema,
-  expiresIn: import_zod8.z.number().int().min(CHARGE_EXPIRES_IN_MIN_SECONDS).max(CHARGE_EXPIRES_IN_MAX_SECONDS).describe(
+  expiresIn: import_zod9.z.number().int().min(CHARGE_EXPIRES_IN_MIN_SECONDS).max(CHARGE_EXPIRES_IN_MAX_SECONDS).describe(
     "Seconds, not minutes or milliseconds \u2014 how long the charge stays open before it expires. Required, min 60, max 3600 (60 minutes) \u2014 sized off the slowest chain Klappay supports today (Ethereum mainnet, where a safely-confirmed transfer takes up to ~15 minutes), leaving real margin for payer-side delay (gas spikes, wallet friction) on top of that. Cannot be extended or shortened after creation."
   ),
-  idempotencyKey: import_zod8.z.string().min(1).max(255).optional().describe(
+  idempotencyKey: import_zod9.z.string().min(1).max(255).optional().describe(
     "Scoped to your tenant. Replaying the same key returns the original charge unchanged instead of creating a duplicate \u2014 safe to retry a request after a timeout without double-charging."
   ),
-  externalRef: import_zod8.z.string().min(1).max(255).optional().describe(
+  externalRef: import_zod9.z.string().min(1).max(255).optional().describe(
     "An opaque correlation id from your own system (e.g. an order id) \u2014 echoed back on the charge and in every webhook payload. Not interpreted or validated by Klappay."
   ),
-  source: import_zod8.z.string().min(1).max(64).optional().describe(
+  source: import_zod9.z.string().min(1).max(64).optional().describe(
     'Free-form label for what created this charge (e.g. `"checkout"`, `"invoice"`) \u2014 useful if you create charges from more than one flow and want to tell them apart later. Not a fixed enum; use whatever values make sense to you.'
   ),
   metadata: MetadataWithKlappaySchema.optional(),
-  redirectUrl: import_zod8.z.string().url().refine((value) => /^https?:\/\//.test(value), "must use http or https").optional().describe(
+  redirectUrl: import_zod9.z.string().url().refine((value) => /^https?:\/\//.test(value), "must use http or https").optional().describe(
     "Where to send the payer once this charge resolves, if you use Klappay's hosted checkout page (see `checkoutUrl` on the read shape) \u2014 ignored otherwise. Must be `http(s)` \u2014 a browser will navigate here, so `javascript:`/`data:` and other non-navigational schemes are rejected. Otherwise not validated beyond being well-formed; what happens at that destination is yours to build."
   ),
   splitRecipients: SplitRecipientsInputSchema.optional()
 });
-var ChargeSchema = import_zod8.z.object({
-  id: import_zod8.z.string().describe("Klappay-generated id, e.g. `ch_...`. Use this to look up the charge later."),
-  amount: import_zod8.z.number().describe("The amount originally requested, in `currency` units (up to 6 decimal places)."),
-  amountReceived: import_zod8.z.number().nullable().describe(
+var ChargeSchema = import_zod9.z.object({
+  id: import_zod9.z.string().describe("Klappay-generated id, e.g. `ch_...`. Use this to look up the charge later."),
+  amount: import_zod9.z.number().describe("The amount originally requested, in `currency` units (up to 6 decimal places)."),
+  amountReceived: import_zod9.z.number().nullable().describe(
     "Cumulative amount actually received on-chain so far, in `currency` units (up to 6 decimal places). `null` until the first transfer arrives. Can exceed `amount` \u2014 see `isOverpaid`."
   ),
-  isOverpaid: import_zod8.z.boolean().describe(
+  isOverpaid: import_zod9.z.boolean().describe(
     "`true` if `amountReceived` ended up greater than `amount`. Klappay never refunds the difference automatically \u2014 see the docs for why."
   ),
-  currency: import_zod8.z.string().describe("Always `USD` today \u2014 the only supported currency."),
-  acceptedPayments: import_zod8.z.array(AcceptedPaymentSchema).describe(
+  currency: import_zod9.z.string().describe("Always `USD` today \u2014 the only supported currency."),
+  acceptedPayments: import_zod9.z.array(AcceptedPaymentSchema).describe(
     "Every `(token, network)` pair this charge was configured to accept, unchanged after creation."
   ),
-  paidWith: import_zod8.z.array(AcceptedPaymentSchema).describe(
+  paidWith: import_zod9.z.array(AcceptedPaymentSchema).describe(
     "Every distinct `(token, network)` pair that has actually contributed a credited transfer so far \u2014 empty until the first one arrives. Can hold more than one entry: a charge accepting several pairs can be paid across a combination of them, and every entry here sums toward `amountReceived`."
   ),
-  address: import_zod8.z.string().describe(
+  swapAlternatives: import_zod9.z.array(SwapAlternativeSchema).describe(
+    "Every `(token, network)` pair the payer can pay with instead, via `POST /v1/charges/{id}/quote` \u2014 derived from the networks in `acceptedPayments` (e.g. a charge accepting USDC on both Base and Optimism lists `ETH` on Base and `ETH` on Optimism separately, since they're different networks the payer has to choose between, not one merged option). Pass an entry's `token`/`network` straight through as `inputToken`/`inputNetwork`. Recomputed on every read against Klappay's current trusted list, not frozen at creation \u2014 empty if this charge's networks have no trusted alt-token, if swap-to-pay isn't configured on this deployment, or if `environment` is `test` (0x, who powers the swap, has no testnet support at all \u2014 `POST /v1/charges/{id}/quote` always rejects a test-environment charge with `422 swap_test_environment_unsupported`)."
+  ),
+  address: import_zod9.z.string().describe(
     "The on-chain address the payer must send funds to \u2014 identical across every accepted network (0xSplits addresses are chain-agnostic). Unique per charge, predicted at creation time \u2014 funds sent here go directly to the merchant, Klappay never custodies them."
   ),
   status: ChargeStatusSchema,
   settlementStatus: SettlementStatusSchema.nullable(),
   environment: EnvironmentSchema,
-  apiKeyId: import_zod8.z.string().nullable().describe(
+  apiKeyId: import_zod9.z.string().nullable().describe(
     "Which of your API keys created this charge. `null` for a charge created before this field existed."
   ),
-  txHash: import_zod8.z.string().nullable().describe(
+  txHash: import_zod9.z.string().nullable().describe(
     "Transaction hash of the most recent transfer detected for this charge. `null` until a payment is detected."
   ),
-  externalRef: import_zod8.z.string().nullable(),
-  source: import_zod8.z.string().nullable(),
+  externalRef: import_zod9.z.string().nullable(),
+  source: import_zod9.z.string().nullable(),
   metadata: MetadataWithKlappaySchema.nullable(),
-  redirectUrl: import_zod8.z.string().nullable().describe("Echoes the `redirectUrl` set at creation, if any. `null` if none was set."),
-  checkoutUrl: import_zod8.z.string().nullable().describe(
+  redirectUrl: import_zod9.z.string().nullable().describe("Echoes the `redirectUrl` set at creation, if any. `null` if none was set."),
+  checkoutUrl: import_zod9.z.string().nullable().describe(
     "Link to Klappay's hosted checkout page for this charge. `null` if this deployment has no hosted checkout configured \u2014 build your own payment UI from `address`/`acceptedPayments` instead."
   ),
-  splitRecipients: import_zod8.z.array(SplitRecipientSchema).describe("Echoes whatever extra split recipients were set at creation \u2014 empty array if none."),
-  createdAt: import_zod8.z.string().datetime(),
-  expiresAt: import_zod8.z.string().datetime().describe(
+  splitRecipients: import_zod9.z.array(SplitRecipientSchema).describe("Echoes whatever extra split recipients were set at creation \u2014 empty array if none."),
+  createdAt: import_zod9.z.string().datetime(),
+  expiresAt: import_zod9.z.string().datetime().describe(
     "When this charge stops accepting payment, if still `pending`/`partially_paid` by then."
   ),
-  confirmedAt: import_zod8.z.string().datetime().nullable().describe("When `status` first reached `confirmed`. `null` until then."),
-  settledAt: import_zod8.z.string().datetime().nullable().describe(
+  confirmedAt: import_zod9.z.string().datetime().nullable().describe("When `status` first reached `confirmed`. `null` until then."),
+  settledAt: import_zod9.z.string().datetime().nullable().describe(
     "When `settlementStatus` first reached `completed` \u2014 the merchant's wallet actually has the funds. `null` until then, including while `settlementStatus` is `pending`/`failed`."
   ),
-  lastActivityAt: import_zod8.z.string().datetime().describe(
+  lastActivityAt: import_zod9.z.string().datetime().describe(
     "When a transfer was last credited toward this charge, or `createdAt` if none has arrived yet."
   )
 });
-var ListChargesSchema = import_zod8.z.object({
+var ListChargesSchema = import_zod9.z.object({
   status: ChargeStatusSchema.optional(),
   token: TokenSchema.optional().describe(
     "Filters on `paidWith.token` \u2014 the pair actually paid, not accepted."
@@ -443,13 +490,13 @@ var ListChargesSchema = import_zod8.z.object({
     "Filters on `paidWith.network` \u2014 the pair actually paid, not accepted."
   ),
   environment: EnvironmentSchema.optional(),
-  since: import_zod8.z.string().datetime().optional().describe(
+  since: import_zod9.z.string().datetime().optional().describe(
     "Only return charges created at or after this timestamp (filters on `createdAt`, not on when the status last changed). If polling as a fallback for missed webhooks, use a window at least as wide as the longest `expiresIn` your charges use, or you can miss a long-lived charge that changed status outside a narrower window."
   ),
-  isOverpaid: import_zod8.z.enum(["true", "false"]).transform((v) => v === "true").optional()
+  isOverpaid: import_zod9.z.enum(["true", "false"]).transform((v) => v === "true").optional()
 }).extend(PaginationQuerySchema.shape);
 var PaginatedChargesSchema = paginatedSchema(ChargeSchema);
-var GetChargeQrCodeQuerySchema = import_zod8.z.object({
+var GetChargeQrCodeQuerySchema = import_zod9.z.object({
   token: TokenSchema.optional().describe(
     "Which accepted `(token, network)` pair to encode in the QR \u2014 required if `acceptedPayments` has more than one pair, since there is no single unambiguous default to fall back to. Ignored (and unnecessary) when the charge accepts exactly one pair."
   ),
@@ -457,61 +504,61 @@ var GetChargeQrCodeQuerySchema = import_zod8.z.object({
 });
 
 // src/distributions.ts
-var import_zod9 = require("zod");
-var SplitDistributionStatusSchema = import_zod9.z.enum(["pending", "processing", "completed", "failed"]).describe(
+var import_zod10 = require("zod");
+var SplitDistributionStatusSchema = import_zod10.z.enum(["pending", "processing", "completed", "failed"]).describe(
   "Status of one payout attempt to the merchant, for a single `(token, network)` pair \u2014 a charge that settles across more than one pair has one of these per pair. `pending`: queued, not yet claimed by a distributor. `processing`: a distributor (Klappay's own worker, or anyone racing to call `distribute()` first, see `PendingDistributionSchema`) has claimed it and is submitting the on-chain transaction. `completed`: the merchant's wallet has the funds. `failed`: every automatic retry was exhausted."
 );
-var PendingDistributionRecipientSchema = import_zod9.z.object({
-  address: import_zod9.z.string().describe("On-chain recipient address."),
-  percentAllocation: import_zod9.z.number().describe("This recipient's share of the split, as a percentage (e.g. `99.0991` = 99.0991%).")
+var PendingDistributionRecipientSchema = import_zod10.z.object({
+  address: import_zod10.z.string().describe("On-chain recipient address."),
+  percentAllocation: import_zod10.z.number().describe("This recipient's share of the split, as a percentage (e.g. `99.0991` = 99.0991%).")
 });
-var PendingDistributionSchema = import_zod9.z.object({
-  splitAddress: import_zod9.z.string().describe("The on-chain 0xSplits address to call `distribute()` on."),
+var PendingDistributionSchema = import_zod10.z.object({
+  splitAddress: import_zod10.z.string().describe("The on-chain 0xSplits address to call `distribute()` on."),
   network: NetworkSchema,
   token: TokenSchema,
-  recipients: import_zod9.z.array(PendingDistributionRecipientSchema).describe(
+  recipients: import_zod10.z.array(PendingDistributionRecipientSchema).describe(
     "The exact recipient list to pass to `distribute()` \u2014 the split contract only stores a hash of this config, so the caller must supply the identical array to prove it matches. Always present, never reconstructed from partial data."
   ),
-  distributorFeePercent: import_zod9.z.number().describe(
+  distributorFeePercent: import_zod10.z.number().describe(
     "Percentage of the split balance paid to whoever calls `distribute()` first (e.g. `0.1` = 0.1%). Frozen at charge creation, same for every distribution today."
   ),
-  estimatedRewardAmount: import_zod9.z.number().describe(
+  estimatedRewardAmount: import_zod10.z.number().describe(
     "Estimate only, in the charge's `currency` units, based on the amount Klappay detected on-chain \u2014 not a live read of the split's current balance. Read the balance yourself before submitting a transaction; a stale estimate is harmless (see the docs), never a reason to skip that check."
   ),
-  availableSince: import_zod9.z.string().datetime().describe("When this distribution entered its grace period."),
-  graceEndsAt: import_zod9.z.string().datetime().describe(
+  availableSince: import_zod10.z.string().datetime().describe("When this distribution entered its grace period."),
+  graceEndsAt: import_zod10.z.string().datetime().describe(
     "When Klappay's own worker may claim this distribution. Racing to call `distribute()` after this timestamp is possible but increasingly likely to lose to the worker."
   )
 });
 var PaginatedPendingDistributionsSchema = paginatedSchema(PendingDistributionSchema);
-var ListenPendingDistributionsQuerySchema = import_zod9.z.object({
-  limit: import_zod9.z.coerce.number().int().min(0).max(PAGINATION_LIMIT_MAX).default(0).describe(
+var ListenPendingDistributionsQuerySchema = import_zod10.z.object({
+  limit: import_zod10.z.coerce.number().int().min(0).max(PAGINATION_LIMIT_MAX).default(0).describe(
     "How many currently-claimable distributions to emit as an initial snapshot right after connecting \u2014 each as a synthetic `distribution.available` event \u2014 before continuing with real-time deltas. `0` (the default, same as omitting it) sends no snapshot at all, matching this endpoint's original behavior: connect first, then call `GET /v1/distributions/pending` yourself to bootstrap. Not a page \u2014 there is no cursor for this snapshot, so if more than `limit` are claimable at connect time, the excess is simply not sent; call `GET /v1/distributions/pending` directly for a complete, paginated listing."
   )
 });
-var PendingDistributionEventSchema = import_zod9.z.discriminatedUnion("type", [
-  import_zod9.z.object({
-    type: import_zod9.z.literal("distribution.available"),
+var PendingDistributionEventSchema = import_zod10.z.discriminatedUnion("type", [
+  import_zod10.z.object({
+    type: import_zod10.z.literal("distribution.available"),
     distribution: PendingDistributionSchema
   }),
-  import_zod9.z.object({
-    type: import_zod9.z.literal("distribution.claimed"),
-    splitAddress: import_zod9.z.string().describe("No longer claimable \u2014 either settled by someone, or picked up by the worker.")
+  import_zod10.z.object({
+    type: import_zod10.z.literal("distribution.claimed"),
+    splitAddress: import_zod10.z.string().describe("No longer claimable \u2014 either settled by someone, or picked up by the worker.")
   })
 ]);
 
 // src/metrics.ts
-var import_zod10 = require("zod");
-var MetricsResourceSchema = import_zod10.z.enum(["charges", "transactions", "distributions"]).describe(
+var import_zod11 = require("zod");
+var MetricsResourceSchema = import_zod11.z.enum(["charges", "transactions", "distributions"]).describe(
   "Which underlying dataset to query. `charges`: one row per charge. `transactions`: one row per detected on-chain transfer \u2014 a charge paid in installments has more than one. `distributions`: one row per payout attempt to the merchant, one per `(token, network)` pair a charge settled across."
 );
-var MetricsAggregationSchema = import_zod10.z.enum(["count", "sum", "avg", "min", "max"]).describe(
+var MetricsAggregationSchema = import_zod11.z.enum(["count", "sum", "avg", "min", "max"]).describe(
   "`count` counts matching rows and never takes `field`. `sum`/`avg`/`min`/`max` require `field` to be set to one of the resource\u2019s numeric fields."
 );
-var MetricsFilterOperatorSchema = import_zod10.z.enum(["eq", "neq", "in", "gt", "gte", "lt", "lte"]).describe(
+var MetricsFilterOperatorSchema = import_zod11.z.enum(["eq", "neq", "in", "gt", "gte", "lt", "lte"]).describe(
   "`in` expects an array value (max 50 entries); every other operator expects a single scalar."
 );
-var MetricsDateGranularitySchema = import_zod10.z.enum(["day", "week", "month", "year"]).describe(
+var MetricsDateGranularitySchema = import_zod11.z.enum(["day", "week", "month", "year"]).describe(
   "Bucket width for a `date_bucket` `groupBy` entry \u2014 Postgres `date_trunc` semantics (UTC)."
 );
 var metricsQueryEnvironmentSchema = EnvironmentSchema.describe(
@@ -524,151 +571,151 @@ var METRICS_QUERY_MAX_GROUP_BY = 3;
 var METRICS_QUERY_MAX_FILTERS = 20;
 var METRICS_QUERY_MAX_METRICS = 10;
 var METRIC_ALIAS_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var metricAliasSchema = import_zod10.z.string().min(1).max(64).regex(
+var metricAliasSchema = import_zod11.z.string().min(1).max(64).regex(
   METRIC_ALIAS_PATTERN,
   "Must start with a letter or underscore, and contain only letters, digits, and underscores \u2014 this becomes a SQL column alias."
 ).optional();
-var MetricsFilterValueSchema = import_zod10.z.union([
-  import_zod10.z.string().max(255),
-  import_zod10.z.number(),
-  import_zod10.z.boolean(),
-  import_zod10.z.array(import_zod10.z.union([import_zod10.z.string().max(255), import_zod10.z.number()])).min(1).max(50)
+var MetricsFilterValueSchema = import_zod11.z.union([
+  import_zod11.z.string().max(255),
+  import_zod11.z.number(),
+  import_zod11.z.boolean(),
+  import_zod11.z.array(import_zod11.z.union([import_zod11.z.string().max(255), import_zod11.z.number()])).min(1).max(50)
 ]);
-var orderBySchema = import_zod10.z.object({
-  key: import_zod10.z.string().min(1).max(64).regex(
+var orderBySchema = import_zod11.z.object({
+  key: import_zod11.z.string().min(1).max(64).regex(
     METRIC_ALIAS_PATTERN,
     "Must start with a letter or underscore, and contain only letters, digits, and underscores \u2014 every valid output column name already looks like this."
   ).describe(
     "An output column name from this same query \u2014 either a `groupBy` field name, or a metric\u2019s `alias` (or its default name: `${aggregation}` for `count`, `${aggregation}_${field}` otherwise, e.g. `sum_amount`). Must match `^[a-zA-Z_][a-zA-Z0-9_]*$` \u2014 every real output column name already does, so this only ever rejects a value that could never have been one."
   ),
-  direction: import_zod10.z.enum(["asc", "desc"])
+  direction: import_zod11.z.enum(["asc", "desc"])
 }).describe(
   "Sort the result rows by any output column \u2014 including the bucket field itself for a `date_bucket` query (e.g. `createdAt`). Omit to get ascending-by-bucket order for a date-bucketed query, or implementation-defined (not guaranteed stable) order otherwise."
 );
-var limitSchema = import_zod10.z.number().int().min(1).max(METRICS_QUERY_MAX_ROW_LIMIT).default(METRICS_QUERY_DEFAULT_ROW_LIMIT).describe(
+var limitSchema = import_zod11.z.number().int().min(1).max(METRICS_QUERY_MAX_ROW_LIMIT).default(METRICS_QUERY_DEFAULT_ROW_LIMIT).describe(
   `Max rows to return, ${1}\u2013${METRICS_QUERY_MAX_ROW_LIMIT}, default ${METRICS_QUERY_DEFAULT_ROW_LIMIT}. If more rows matched, \`meta.truncated\` is \`true\` on the response \u2014 narrow the query instead of just raising this.`
 );
-var ChargesQueryFieldSchema = import_zod10.z.enum(["status", "source", "apiKeyId", "currency", "isOverpaid", "externalRef"]).describe(
+var ChargesQueryFieldSchema = import_zod11.z.enum(["status", "source", "apiKeyId", "currency", "isOverpaid", "externalRef"]).describe(
   "A `Charge` field to filter or group by \u2014 see `ChargeStatusSchema` for `status`'s own possible values (charges.md). `source`/`externalRef` are free-form strings your own integration set at creation, not a fixed enum."
 );
-var ChargesMetricFieldSchema = import_zod10.z.enum(["amount", "amountReceived", "feePercent"]).describe(
+var ChargesMetricFieldSchema = import_zod11.z.enum(["amount", "amountReceived", "feePercent"]).describe(
   "A `Charge` numeric field to aggregate. `amount`/`amountReceived` are decimal currency amounts (requested vs. actually received \u2014 see `charges.md`). `feePercent` is the platform fee frozen on the charge at creation, e.g. `1.5` means 1.5%."
 );
-var ChargesDateFieldSchema = import_zod10.z.enum(["createdAt", "confirmedAt", "lastActivityAt", "expiresAt"]).describe(
+var ChargesDateFieldSchema = import_zod11.z.enum(["createdAt", "confirmedAt", "lastActivityAt", "expiresAt"]).describe(
   "A `Charge` timestamp to filter/bucket by. `confirmedAt` is `null` until the charge reaches `confirmed` \u2014 a `dateRange`/`date_bucket` on it implicitly excludes every charge that never confirmed. `expiresAt` is always present (set at creation), useful for e.g. finding charges expiring soon or measuring how close to expiry charges typically resolve."
 );
-var ChargesFilterSchema = import_zod10.z.object({
+var ChargesFilterSchema = import_zod11.z.object({
   field: ChargesQueryFieldSchema,
   operator: MetricsFilterOperatorSchema,
   value: MetricsFilterValueSchema
 });
-var ChargesGroupBySchema = import_zod10.z.union([
-  import_zod10.z.object({ type: import_zod10.z.literal("field"), field: ChargesQueryFieldSchema }),
-  import_zod10.z.object({
-    type: import_zod10.z.literal("date_bucket"),
+var ChargesGroupBySchema = import_zod11.z.union([
+  import_zod11.z.object({ type: import_zod11.z.literal("field"), field: ChargesQueryFieldSchema }),
+  import_zod11.z.object({
+    type: import_zod11.z.literal("date_bucket"),
     field: ChargesDateFieldSchema,
     granularity: MetricsDateGranularitySchema
   })
 ]);
-var ChargesMetricSchema = import_zod10.z.object({
+var ChargesMetricSchema = import_zod11.z.object({
   aggregation: MetricsAggregationSchema,
   field: ChargesMetricFieldSchema.optional(),
   alias: metricAliasSchema
 });
-var ChargesMetricsQuerySchema = import_zod10.z.object({
-  resource: import_zod10.z.literal("charges"),
+var ChargesMetricsQuerySchema = import_zod11.z.object({
+  resource: import_zod11.z.literal("charges"),
   environment: metricsQueryEnvironmentSchema,
-  dateRange: import_zod10.z.object({
+  dateRange: import_zod11.z.object({
     field: ChargesDateFieldSchema,
-    from: import_zod10.z.string().max(64).datetime(),
-    to: import_zod10.z.string().max(64).datetime()
+    from: import_zod11.z.string().max(64).datetime(),
+    to: import_zod11.z.string().max(64).datetime()
   }),
-  groupBy: import_zod10.z.array(ChargesGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
-  metrics: import_zod10.z.array(ChargesMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
-  filters: import_zod10.z.array(ChargesFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
+  groupBy: import_zod11.z.array(ChargesGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
+  metrics: import_zod11.z.array(ChargesMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
+  filters: import_zod11.z.array(ChargesFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
   orderBy: orderBySchema.optional(),
   limit: limitSchema
 });
-var TransactionsQueryFieldSchema = import_zod10.z.enum(["network", "token", "source", "causedTransition"]).describe(
+var TransactionsQueryFieldSchema = import_zod11.z.enum(["network", "token", "source", "causedTransition"]).describe(
   "A `Transaction` field to filter or group by \u2014 see `NetworkSchema`/`TokenSchema`/`TransactionSourceSchema` for their possible values. `causedTransition` is `true` only for the transfer(s) that actually flipped the charge's `status` \u2014 a charge paid in installments can have more than one; filtering/grouping on it excludes no-op duplicate transfers (see `TimelineEvent.causedTransition` in charges.md for the full explanation)."
 );
-var TransactionsMetricFieldSchema = import_zod10.z.enum(["amount"]).describe("The transfer amount, in the charge's `currency` units.");
-var TransactionsDateFieldSchema = import_zod10.z.enum(["detectedAt"]).describe("When Klappay detected this transfer on-chain (not when it was mined).");
-var TransactionsFilterSchema = import_zod10.z.object({
+var TransactionsMetricFieldSchema = import_zod11.z.enum(["amount"]).describe("The transfer amount, in the charge's `currency` units.");
+var TransactionsDateFieldSchema = import_zod11.z.enum(["detectedAt"]).describe("When Klappay detected this transfer on-chain (not when it was mined).");
+var TransactionsFilterSchema = import_zod11.z.object({
   field: TransactionsQueryFieldSchema,
   operator: MetricsFilterOperatorSchema,
   value: MetricsFilterValueSchema
 });
-var TransactionsGroupBySchema = import_zod10.z.union([
-  import_zod10.z.object({ type: import_zod10.z.literal("field"), field: TransactionsQueryFieldSchema }),
-  import_zod10.z.object({
-    type: import_zod10.z.literal("date_bucket"),
+var TransactionsGroupBySchema = import_zod11.z.union([
+  import_zod11.z.object({ type: import_zod11.z.literal("field"), field: TransactionsQueryFieldSchema }),
+  import_zod11.z.object({
+    type: import_zod11.z.literal("date_bucket"),
     field: TransactionsDateFieldSchema,
     granularity: MetricsDateGranularitySchema
   })
 ]);
-var TransactionsMetricSchema = import_zod10.z.object({
+var TransactionsMetricSchema = import_zod11.z.object({
   aggregation: MetricsAggregationSchema,
   field: TransactionsMetricFieldSchema.optional(),
   alias: metricAliasSchema
 });
-var TransactionsMetricsQuerySchema = import_zod10.z.object({
-  resource: import_zod10.z.literal("transactions"),
+var TransactionsMetricsQuerySchema = import_zod11.z.object({
+  resource: import_zod11.z.literal("transactions"),
   environment: metricsQueryEnvironmentSchema,
-  dateRange: import_zod10.z.object({
+  dateRange: import_zod11.z.object({
     field: TransactionsDateFieldSchema,
-    from: import_zod10.z.string().max(64).datetime(),
-    to: import_zod10.z.string().max(64).datetime()
+    from: import_zod11.z.string().max(64).datetime(),
+    to: import_zod11.z.string().max(64).datetime()
   }),
-  groupBy: import_zod10.z.array(TransactionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
-  metrics: import_zod10.z.array(TransactionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
-  filters: import_zod10.z.array(TransactionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
+  groupBy: import_zod11.z.array(TransactionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
+  metrics: import_zod11.z.array(TransactionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
+  filters: import_zod11.z.array(TransactionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
   orderBy: orderBySchema.optional(),
   limit: limitSchema
 });
-var DistributionsQueryFieldSchema = import_zod10.z.enum(["status", "network", "token", "distributorAddress"]).describe(
+var DistributionsQueryFieldSchema = import_zod11.z.enum(["status", "network", "token", "distributorAddress"]).describe(
   "A `SplitDistribution` field to filter or group by \u2014 see `SplitDistributionStatusSchema`/`NetworkSchema`/`TokenSchema` for their possible values. `distributorAddress` is the public on-chain address that actually called `distribute()` for a `completed` distribution \u2014 Klappay's own operator address if settled by Klappay's own worker, a community keeper's address if settled externally (or `null` on the rare case that lookup failed), `null` for every non-`completed` status."
 );
-var DistributionsMetricFieldSchema = import_zod10.z.enum(["attempts"]).describe(
+var DistributionsMetricFieldSchema = import_zod11.z.enum(["attempts"]).describe(
   "How many times a payout was attempted for this settlement so far \u2014 incremented on every attempt, whether it succeeded or is being retried after failing. A high `attempts` alongside `status: 'failed'` means every automatic retry was exhausted."
 );
-var DistributionsDateFieldSchema = import_zod10.z.enum(["createdAt", "processingStartedAt", "completedAt"]).describe(
+var DistributionsDateFieldSchema = import_zod11.z.enum(["createdAt", "processingStartedAt", "completedAt"]).describe(
   "`createdAt`: when this settlement was queued. `processingStartedAt`: when a worker began its most recent attempt at the payout \u2014 `null` until the first attempt, then overwritten on every subsequent retry, so it reflects the *latest* attempt's start, not the first. `completedAt`: when it actually paid out \u2014 `null` until `status` reaches `completed`, so a `dateRange`/`date_bucket` on it implicitly excludes every distribution still pending/processing/failed."
 );
-var DistributionsFilterSchema = import_zod10.z.object({
+var DistributionsFilterSchema = import_zod11.z.object({
   field: DistributionsQueryFieldSchema,
   operator: MetricsFilterOperatorSchema,
   value: MetricsFilterValueSchema
 });
-var DistributionsGroupBySchema = import_zod10.z.union([
-  import_zod10.z.object({ type: import_zod10.z.literal("field"), field: DistributionsQueryFieldSchema }),
-  import_zod10.z.object({
-    type: import_zod10.z.literal("date_bucket"),
+var DistributionsGroupBySchema = import_zod11.z.union([
+  import_zod11.z.object({ type: import_zod11.z.literal("field"), field: DistributionsQueryFieldSchema }),
+  import_zod11.z.object({
+    type: import_zod11.z.literal("date_bucket"),
     field: DistributionsDateFieldSchema,
     granularity: MetricsDateGranularitySchema
   })
 ]);
-var DistributionsMetricSchema = import_zod10.z.object({
+var DistributionsMetricSchema = import_zod11.z.object({
   aggregation: MetricsAggregationSchema,
   field: DistributionsMetricFieldSchema.optional(),
   alias: metricAliasSchema
 });
-var DistributionsMetricsQuerySchema = import_zod10.z.object({
-  resource: import_zod10.z.literal("distributions"),
+var DistributionsMetricsQuerySchema = import_zod11.z.object({
+  resource: import_zod11.z.literal("distributions"),
   environment: metricsQueryEnvironmentSchema,
-  dateRange: import_zod10.z.object({
+  dateRange: import_zod11.z.object({
     field: DistributionsDateFieldSchema,
-    from: import_zod10.z.string().max(64).datetime(),
-    to: import_zod10.z.string().max(64).datetime()
+    from: import_zod11.z.string().max(64).datetime(),
+    to: import_zod11.z.string().max(64).datetime()
   }),
-  groupBy: import_zod10.z.array(DistributionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
-  metrics: import_zod10.z.array(DistributionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
-  filters: import_zod10.z.array(DistributionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
+  groupBy: import_zod11.z.array(DistributionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
+  metrics: import_zod11.z.array(DistributionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
+  filters: import_zod11.z.array(DistributionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
   orderBy: orderBySchema.optional(),
   limit: limitSchema
 });
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
+var MetricsQuerySchema = import_zod11.z.discriminatedUnion("resource", [
   ChargesMetricsQuerySchema,
   TransactionsMetricsQuerySchema,
   DistributionsMetricsQuerySchema
@@ -677,7 +724,7 @@ var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
   const to = new Date(input.dateRange.to);
   if (from >= to) {
     ctx.addIssue({
-      code: import_zod10.z.ZodIssueCode.custom,
+      code: import_zod11.z.ZodIssueCode.custom,
       message: "`dateRange.from` must be before `dateRange.to`.",
       path: ["dateRange", "from"]
     });
@@ -685,7 +732,7 @@ var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
   const spanDays = (to.getTime() - from.getTime()) / ONE_DAY_MS;
   if (spanDays > MAX_METRICS_QUERY_DATE_RANGE_DAYS) {
     ctx.addIssue({
-      code: import_zod10.z.ZodIssueCode.custom,
+      code: import_zod11.z.ZodIssueCode.custom,
       message: `\`dateRange\` cannot span more than ${MAX_METRICS_QUERY_DATE_RANGE_DAYS} days.`,
       path: ["dateRange", "to"]
     });
@@ -693,7 +740,7 @@ var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
   const dateBucketCount = input.groupBy.filter((entry) => entry.type === "date_bucket").length;
   if (dateBucketCount > 1) {
     ctx.addIssue({
-      code: import_zod10.z.ZodIssueCode.custom,
+      code: import_zod11.z.ZodIssueCode.custom,
       message: "At most one `date_bucket` entry is allowed in `groupBy`.",
       path: ["groupBy"]
     });
@@ -701,7 +748,7 @@ var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
   input.metrics.forEach((metric, index) => {
     if (metric.aggregation !== "count" && metric.field === void 0) {
       ctx.addIssue({
-        code: import_zod10.z.ZodIssueCode.custom,
+        code: import_zod11.z.ZodIssueCode.custom,
         message: "`field` is required unless `aggregation` is `count`.",
         path: ["metrics", index, "field"]
       });
@@ -710,7 +757,7 @@ var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
   const aliases = input.metrics.map((metric) => metric.alias).filter((alias) => alias !== void 0);
   if (new Set(aliases).size !== aliases.length) {
     ctx.addIssue({
-      code: import_zod10.z.ZodIssueCode.custom,
+      code: import_zod11.z.ZodIssueCode.custom,
       message: "Every `metrics[].alias` must be unique.",
       path: ["metrics"]
     });
@@ -719,32 +766,32 @@ var MetricsQuerySchema = import_zod10.z.discriminatedUnion("resource", [
   input.metrics.forEach((metric, index) => {
     if (metric.alias !== void 0 && reservedNames.has(metric.alias)) {
       ctx.addIssue({
-        code: import_zod10.z.ZodIssueCode.custom,
+        code: import_zod11.z.ZodIssueCode.custom,
         message: `\`alias\` "${metric.alias}" collides with a \`groupBy\` field name (or the reserved word "bucket") \u2014 choose a different alias.`,
         path: ["metrics", index, "alias"]
       });
     }
   });
 });
-var MetricsQueryResultRowSchema = import_zod10.z.record(
-  import_zod10.z.string(),
-  import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number(), import_zod10.z.boolean(), import_zod10.z.null()])
+var MetricsQueryResultRowSchema = import_zod11.z.record(
+  import_zod11.z.string(),
+  import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number(), import_zod11.z.boolean(), import_zod11.z.null()])
 );
-var MetricsQueryResultSchema = import_zod10.z.object({
-  data: import_zod10.z.array(MetricsQueryResultRowSchema),
-  meta: import_zod10.z.object({
+var MetricsQueryResultSchema = import_zod11.z.object({
+  data: import_zod11.z.array(MetricsQueryResultRowSchema),
+  meta: import_zod11.z.object({
     resource: MetricsResourceSchema,
     environment: EnvironmentSchema,
-    rowCount: import_zod10.z.number().int().describe("Number of rows in `data`."),
-    truncated: import_zod10.z.boolean().describe(
+    rowCount: import_zod11.z.number().int().describe("Number of rows in `data`."),
+    truncated: import_zod11.z.boolean().describe(
       "`true` if more rows matched than `limit` allowed \u2014 `data` holds only the first `limit`."
     )
   })
 });
 
 // src/webhook-events.ts
-var import_zod11 = require("zod");
-var ChargeWebhookEventTypeSchema = import_zod11.z.enum([
+var import_zod12 = require("zod");
+var ChargeWebhookEventTypeSchema = import_zod12.z.enum([
   "charge.created",
   "charge.partially_paid",
   "charge.confirmed",
@@ -756,14 +803,14 @@ var ChargeWebhookEventTypeSchema = import_zod11.z.enum([
 ]).describe(
   'Note the distinction between `charge.confirmed` and `charge.settled`: `confirmed` means the payment was detected on-chain; `settled` means the merchant\'s wallet actually received the funds \u2014 a separate, later step. Subscribe to `confirmed` if you only need "will I get paid," or `settled` if you need "has the money actually arrived." `charge.overpaid` fires alongside `charge.confirmed`/`charge.partially_paid` whenever the cumulative amount received ends up above `amount` (see `Charge.isOverpaid`). Every event in this category carries the full `Charge` object as `data`.'
 );
-var WebhookDeliveryEventTypeSchema = import_zod11.z.enum(["webhook.delivery_failed", "webhook.delivery_recovered", "webhook.endpoint_unhealthy"]).describe(
+var WebhookDeliveryEventTypeSchema = import_zod12.z.enum(["webhook.delivery_failed", "webhook.delivery_recovered", "webhook.endpoint_unhealthy"]).describe(
   "Meta-events about the health of your own webhook endpoints \u2014 useful for monitoring without polling `GET /v1/webhooks/{id}/deliveries`. `webhook.endpoint_unhealthy` fires once when a webhook's failure rate over the trailing 24h crosses 20%, and `webhook.delivery_recovered` fires once when a delivery to that webhook next succeeds. `data` for every event in this category: `{ webhookId, url, failureRatio? }` (`failureRatio` only present on `webhook.endpoint_unhealthy`)."
 );
-var WebhookEventTypeSchema = import_zod11.z.union([
+var WebhookEventTypeSchema = import_zod12.z.union([
   ChargeWebhookEventTypeSchema,
   WebhookDeliveryEventTypeSchema
 ]);
-var WebhookCategorySchema = import_zod11.z.enum(["payments", "webhooks"]).describe(
+var WebhookCategorySchema = import_zod12.z.enum(["payments", "webhooks"]).describe(
   "Subscribe to every event in a category via `eventCategories` instead of listing events one by one \u2014 new events added to a category later arrive automatically, no subscription update needed."
 );
 function buildCategoryMap() {
@@ -791,101 +838,101 @@ var TriggerableChargeEventSchema = ChargeWebhookEventTypeSchema.exclude([
 );
 
 // src/webhooks.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var WEBHOOK_EVENTS_WILDCARD = "*";
-var CreateWebhookSchema = import_zod12.z.object({
-  url: import_zod12.z.string().max(2048).url().describe(
+var CreateWebhookSchema = import_zod13.z.object({
+  url: import_zod13.z.string().max(2048).url().describe(
     "Must be HTTPS and resolve to a public address \u2014 private/internal IPs are rejected."
   ),
-  events: import_zod12.z.array(import_zod12.z.union([WebhookEventTypeSchema, import_zod12.z.literal(WEBHOOK_EVENTS_WILDCARD)])).max(Object.keys(EVENT_CATEGORY_MAP).length + 1).default([]).describe(
+  events: import_zod13.z.array(import_zod13.z.union([WebhookEventTypeSchema, import_zod13.z.literal(WEBHOOK_EVENTS_WILDCARD)])).max(Object.keys(EVENT_CATEGORY_MAP).length + 1).default([]).describe(
     'Individual event types to receive, or `"*"` for every event (combine with `excludeEvents` to opt back out of specific ones). Omit in favor of `eventCategories` if you want whole categories instead.'
   ),
-  eventCategories: import_zod12.z.array(WebhookCategorySchema).max(WebhookCategorySchema.options.length).default([]).describe(
+  eventCategories: import_zod13.z.array(WebhookCategorySchema).max(WebhookCategorySchema.options.length).default([]).describe(
     "Subscribe to every event in these categories. At least one of `events` or `eventCategories` is required."
   ),
-  excludeEvents: import_zod12.z.array(WebhookEventTypeSchema).max(Object.keys(EVENT_CATEGORY_MAP).length).default([]).describe(
+  excludeEvents: import_zod13.z.array(WebhookEventTypeSchema).max(Object.keys(EVENT_CATEGORY_MAP).length).default([]).describe(
     'Event types to exclude even if selected via `events: ["*"]` or `eventCategories`.'
   )
 }).refine((v) => v.events.length > 0 || v.eventCategories.length > 0, {
   message: "must select at least one event via `events` or `eventCategories`",
   path: ["events"]
 });
-var WebhookSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
+var WebhookSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
   environment: EnvironmentSchema.nullable().describe(
     "Which environment's API key created this webhook \u2014 `live` or `test`. Every event is only ever delivered to a webhook whose `environment` matches the event's own (or to a webhook with `environment: null`, which receives every environment \u2014 the case for every webhook created before this field existed)."
   ),
-  url: import_zod12.z.string(),
-  events: import_zod12.z.array(WebhookEventTypeSchema),
-  eventCategories: import_zod12.z.array(WebhookCategorySchema),
-  excludeEvents: import_zod12.z.array(WebhookEventTypeSchema),
-  isWildcard: import_zod12.z.boolean(),
-  secret: import_zod12.z.string().describe(
+  url: import_zod13.z.string(),
+  events: import_zod13.z.array(WebhookEventTypeSchema),
+  eventCategories: import_zod13.z.array(WebhookCategorySchema),
+  excludeEvents: import_zod13.z.array(WebhookEventTypeSchema),
+  isWildcard: import_zod13.z.boolean(),
+  secret: import_zod13.z.string().describe(
     "The signing secret, used to verify the `X-Klappay-Signature` header on every delivery. Returned in full only this once \u2014 store it now, it is not recoverable afterward. Header format: `t=<unix-seconds>,v1=<hex-encoded HMAC-SHA256>`. Compute the expected signature as `HMAC-SHA256(secret, \"${t}.${raw request body}\")` (hex-encoded) and compare it to `v1` using a constant-time comparison; as a replay-protection measure, also reject if `t` is too far from the current time \u2014 Klappay does not enforce or check any particular tolerance server-side, so the exact threshold is entirely the receiver's own policy call. An official SDK's `constructEvent()`/`verifySignature()` do this for you, defaulting to a 300-second tolerance, overridable via `constructEvent`'s `toleranceSeconds` option \u2014 see github.com/klappay for available SDKs."
   ),
-  createdAt: import_zod12.z.string().datetime()
+  createdAt: import_zod13.z.string().datetime()
 });
 var WebhookListItemSchema = WebhookSchema.omit({ secret: true }).extend({
-  hint: import_zod12.z.string().describe("A truncated, safe-to-display form of the secret (e.g. `whsec_...ab12`).")
+  hint: import_zod13.z.string().describe("A truncated, safe-to-display form of the secret (e.g. `whsec_...ab12`).")
 });
-var WebhookPayloadSchema = import_zod12.z.object({
-  id: import_zod12.z.string().describe(
+var WebhookPayloadSchema = import_zod13.z.object({
+  id: import_zod13.z.string().describe(
     "Unique id for this specific delivery \u2014 also sent as the `X-Klappay-Delivery` header."
   ),
   event: WebhookEventTypeSchema,
-  createdAt: import_zod12.z.string().datetime(),
-  data: import_zod12.z.unknown().describe(
+  createdAt: import_zod13.z.string().datetime(),
+  data: import_zod13.z.unknown().describe(
     "Event-specific data. Charge events (`charge.*`) carry the full `Charge` object; webhook-delivery events carry a smaller, event-specific object \u2014 see `WebhookEventDataMap`/`TypedWebhookPayload` for the exact shape per event, or docs/webhooks.md."
   )
 });
-var WebhookDeliveryStatusSchema = import_zod12.z.enum(["pending", "delivered", "failed"]);
-var WebhookDeliverySchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  webhookId: import_zod12.z.string(),
+var WebhookDeliveryStatusSchema = import_zod13.z.enum(["pending", "delivered", "failed"]);
+var WebhookDeliverySchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  webhookId: import_zod13.z.string(),
   event: WebhookEventTypeSchema,
   status: WebhookDeliveryStatusSchema.describe(
     "`pending`: still retrying. `delivered`: got a 2xx response. `failed`: retries exhausted (5 attempts over ~24h) \u2014 use `POST /v1/webhooks/{id}/deliveries/{deliveryId}/retry` to try again manually."
   ),
-  attempts: import_zod12.z.number(),
-  responseCode: import_zod12.z.number().nullable().describe(
+  attempts: import_zod13.z.number(),
+  responseCode: import_zod13.z.number().nullable().describe(
     "HTTP status your endpoint returned on the most recent attempt. `null` if every attempt failed to connect at all."
   ),
-  nextRetryAt: import_zod12.z.string().datetime().nullable(),
-  deliveredAt: import_zod12.z.string().datetime().nullable(),
-  createdAt: import_zod12.z.string().datetime()
+  nextRetryAt: import_zod13.z.string().datetime().nullable(),
+  deliveredAt: import_zod13.z.string().datetime().nullable(),
+  createdAt: import_zod13.z.string().datetime()
 });
 var ListWebhookDeliveriesSchema = PaginationQuerySchema;
 var PaginatedWebhookDeliveriesSchema = paginatedSchema(WebhookDeliverySchema);
 
 // src/recipients.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var EVM_ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
-var CreateRecipientSchema = import_zod13.z.object({
-  address: import_zod13.z.string().regex(EVM_ADDRESS_REGEX, "must be a 20-byte hex address").describe("EVM address to register as a trusted split recipient for your organization."),
-  label: import_zod13.z.string().min(1).max(64).optional().describe('Free-form label for your own bookkeeping (e.g. `"supplier"`) \u2014 never interpreted.')
+var CreateRecipientSchema = import_zod14.z.object({
+  address: import_zod14.z.string().regex(EVM_ADDRESS_REGEX, "must be a 20-byte hex address").describe("EVM address to register as a trusted split recipient for your organization."),
+  label: import_zod14.z.string().min(1).max(64).optional().describe('Free-form label for your own bookkeeping (e.g. `"supplier"`) \u2014 never interpreted.')
 });
-var RecipientSchema = import_zod13.z.object({
-  id: import_zod13.z.string().describe(
+var RecipientSchema = import_zod14.z.object({
+  id: import_zod14.z.string().describe(
     "Klappay-generated id, e.g. `rc_...` \u2014 this, not the raw address, is what a charge's `splitRecipients[].recipientId` references."
   ),
   environment: EnvironmentSchema,
-  address: import_zod13.z.string(),
-  label: import_zod13.z.string().nullable(),
-  payout: import_zod13.z.boolean().describe(
+  address: import_zod14.z.string(),
+  label: import_zod14.z.string().nullable(),
+  payout: import_zod14.z.boolean().describe(
     "Whether this recipient is eligible to be used as an API key's `payoutAddress` (in addition to being referenceable in a split, which every non-revoked recipient already is). Set via `PATCH /v1/recipients/{id}` \u2014 requires the `recipients:manage_payout` scope, deliberately separate from `recipients:write`."
   ),
-  createdAt: import_zod13.z.string().datetime()
+  createdAt: import_zod14.z.string().datetime()
 });
-var SetRecipientPayoutSchema = import_zod13.z.object({
-  payout: import_zod13.z.boolean().describe("New payout-eligibility value for this recipient.")
+var SetRecipientPayoutSchema = import_zod14.z.object({
+  payout: import_zod14.z.boolean().describe("New payout-eligibility value for this recipient.")
 });
 
 // src/timeline.ts
-var import_zod14 = require("zod");
-var TransactionSourceSchema = import_zod14.z.enum(["moralis_webhook", "reconciliation_job", "sandbox"]).describe(
+var import_zod15 = require("zod");
+var TransactionSourceSchema = import_zod15.z.enum(["moralis_webhook", "reconciliation_job", "sandbox"]).describe(
   "How this transfer was detected: `moralis_webhook` (the normal path), `reconciliation_job` (a fallback poller caught it after the webhook was missed or delayed), or `sandbox` (simulated via `POST /v1/sandbox/charges/{id}/trigger`, no real on-chain transfer)."
 );
-var TimelineEventTypeSchema = import_zod14.z.enum([
+var TimelineEventTypeSchema = import_zod15.z.enum([
   "charge.created",
   "charge.expired",
   "transaction.detected",
@@ -896,11 +943,11 @@ var TimelineEventTypeSchema = import_zod14.z.enum([
 ]).describe(
   "`charge.created`: the charge was created. `charge.expired`: `expiresAt` passed with no full payment. `transaction.detected`: a raw on-chain transfer was seen (see the `event`-shaped fields below for details \u2014 a charge can have more than one, e.g. a partial payment followed by the rest). `split.distributed`: a payout to the merchant completed on-chain, for one contributing `(token, network)` pair \u2014 a charge settled across more than one pair emits one of these per pair (see the `token`/`network` fields below). `webhook.dispatched`/`webhook.delivered`/`webhook.failed`: one specific delivery *attempt* for one webhook subscription \u2014 `failed` here means this single attempt failed, not that all retries were exhausted (see `WebhookDeliveryStatusSchema` for the exhausted-all-retries state)."
 );
-var TimelineEventSchema = import_zod14.z.object({
+var TimelineEventSchema = import_zod15.z.object({
   type: TimelineEventTypeSchema,
-  at: import_zod14.z.string().datetime(),
-  txHash: import_zod14.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
-  amount: import_zod14.z.number().optional().describe(
+  at: import_zod15.z.string().datetime(),
+  txHash: import_zod15.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
+  amount: import_zod15.z.number().optional().describe(
     "Present for `transaction.detected` events only \u2014 the amount that specific transfer carried."
   ),
   source: TransactionSourceSchema.optional().describe(
@@ -912,56 +959,112 @@ var TimelineEventSchema = import_zod14.z.object({
   network: NetworkSchema.optional().describe(
     "Present for `transaction.detected` and `split.distributed` events \u2014 which network this specific transfer, or settlement, used."
   ),
-  causedTransition: import_zod14.z.boolean().optional().describe(
+  causedTransition: import_zod15.z.boolean().optional().describe(
     "Present for `transaction.detected` events only. `true` if this specific transfer changed the charge's status (e.g. PENDING\u2192CONFIRMED) \u2014 a charge paid in installments can have more than one such event."
   ),
   event: WebhookEventTypeSchema.optional().describe(
     "Present for `webhook.*` events only \u2014 which event type this delivery was for."
   ),
-  responseCode: import_zod14.z.number().nullable().optional().describe(
+  responseCode: import_zod15.z.number().nullable().optional().describe(
     "Present for `webhook.*` events only \u2014 HTTP status your endpoint returned, or `null` if the request never connected."
   ),
-  attempts: import_zod14.z.number().optional().describe(
+  attempts: import_zod15.z.number().optional().describe(
     "Present for `webhook.*` events only \u2014 how many delivery attempts have been made so far."
   )
 });
 
 // src/health.ts
-var import_zod15 = require("zod");
-var HealthSchema = import_zod15.z.object({
-  status: import_zod15.z.enum(["ok", "error"]).describe(
+var import_zod16 = require("zod");
+var HealthSchema = import_zod16.z.object({
+  status: import_zod16.z.enum(["ok", "error"]).describe(
     "`error` when the database connectivity check fails \u2014 the HTTP status code mirrors this (503 instead of 200), so a plain uptime check (not just a JSON-aware one) still catches a DB outage."
   ),
-  version: import_zod15.z.string(),
-  timestamp: import_zod15.z.string().datetime(),
-  db: import_zod15.z.enum(["ok", "error"]).describe("Result of a real database connectivity check, not just a process-alive check."),
-  pendingWebhooks: import_zod15.z.number().describe("Count of webhook deliveries still awaiting a successful attempt."),
-  oldestPendingChargeAgeSeconds: import_zod15.z.number().nullable().describe("Age of the oldest still-unpaid charge, in seconds. `null` if there are none."),
-  lastMoralisEventAgeSeconds: import_zod15.z.number().nullable().describe(
+  version: import_zod16.z.string(),
+  timestamp: import_zod16.z.string().datetime(),
+  db: import_zod16.z.enum(["ok", "error"]).describe("Result of a real database connectivity check, not just a process-alive check."),
+  pendingWebhooks: import_zod16.z.number().describe("Count of webhook deliveries still awaiting a successful attempt."),
+  oldestPendingChargeAgeSeconds: import_zod16.z.number().nullable().describe("Age of the oldest still-unpaid charge, in seconds. `null` if there are none."),
+  lastMoralisEventAgeSeconds: import_zod16.z.number().nullable().describe(
     "Seconds since the last on-chain payment notification was received \u2014 a cheap signal for whether payment detection is currently working. `null` if none have ever been received."
   )
 });
 
 // src/sandbox.ts
-var import_zod16 = require("zod");
-var SandboxTriggerSchema = import_zod16.z.object({
+var import_zod17 = require("zod");
+var SandboxTriggerSchema = import_zod17.z.object({
   event: TriggerableChargeEventSchema,
-  amount: import_zod16.z.number().positive().max(CHARGE_AMOUNT_MAX).optional().describe(
+  amount: import_zod17.z.number().positive().max(CHARGE_AMOUNT_MAX).optional().describe(
     "Used with `charge.partially_paid` (amount to simulate as received so far \u2014 must be less than the charge amount, defaults to half of it if omitted) and with `charge.overpaid` (amount received \u2014 must be greater than the charge amount, defaults to 1.5x it if omitted). Ignored for every other event."
   )
 });
 
 // src/capabilities.ts
-var import_zod17 = require("zod");
-var CapabilitiesSchema = import_zod17.z.object({
-  acceptedPayments: import_zod17.z.array(AcceptedPaymentSchema).describe(
+var import_zod18 = require("zod");
+var CapabilitiesSchema = import_zod18.z.object({
+  acceptedPayments: import_zod18.z.array(AcceptedPaymentSchema).describe(
     "Every `(token, network)` pair actually configured for your environment right now \u2014 read straight from the same lookup `POST /v1/charges` validates `acceptedPayments` against, so it can never list a pair that charge creation would then reject. Use this to build a picker UI instead of hardcoding the matrix client-side."
   )
 });
+
+// src/swap.ts
+var import_zod19 = require("zod");
+var CreateSwapQuoteSchema = import_zod19.z.object({
+  inputToken: AltTokenSchema.describe(
+    "Which alt-cryptocurrency the payer wants to send \u2014 must be one of this charge's `swapAlternatives`, or `422 token_not_supported`."
+  ),
+  inputNetwork: NetworkSchema.describe(
+    "Which network the payer will send `inputToken` on. Also picks which of this charge's `acceptedPayments` pairs the swap resolves to \u2014 a charge accepting USDC on both Base and Optimism resolves to whichever `inputNetwork` you pass. If the charge accepts more than one token on that same network, Klappay breaks the tie using its own trust ranking for that network (e.g. USDT over USDC on BNB Chain, where \"USDC\" is a third-party Binance-Peg token, not Circle's) \u2014 never a token the charge doesn't actually accept."
+  ),
+  takerAddress: import_zod19.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a 20-byte hex address").describe(
+    "The payer's own wallet address \u2014 the account that will sign and submit the swap transaction. Not validated against anything else; any well-formed address is accepted, since Klappay never custodies these funds."
+  )
+});
+var SwapQuoteSchema = import_zod19.z.object({
+  inputToken: AltTokenSchema,
+  inputNetwork: NetworkSchema,
+  inputAmount: import_zod19.z.number().describe(
+    "The ceiling of `inputToken` the payer needs available to sign for, in whole units (not wei/base units) \u2014 not necessarily the exact final cost. Any `inputToken` beyond what the swap actually needs (price moved favorably, less slippage than budgeted) is swapped back and refunded to the payer automatically, in the same transaction \u2014 never a separate step or a Klappay-side refund."
+  ),
+  outputToken: TokenSchema.describe(
+    "Which of this charge's `acceptedPayments` tokens the swap resolves to."
+  ),
+  outputNetwork: NetworkSchema,
+  outputAmount: import_zod19.z.number().describe(
+    "The exact remaining amount owed on this charge (`amount - amountReceived`), in `currency` units \u2014 always what the merchant's split address receives, regardless of `inputAmount`."
+  ),
+  fees: import_zod19.z.object({
+    klappayFee: import_zod19.z.number().describe(
+      "Klappay's own swap fee (1% today), in `outputToken` units \u2014 paid by the payer, on top of `inputAmount`, separate from the merchant's own `feePercent`. Never subtracted from `outputAmount`."
+    ),
+    zeroExFee: import_zod19.z.number().nullable().describe(
+      "0x's own protocol fee for this specific token pair, in `outputToken` units, or `null` when this pair isn't currently one 0x charges on. Also paid by the payer on top of `inputAmount`, also never subtracted from `outputAmount` \u2014 Klappay never sees this fee, it goes straight to 0x."
+    )
+  }).describe(
+    "Every fee the payer is charged for using swap-to-pay, broken out by who collects it \u2014 both already reflected in `inputAmount`, shown here separately for transparency. Neither ever reduces `outputAmount`."
+  ),
+  expiresAt: import_zod19.z.string().datetime().describe(
+    "When this quote's price is no longer safely valid \u2014 a rough guide for the payer's UI countdown only. The actual price guarantee is enforced on-chain by the swap transaction itself (a signed Permit2 deadline, or a minimum-output check for a native-currency sell), not by this timestamp \u2014 submitting after it expires either reverts on-chain or simply gets re-quoted at the current price, never silently executes at a stale rate."
+  ),
+  transaction: import_zod19.z.object({
+    to: import_zod19.z.string().describe("Contract address the payer's wallet must send this transaction to."),
+    data: import_zod19.z.string().describe("Calldata \u2014 opaque, must be sent unmodified."),
+    value: import_zod19.z.string().describe(
+      "Native currency (ETH/BNB/MATIC/AVAX) to attach, in wei \u2014 `\"0\"` when `inputToken` isn't this network's native currency."
+    )
+  }).describe(
+    "Pass this directly to the payer's wallet (e.g. viem/ethers `sendTransaction`) \u2014 Klappay never touches the payer's private key or submits anything on their behalf. If `permit2` is present on this response, sign that first and append the signature to this `data` before sending; if `permit2` is absent, send `transaction` as-is with no extra step."
+  ),
+  permit2: import_zod19.z.object({ eip712: import_zod19.z.record(import_zod19.z.unknown()) }).optional().describe(
+    "Present only when `inputToken` is an ERC-20 (today, only `BTC`) \u2014 the payer's wallet must sign this EIP-712 message and append the signature to `transaction.data` before sending, since an ERC-20 sell needs a Permit2 allowance signature that a native-currency sell doesn't. Absent when `inputToken` is a network's own native currency (ETH/BNB/MATIC/AVAX) \u2014 `transaction` is then ready to sign and send directly, no extra step."
+  )
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALT_TOKEN_ADDRESSES,
+  ALT_TOKEN_DECIMALS,
   API_KEY_SCOPES,
   AcceptedPaymentSchema,
+  AltTokenSchema,
   ApiKeyScopeSchema,
   CHARGE_ACCEPTED_PAYMENTS_MAX,
   CHARGE_AMOUNT_MAX,
@@ -980,6 +1083,7 @@ var CapabilitiesSchema = import_zod17.z.object({
   CheckoutProductSchema,
   CreateChargeSchema,
   CreateRecipientSchema,
+  CreateSwapQuoteSchema,
   CreateWebhookSchema,
   DistributionsDateFieldSchema,
   DistributionsMetricFieldSchema,
@@ -1029,6 +1133,8 @@ var CapabilitiesSchema = import_zod17.z.object({
   SplitDistributionStatusSchema,
   SplitRecipientInputSchema,
   SplitRecipientSchema,
+  SwapAlternativeSchema,
+  SwapQuoteSchema,
   TOKEN_ADDRESSES,
   TOKEN_DECIMALS,
   TimelineEventSchema,
@@ -1050,6 +1156,7 @@ var CapabilitiesSchema = import_zod17.z.object({
   WebhookPayloadSchema,
   WebhookSchema,
   findConflictingScopes,
+  listSwapAlternatives,
   paginatedSchema
 });
 //# sourceMappingURL=index.js.map