@klappay/types 1.0.9 → 1.1.0

package/dist/index.js

@@ -35,7 +35,6 @@ __export(index_exports, {
   ChangePasswordSchema: () => ChangePasswordSchema,
   ChargeModeSchema: () => ChargeModeSchema,
   ChargeSchema: () => ChargeSchema,
-  ChargeStatusEventSchema: () => ChargeStatusEventSchema,
   ChargeStatusSchema: () => ChargeStatusSchema,
   ChargeWebhookEventTypeSchema: () => ChargeWebhookEventTypeSchema,
   ChargesDateFieldSchema: () => ChargesDateFieldSchema,
@@ -54,6 +53,7 @@ __export(index_exports, {
   ErrorPayloadSchema: () => ErrorPayloadSchema,
   ForgotPasswordSchema: () => ForgotPasswordSchema,
   GetChargeQrCodeQuerySchema: () => GetChargeQrCodeQuerySchema,
+  GetPublicChargeQuerySchema: () => GetPublicChargeQuerySchema,
   HealthSchema: () => HealthSchema,
   InvitationSchema: () => InvitationSchema,
   InviteUserSchema: () => InviteUserSchema,
@@ -62,6 +62,7 @@ __export(index_exports, {
   ListOrganizationsSchema: () => ListOrganizationsSchema,
   ListUsersSchema: () => ListUsersSchema,
   ListWebhookDeliveriesSchema: () => ListWebhookDeliveriesSchema,
+  ListenPendingDistributionsQuerySchema: () => ListenPendingDistributionsQuerySchema,
   LoginSchema: () => LoginSchema,
   MAX_METRICS_QUERY_DATE_RANGE_DAYS: () => MAX_METRICS_QUERY_DATE_RANGE_DAYS,
   METRICS_QUERY_DEFAULT_ROW_LIMIT: () => METRICS_QUERY_DEFAULT_ROW_LIMIT,
@@ -92,12 +93,14 @@ __export(index_exports, {
   PaginatedApiKeysSchema: () => PaginatedApiKeysSchema,
   PaginatedChargesSchema: () => PaginatedChargesSchema,
   PaginatedOrganizationsSchema: () => PaginatedOrganizationsSchema,
+  PaginatedPendingDistributionsSchema: () => PaginatedPendingDistributionsSchema,
   PaginatedUsersSchema: () => PaginatedUsersSchema,
   PaginatedWebhookDeliveriesSchema: () => PaginatedWebhookDeliveriesSchema,
   PaginationQuerySchema: () => PaginationQuerySchema,
   PendingDistributionEventSchema: () => PendingDistributionEventSchema,
   PendingDistributionRecipientSchema: () => PendingDistributionRecipientSchema,
   PendingDistributionSchema: () => PendingDistributionSchema,
+  PublicChargeSchema: () => PublicChargeSchema,
   ResetPasswordSchema: () => ResetPasswordSchema,
   SandboxEventTriggerSchema: () => SandboxEventTriggerSchema,
   SandboxTriggerSchema: () => SandboxTriggerSchema,
@@ -106,7 +109,6 @@ __export(index_exports, {
   SettlementStatusSchema: () => SettlementStatusSchema,
   SignupSchema: () => SignupSchema,
   SplitDistributionStatusSchema: () => SplitDistributionStatusSchema,
-  SplitRecipientRoleSchema: () => SplitRecipientRoleSchema,
   TOKEN_ADDRESSES: () => TOKEN_ADDRESSES,
   TOKEN_DECIMALS: () => TOKEN_DECIMALS,
   TimelineEventSchema: () => TimelineEventSchema,
@@ -121,10 +123,7 @@ __export(index_exports, {
   UpdateUserRoleSchema: () => UpdateUserRoleSchema,
   UserRoleSchema: () => UserRoleSchema,
   UserSchema: () => UserSchema,
-  VerifyChargeSchema: () => VerifyChargeSchema,
   VerifyEmailSchema: () => VerifyEmailSchema,
-  VerifyPaymentSchema: () => VerifyPaymentSchema,
-  VerifySplitEntrySchema: () => VerifySplitEntrySchema,
   WEBHOOK_EVENTS_WILDCARD: () => WEBHOOK_EVENTS_WILDCARD,
   WEBHOOK_EVENT_CATEGORIES: () => WEBHOOK_EVENT_CATEGORIES,
   WebhookCategorySchema: () => WebhookCategorySchema,
@@ -258,8 +257,8 @@ var TOKEN_ADDRESSES = {
 
 // src/charges.ts
 var import_zod6 = require("zod");
-var ChargeStatusSchema = import_zod6.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`. This never reflects whether funds actually reached the merchant \u2014 see `settlementStatus` for that."
+var ChargeStatusSchema = import_zod6.z.enum(["pending", "partially_paid", "confirmed", "expired", "underpaid", "canceled"]).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`. `canceled`: the merchant explicitly canceled it via `POST /v1/charges/{id}/cancel` before it resolved on its own \u2014 unlike every other terminal status, this one is never reached automatically. This never reflects whether funds actually reached the merchant \u2014 see `settlementStatus` for that."
 );
 var SettlementStatusSchema = import_zod6.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."
@@ -374,6 +373,9 @@ var ChargeSchema = import_zod6.z.object({
   ),
   pausedAt: import_zod6.z.string().datetime().nullable().describe(
     "Only ever set for a charge with no `expiresAt`: `null` means Klappay is actively watching this address in real time (the normal case). A timestamp means no contribution arrived for longer than the inactivity window (90 days for a charge with a goal `amount`, 365 days for one without), so real-time watching was stopped \u2014 the charge itself is never closed, a transfer can still arrive and land, just detected on a much slower fallback poll instead of instantly. Clears automatically (and real-time watching resumes) the moment that happens."
+  ),
+  canceledAt: import_zod6.z.string().datetime().nullable().describe(
+    "When `POST /v1/charges/{id}/cancel` was called. `null` unless `status` is `canceled`. Unlike `pausedAt`, this never clears automatically \u2014 real-time watching is stopped the same way, but a transfer landing afterward doesn't revert the charge to `pending`; it fires `charge.paid_after_cancel` instead, since resuming silently would contradict the merchant's explicit cancellation."
   )
 });
 var ListChargesSchema = import_zod6.z.object({
@@ -397,65 +399,96 @@ var GetChargeQrCodeQuerySchema = import_zod6.z.object({
   ),
   network: NetworkSchema.optional()
 });
-var ChargeStatusEventSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
+
+// src/public-charges.ts
+var import_zod7 = require("zod");
+var PublicChargeSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  mode: ChargeModeSchema,
   status: ChargeStatusSchema,
   settlementStatus: SettlementStatusSchema.nullable(),
-  amount: import_zod6.z.number().nullable(),
-  amountReceived: import_zod6.z.number().nullable(),
-  paidWith: import_zod6.z.array(AcceptedPaymentSchema)
+  amount: import_zod7.z.number().nullable(),
+  amountReceived: import_zod7.z.number().nullable(),
+  isOverpaid: import_zod7.z.boolean(),
+  currency: import_zod7.z.string(),
+  acceptedPayments: import_zod7.z.array(AcceptedPaymentSchema),
+  paidWith: import_zod7.z.array(AcceptedPaymentSchema),
+  address: import_zod7.z.string(),
+  environment: EnvironmentSchema,
+  txHash: import_zod7.z.string().nullable(),
+  metadata: import_zod7.z.record(import_zod7.z.unknown()).nullable().describe(
+    "Redacted \u2014 everything the merchant put in `Charge.metadata` is stripped except the reserved `klappay` key (for Klappay-internal product integrations, e.g. this endpoint's own checkout consumer), if present. `null` if there's no `klappay` key, even when the merchant's own metadata is otherwise non-empty."
+  ),
+  createdAt: import_zod7.z.string().datetime(),
+  expiresAt: import_zod7.z.string().datetime().nullable(),
+  confirmedAt: import_zod7.z.string().datetime().nullable(),
+  settledAt: import_zod7.z.string().datetime().nullable(),
+  lastActivityAt: import_zod7.z.string().datetime(),
+  pausedAt: import_zod7.z.string().datetime().nullable(),
+  canceledAt: import_zod7.z.string().datetime().nullable()
+});
+var GetPublicChargeQuerySchema = import_zod7.z.object({
+  environment: EnvironmentSchema.describe(
+    "Which environment this charge is expected to be in. Required, not inferred \u2014 there's no API key here to derive it from, and stating it explicitly catches an integration bug (e.g. a `test` chargeId reaching a `live` checkout flow) instead of silently trusting whatever environment the id happens to belong to. A mismatch is indistinguishable from the charge not existing at all (`404`), same anti-enumeration posture as every other case below."
+  )
 });
 
 // src/distributions.ts
-var import_zod7 = require("zod");
-var SplitDistributionStatusSchema = import_zod7.z.enum(["pending", "processing", "completed", "failed"]).describe(
+var import_zod8 = require("zod");
+var SplitDistributionStatusSchema = import_zod8.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_zod7.z.object({
-  address: import_zod7.z.string().describe("On-chain recipient address."),
-  percentAllocation: import_zod7.z.number().describe("This recipient's share of the split, as a percentage (e.g. `99.0991` = 99.0991%).")
+var PendingDistributionRecipientSchema = import_zod8.z.object({
+  address: import_zod8.z.string().describe("On-chain recipient address."),
+  percentAllocation: import_zod8.z.number().describe("This recipient's share of the split, as a percentage (e.g. `99.0991` = 99.0991%).")
 });
-var PendingDistributionSchema = import_zod7.z.object({
-  splitAddress: import_zod7.z.string().describe("The on-chain 0xSplits address to call `distribute()` on."),
+var PendingDistributionSchema = import_zod8.z.object({
+  splitAddress: import_zod8.z.string().describe("The on-chain 0xSplits address to call `distribute()` on."),
   network: NetworkSchema,
   token: TokenSchema,
-  recipients: import_zod7.z.array(PendingDistributionRecipientSchema).describe(
+  recipients: import_zod8.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_zod7.z.number().describe(
+  distributorFeePercent: import_zod8.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_zod7.z.number().describe(
+  estimatedRewardAmount: import_zod8.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_zod7.z.string().datetime().describe("When this distribution entered its grace period."),
-  graceEndsAt: import_zod7.z.string().datetime().describe(
+  availableSince: import_zod8.z.string().datetime().describe("When this distribution entered its grace period."),
+  graceEndsAt: import_zod8.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 PendingDistributionEventSchema = import_zod7.z.discriminatedUnion("type", [
-  import_zod7.z.object({
-    type: import_zod7.z.literal("distribution.available"),
+var PaginatedPendingDistributionsSchema = paginatedSchema(PendingDistributionSchema);
+var ListenPendingDistributionsQuerySchema = import_zod8.z.object({
+  limit: import_zod8.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_zod8.z.discriminatedUnion("type", [
+  import_zod8.z.object({
+    type: import_zod8.z.literal("distribution.available"),
     distribution: PendingDistributionSchema
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("distribution.claimed"),
-    splitAddress: import_zod7.z.string().describe("No longer claimable \u2014 either settled by someone, or picked up by the worker.")
+  import_zod8.z.object({
+    type: import_zod8.z.literal("distribution.claimed"),
+    splitAddress: import_zod8.z.string().describe("No longer claimable \u2014 either settled by someone, or picked up by the worker.")
   })
 ]);
 
 // src/metrics.ts
-var import_zod8 = require("zod");
-var MetricsResourceSchema = import_zod8.z.enum(["charges", "transactions", "distributions"]).describe(
+var import_zod9 = require("zod");
+var MetricsResourceSchema = import_zod9.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_zod8.z.enum(["count", "sum", "avg", "min", "max"]).describe(
+var MetricsAggregationSchema = import_zod9.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_zod8.z.enum(["eq", "neq", "in", "gt", "gte", "lt", "lte"]).describe(
+var MetricsFilterOperatorSchema = import_zod9.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_zod8.z.enum(["day", "week", "month"]).describe(
+var MetricsDateGranularitySchema = import_zod9.z.enum(["day", "week", "month"]).describe(
   "Bucket width for a `date_bucket` `groupBy` entry \u2014 Postgres `date_trunc` semantics (UTC)."
 );
 var metricsQueryEnvironmentSchema = EnvironmentSchema.describe(
@@ -468,151 +501,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_zod8.z.string().min(1).max(64).regex(
+var metricAliasSchema = import_zod9.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_zod8.z.union([
-  import_zod8.z.string().max(255),
-  import_zod8.z.number(),
-  import_zod8.z.boolean(),
-  import_zod8.z.array(import_zod8.z.union([import_zod8.z.string().max(255), import_zod8.z.number()])).min(1).max(50)
+var MetricsFilterValueSchema = import_zod9.z.union([
+  import_zod9.z.string().max(255),
+  import_zod9.z.number(),
+  import_zod9.z.boolean(),
+  import_zod9.z.array(import_zod9.z.union([import_zod9.z.string().max(255), import_zod9.z.number()])).min(1).max(50)
 ]);
-var orderBySchema = import_zod8.z.object({
-  key: import_zod8.z.string().min(1).max(64).regex(
+var orderBySchema = import_zod9.z.object({
+  key: import_zod9.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_zod8.z.enum(["asc", "desc"])
+  direction: import_zod9.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_zod8.z.number().int().min(1).max(METRICS_QUERY_MAX_ROW_LIMIT).default(METRICS_QUERY_DEFAULT_ROW_LIMIT).describe(
+var limitSchema = import_zod9.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_zod8.z.enum(["status", "mode", "source", "apiKeyId", "currency", "isOverpaid", "externalRef"]).describe(
+var ChargesQueryFieldSchema = import_zod9.z.enum(["status", "mode", "source", "apiKeyId", "currency", "isOverpaid", "externalRef"]).describe(
   "A `Charge` field to filter or group by \u2014 see `ChargeStatusSchema`/`ChargeModeSchema` for `status`/`mode`'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_zod8.z.enum(["amount", "amountReceived", "feePercent"]).describe(
+var ChargesMetricFieldSchema = import_zod9.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_zod8.z.enum(["createdAt", "confirmedAt", "lastActivityAt"]).describe(
+var ChargesDateFieldSchema = import_zod9.z.enum(["createdAt", "confirmedAt", "lastActivityAt"]).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."
 );
-var ChargesFilterSchema = import_zod8.z.object({
+var ChargesFilterSchema = import_zod9.z.object({
   field: ChargesQueryFieldSchema,
   operator: MetricsFilterOperatorSchema,
   value: MetricsFilterValueSchema
 });
-var ChargesGroupBySchema = import_zod8.z.union([
-  import_zod8.z.object({ type: import_zod8.z.literal("field"), field: ChargesQueryFieldSchema }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("date_bucket"),
+var ChargesGroupBySchema = import_zod9.z.union([
+  import_zod9.z.object({ type: import_zod9.z.literal("field"), field: ChargesQueryFieldSchema }),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("date_bucket"),
     field: ChargesDateFieldSchema,
     granularity: MetricsDateGranularitySchema
   })
 ]);
-var ChargesMetricSchema = import_zod8.z.object({
+var ChargesMetricSchema = import_zod9.z.object({
   aggregation: MetricsAggregationSchema,
   field: ChargesMetricFieldSchema.optional(),
   alias: metricAliasSchema
 });
-var ChargesMetricsQuerySchema = import_zod8.z.object({
-  resource: import_zod8.z.literal("charges"),
+var ChargesMetricsQuerySchema = import_zod9.z.object({
+  resource: import_zod9.z.literal("charges"),
   environment: metricsQueryEnvironmentSchema,
-  dateRange: import_zod8.z.object({
+  dateRange: import_zod9.z.object({
     field: ChargesDateFieldSchema,
-    from: import_zod8.z.string().max(64).datetime(),
-    to: import_zod8.z.string().max(64).datetime()
+    from: import_zod9.z.string().max(64).datetime(),
+    to: import_zod9.z.string().max(64).datetime()
   }),
-  groupBy: import_zod8.z.array(ChargesGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
-  metrics: import_zod8.z.array(ChargesMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
-  filters: import_zod8.z.array(ChargesFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
+  groupBy: import_zod9.z.array(ChargesGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
+  metrics: import_zod9.z.array(ChargesMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
+  filters: import_zod9.z.array(ChargesFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
   orderBy: orderBySchema.optional(),
   limit: limitSchema
 });
-var TransactionsQueryFieldSchema = import_zod8.z.enum(["network", "token", "source", "causedTransition"]).describe(
+var TransactionsQueryFieldSchema = import_zod9.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_zod8.z.enum(["amount"]).describe("The transfer amount, in the charge's `currency` units.");
-var TransactionsDateFieldSchema = import_zod8.z.enum(["detectedAt"]).describe("When Klappay detected this transfer on-chain (not when it was mined).");
-var TransactionsFilterSchema = import_zod8.z.object({
+var TransactionsMetricFieldSchema = import_zod9.z.enum(["amount"]).describe("The transfer amount, in the charge's `currency` units.");
+var TransactionsDateFieldSchema = import_zod9.z.enum(["detectedAt"]).describe("When Klappay detected this transfer on-chain (not when it was mined).");
+var TransactionsFilterSchema = import_zod9.z.object({
   field: TransactionsQueryFieldSchema,
   operator: MetricsFilterOperatorSchema,
   value: MetricsFilterValueSchema
 });
-var TransactionsGroupBySchema = import_zod8.z.union([
-  import_zod8.z.object({ type: import_zod8.z.literal("field"), field: TransactionsQueryFieldSchema }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("date_bucket"),
+var TransactionsGroupBySchema = import_zod9.z.union([
+  import_zod9.z.object({ type: import_zod9.z.literal("field"), field: TransactionsQueryFieldSchema }),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("date_bucket"),
     field: TransactionsDateFieldSchema,
     granularity: MetricsDateGranularitySchema
   })
 ]);
-var TransactionsMetricSchema = import_zod8.z.object({
+var TransactionsMetricSchema = import_zod9.z.object({
   aggregation: MetricsAggregationSchema,
   field: TransactionsMetricFieldSchema.optional(),
   alias: metricAliasSchema
 });
-var TransactionsMetricsQuerySchema = import_zod8.z.object({
-  resource: import_zod8.z.literal("transactions"),
+var TransactionsMetricsQuerySchema = import_zod9.z.object({
+  resource: import_zod9.z.literal("transactions"),
   environment: metricsQueryEnvironmentSchema,
-  dateRange: import_zod8.z.object({
+  dateRange: import_zod9.z.object({
     field: TransactionsDateFieldSchema,
-    from: import_zod8.z.string().max(64).datetime(),
-    to: import_zod8.z.string().max(64).datetime()
+    from: import_zod9.z.string().max(64).datetime(),
+    to: import_zod9.z.string().max(64).datetime()
   }),
-  groupBy: import_zod8.z.array(TransactionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
-  metrics: import_zod8.z.array(TransactionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
-  filters: import_zod8.z.array(TransactionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
+  groupBy: import_zod9.z.array(TransactionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
+  metrics: import_zod9.z.array(TransactionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
+  filters: import_zod9.z.array(TransactionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
   orderBy: orderBySchema.optional(),
   limit: limitSchema
 });
-var DistributionsQueryFieldSchema = import_zod8.z.enum(["status", "network", "token"]).describe(
+var DistributionsQueryFieldSchema = import_zod9.z.enum(["status", "network", "token"]).describe(
   "A `SplitDistribution` field to filter or group by \u2014 see `SplitDistributionStatusSchema`/`NetworkSchema`/`TokenSchema` for their possible values."
 );
-var DistributionsMetricFieldSchema = import_zod8.z.enum(["attempts"]).describe(
+var DistributionsMetricFieldSchema = import_zod9.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_zod8.z.enum(["createdAt", "completedAt"]).describe(
+var DistributionsDateFieldSchema = import_zod9.z.enum(["createdAt", "completedAt"]).describe(
   "`createdAt`: when this settlement was queued. `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_zod8.z.object({
+var DistributionsFilterSchema = import_zod9.z.object({
   field: DistributionsQueryFieldSchema,
   operator: MetricsFilterOperatorSchema,
   value: MetricsFilterValueSchema
 });
-var DistributionsGroupBySchema = import_zod8.z.union([
-  import_zod8.z.object({ type: import_zod8.z.literal("field"), field: DistributionsQueryFieldSchema }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("date_bucket"),
+var DistributionsGroupBySchema = import_zod9.z.union([
+  import_zod9.z.object({ type: import_zod9.z.literal("field"), field: DistributionsQueryFieldSchema }),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("date_bucket"),
     field: DistributionsDateFieldSchema,
     granularity: MetricsDateGranularitySchema
   })
 ]);
-var DistributionsMetricSchema = import_zod8.z.object({
+var DistributionsMetricSchema = import_zod9.z.object({
   aggregation: MetricsAggregationSchema,
   field: DistributionsMetricFieldSchema.optional(),
   alias: metricAliasSchema
 });
-var DistributionsMetricsQuerySchema = import_zod8.z.object({
-  resource: import_zod8.z.literal("distributions"),
+var DistributionsMetricsQuerySchema = import_zod9.z.object({
+  resource: import_zod9.z.literal("distributions"),
   environment: metricsQueryEnvironmentSchema,
-  dateRange: import_zod8.z.object({
+  dateRange: import_zod9.z.object({
     field: DistributionsDateFieldSchema,
-    from: import_zod8.z.string().max(64).datetime(),
-    to: import_zod8.z.string().max(64).datetime()
+    from: import_zod9.z.string().max(64).datetime(),
+    to: import_zod9.z.string().max(64).datetime()
   }),
-  groupBy: import_zod8.z.array(DistributionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
-  metrics: import_zod8.z.array(DistributionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
-  filters: import_zod8.z.array(DistributionsFilterSchema).max(METRICS_QUERY_MAX_FILTERS).default([]),
+  groupBy: import_zod9.z.array(DistributionsGroupBySchema).max(METRICS_QUERY_MAX_GROUP_BY).default([]),
+  metrics: import_zod9.z.array(DistributionsMetricSchema).min(1).max(METRICS_QUERY_MAX_METRICS),
+  filters: import_zod9.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_zod8.z.discriminatedUnion("resource", [
+var MetricsQuerySchema = import_zod9.z.discriminatedUnion("resource", [
   ChargesMetricsQuerySchema,
   TransactionsMetricsQuerySchema,
   DistributionsMetricsQuerySchema
@@ -621,7 +654,7 @@ var MetricsQuerySchema = import_zod8.z.discriminatedUnion("resource", [
   const to = new Date(input.dateRange.to);
   if (from >= to) {
     ctx.addIssue({
-      code: import_zod8.z.ZodIssueCode.custom,
+      code: import_zod9.z.ZodIssueCode.custom,
       message: "`dateRange.from` must be before `dateRange.to`.",
       path: ["dateRange", "from"]
     });
@@ -629,7 +662,7 @@ var MetricsQuerySchema = import_zod8.z.discriminatedUnion("resource", [
   const spanDays = (to.getTime() - from.getTime()) / ONE_DAY_MS;
   if (spanDays > MAX_METRICS_QUERY_DATE_RANGE_DAYS) {
     ctx.addIssue({
-      code: import_zod8.z.ZodIssueCode.custom,
+      code: import_zod9.z.ZodIssueCode.custom,
       message: `\`dateRange\` cannot span more than ${MAX_METRICS_QUERY_DATE_RANGE_DAYS} days.`,
       path: ["dateRange", "to"]
     });
@@ -637,7 +670,7 @@ var MetricsQuerySchema = import_zod8.z.discriminatedUnion("resource", [
   const dateBucketCount = input.groupBy.filter((entry) => entry.type === "date_bucket").length;
   if (dateBucketCount > 1) {
     ctx.addIssue({
-      code: import_zod8.z.ZodIssueCode.custom,
+      code: import_zod9.z.ZodIssueCode.custom,
       message: "At most one `date_bucket` entry is allowed in `groupBy`.",
       path: ["groupBy"]
     });
@@ -645,7 +678,7 @@ var MetricsQuerySchema = import_zod8.z.discriminatedUnion("resource", [
   input.metrics.forEach((metric, index) => {
     if (metric.aggregation !== "count" && metric.field === void 0) {
       ctx.addIssue({
-        code: import_zod8.z.ZodIssueCode.custom,
+        code: import_zod9.z.ZodIssueCode.custom,
         message: "`field` is required unless `aggregation` is `count`.",
         path: ["metrics", index, "field"]
       });
@@ -654,7 +687,7 @@ var MetricsQuerySchema = import_zod8.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_zod8.z.ZodIssueCode.custom,
+      code: import_zod9.z.ZodIssueCode.custom,
       message: "Every `metrics[].alias` must be unique.",
       path: ["metrics"]
     });
@@ -663,36 +696,36 @@ var MetricsQuerySchema = import_zod8.z.discriminatedUnion("resource", [
   input.metrics.forEach((metric, index) => {
     if (metric.alias !== void 0 && reservedNames.has(metric.alias)) {
       ctx.addIssue({
-        code: import_zod8.z.ZodIssueCode.custom,
+        code: import_zod9.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_zod8.z.record(
-  import_zod8.z.string(),
-  import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number(), import_zod8.z.boolean(), import_zod8.z.null()])
+var MetricsQueryResultRowSchema = import_zod9.z.record(
+  import_zod9.z.string(),
+  import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean(), import_zod9.z.null()])
 );
-var MetricsQueryScopeSchema = import_zod8.z.enum(["owner_admin", "member"]).describe(
+var MetricsQueryScopeSchema = import_zod9.z.enum(["owner_admin", "member"]).describe(
   "`member`: results were automatically restricted to data tied to API keys you personally created \u2014 rows with no resolvable creator were excluded, not counted, and not surfaced any other way. `owner_admin`: the full organization\u2019s data was queried, no restriction applied."
 );
-var MetricsQueryResultSchema = import_zod8.z.object({
-  data: import_zod8.z.array(MetricsQueryResultRowSchema),
-  meta: import_zod8.z.object({
+var MetricsQueryResultSchema = import_zod9.z.object({
+  data: import_zod9.z.array(MetricsQueryResultRowSchema),
+  meta: import_zod9.z.object({
     resource: MetricsResourceSchema,
     environment: EnvironmentSchema,
     scope: MetricsQueryScopeSchema,
-    rowCount: import_zod8.z.number().int().describe("Number of rows in `data`."),
-    truncated: import_zod8.z.boolean().describe(
+    rowCount: import_zod9.z.number().int().describe("Number of rows in `data`."),
+    truncated: import_zod9.z.boolean().describe(
       "`true` if more rows matched than `limit` allowed \u2014 `data` holds only the first `limit`."
     )
   })
 });
 
 // src/webhook-events.ts
-var import_zod9 = require("zod");
-var ChargeWebhookEventTypeSchema = import_zod9.z.enum([
+var import_zod10 = require("zod");
+var ChargeWebhookEventTypeSchema = import_zod10.z.enum([
   "charge.created",
   "charge.partially_paid",
   "charge.confirmed",
@@ -704,11 +737,13 @@ var ChargeWebhookEventTypeSchema = import_zod9.z.enum([
   "charge.paused",
   "charge.reactivated",
   "charge.contribution_received",
-  "charge.contribution_settled"
+  "charge.contribution_settled",
+  "charge.canceled",
+  "charge.paid_after_cancel"
 ]).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`, except `charge.paused`/`charge.reactivated`/`charge.contribution_received`/`charge.contribution_settled` (see below). `charge.paused` fires when a charge with no `expiresAt` has had no contribution for longer than its inactivity window (90 days for a charge with a goal `amount`, 365 days for one without) \u2014 Klappay stops watching its address in real time, but the charge itself is never closed; `charge.reactivated` fires the moment a transfer lands on a paused charge, detected by the same fallback poller used for missed webhooks (so with much higher latency than normal \u2014 pausing trades that away deliberately, see `docs/payments.md`). `charge.contribution_received`/`charge.contribution_settled` are exclusive to `mode: continuous` charges (see `Charge.mode`) \u2014 a continuous charge never fires `charge.confirmed`/`charge.settled` at all, since `status` never leaves `pending`; instead every individual transfer fires `contribution_received` on detection and `contribution_settled` once its payout completes, one pair-scoped event per contribution instead of one event for the whole charge. `data` for `charge.paused`: `{ chargeId, lastActivityAt, pausedAt }`; for `charge.reactivated`: `{ chargeId, reactivatedAt }`; for `charge.contribution_received`: `{ chargeId, token, network, amount, txHash, payerAddress }`; for `charge.contribution_settled`: `{ chargeId, token, network, amount, txHash, distributorAddress }`.'
+  '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`, except `charge.paused`/`charge.reactivated`/`charge.contribution_received`/`charge.contribution_settled`/`charge.paid_after_cancel` (see below). `charge.paused` fires when a charge with no `expiresAt` has had no contribution for longer than its inactivity window (90 days for a charge with a goal `amount`, 365 days for one without) \u2014 Klappay stops watching its address in real time, but the charge itself is never closed; `charge.reactivated` fires the moment a transfer lands on a paused charge, detected by the same fallback poller used for missed webhooks (so with much higher latency than normal \u2014 pausing trades that away deliberately, see `docs/payments.md`). `charge.contribution_received`/`charge.contribution_settled` are exclusive to `mode: continuous` charges (see `Charge.mode`) \u2014 a continuous charge never fires `charge.confirmed`/`charge.settled` at all, since `status` never leaves `pending`; instead every individual transfer fires `contribution_received` on detection and `contribution_settled` once its payout completes, one pair-scoped event per contribution instead of one event for the whole charge. `charge.canceled` fires when a merchant explicitly cancels a `pending`/`partially_paid` charge via `POST /v1/charges/{id}/cancel` \u2014 unlike every other terminal status, this one is never reached automatically. `charge.paid_after_cancel` is an anomaly signal: a transfer still landed on a canceled charge\'s address (nothing on-chain can prevent that) \u2014 `status` stays `canceled`, it is never silently resumed, and this event is your cue to manually refund the payer or honor the charge anyway. `data` for `charge.paused`: `{ chargeId, lastActivityAt, pausedAt }`; for `charge.reactivated`: `{ chargeId, reactivatedAt }`; for `charge.contribution_received`: `{ chargeId, token, network, amount, txHash, payerAddress }`; for `charge.contribution_settled`: `{ chargeId, token, network, amount, txHash, distributorAddress }`; for `charge.paid_after_cancel`: `{ chargeId, token, network, amount, txHash, payerAddress }`.'
 );
-var AccountWebhookEventTypeSchema = import_zod9.z.enum([
+var AccountWebhookEventTypeSchema = import_zod10.z.enum([
   "payout_address.changed",
   "api_key.created",
   "api_key.revoked",
@@ -722,10 +757,10 @@ var AccountWebhookEventTypeSchema = import_zod9.z.enum([
 ]).describe(
   "Account and configuration changes \u2014 not tied to any single charge. `data` per event: `payout_address.changed`: `{ organizationId, from, to }` (`from` nullable); `api_key.created`/`api_key.revoked`: `{ apiKeyId, name, environment, hint }`; `webhook.created`/`webhook.deleted`/`webhook.secret_rotated`: `{ webhookId, url }`; `fee_tier.updated`: `{ organizationId, previousFeePercent, newFeePercent }`; `member.removed`: `{ userId, email, role }`; `member.role_changed`: `{ userId, email, role, previousRole }`; `member.invited`: `{ organizationId, email, role, invitedByUserId }`."
 );
-var WebhookDeliveryEventTypeSchema = import_zod9.z.enum(["webhook.delivery_failed", "webhook.delivery_recovered", "webhook.endpoint_unhealthy"]).describe(
+var WebhookDeliveryEventTypeSchema = import_zod10.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 SecurityWebhookEventTypeSchema = import_zod9.z.enum([
+var SecurityWebhookEventTypeSchema = import_zod10.z.enum([
   "auth.login",
   "auth.login_failed",
   "auth.suspicious_activity",
@@ -738,13 +773,13 @@ var SecurityWebhookEventTypeSchema = import_zod9.z.enum([
 ]).describe(
   "Account security signals. `auth.suspicious_activity` is a soft heuristic (login from an IP not seen on this account before), not a block \u2014 evaluate it, not enforce against it. `auth.password_reset_requested` only ever dispatches when the requested email actually matches an account (there is nowhere to notify otherwise) \u2014 `POST /v1/auth/forgot-password` itself always returns the same generic response either way, so this event never becomes a second channel for the same enumeration question the endpoint response deliberately avoids answering. `auth.password_changed` is the self-service counterpart to `auth.password_reset_completed` \u2014 fires from `POST /v1/auth/change-password` (requires the current password) instead of the unauthenticated forgot-password flow. `auth.email_change_requested`/`auth.email_changed` are the request/complete pair for `POST /v1/auth/change-email` \u2192 `POST /v1/auth/confirm-email-change` \u2014 the change only takes effect, and `email_changed` only fires, once the confirmation link sent to the *current* address is used. `data` per event: `auth.login`: `{ userId, ipAddress }`; `auth.login_failed`: `{ email, ipAddress }`; `auth.suspicious_activity`: `{ userId, ipAddress, previousIpAddress }`; `auth.email_verified`/`auth.password_reset_requested`/`auth.password_reset_completed`/`auth.password_changed`: `{ userId, email }`; `auth.email_change_requested`: `{ userId, email, newEmail }`; `auth.email_changed`: `{ userId, previousEmail, newEmail }`."
 );
-var WebhookEventTypeSchema = import_zod9.z.union([
+var WebhookEventTypeSchema = import_zod10.z.union([
   ChargeWebhookEventTypeSchema,
   AccountWebhookEventTypeSchema,
   WebhookDeliveryEventTypeSchema,
   SecurityWebhookEventTypeSchema
 ]);
-var WebhookCategorySchema = import_zod9.z.enum(["payments", "account", "webhooks", "security"]).describe(
+var WebhookCategorySchema = import_zod10.z.enum(["payments", "account", "webhooks", "security"]).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() {
@@ -767,108 +802,110 @@ var TriggerableChargeEventSchema = ChargeWebhookEventTypeSchema.exclude([
   "charge.paused",
   "charge.reactivated",
   "charge.contribution_received",
-  "charge.contribution_settled"
+  "charge.contribution_settled",
+  "charge.canceled",
+  "charge.paid_after_cancel"
 ]).describe(
-  "Every charge event that represents a payment-progress state transition a sandbox charge can be pushed into \u2014 everything except `charge.created` (a charge already exists by the time you have an id to trigger against), `charge.paused`/`charge.reactivated` (driven by a background worker on real inactivity, not a payment state \u2014 nothing meaningful to simulate or wait for on a fresh sandbox charge), and `charge.contribution_received`/`charge.contribution_settled` (exclusive to `mode: continuous` charges, which this trigger endpoint does not support simulating today \u2014 see `POST /v1/charges/{id}/trigger`'s own description)."
+  "Every charge event that represents a payment-progress state transition a sandbox charge can be pushed into \u2014 everything except `charge.created` (a charge already exists by the time you have an id to trigger against), `charge.paused`/`charge.reactivated` (driven by a background worker on real inactivity, not a payment state \u2014 nothing meaningful to simulate or wait for on a fresh sandbox charge), `charge.contribution_received`/`charge.contribution_settled` (exclusive to `mode: continuous` charges, which this trigger endpoint does not support simulating today \u2014 see `POST /v1/charges/{id}/trigger`'s own description), and `charge.canceled` (already a real, immediate action in `test` mode via `POST /v1/charges/{id}/cancel` itself \u2014 nothing to simulate) along with `charge.paid_after_cancel` (not simulatable without a real transfer to an already-canceled charge)."
 );
-var NonChargeTriggerableEventSchema = import_zod9.z.union([
+var NonChargeTriggerableEventSchema = import_zod10.z.union([
   AccountWebhookEventTypeSchema,
   WebhookDeliveryEventTypeSchema,
   SecurityWebhookEventTypeSchema
 ]);
 
 // src/webhooks.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var WEBHOOK_EVENTS_WILDCARD = "*";
-var CreateWebhookSchema = import_zod10.z.object({
-  url: import_zod10.z.string().max(2048).url().describe(
+var CreateWebhookSchema = import_zod11.z.object({
+  url: import_zod11.z.string().max(2048).url().describe(
     "Must be HTTPS and resolve to a public address \u2014 private/internal IPs are rejected."
   ),
-  events: import_zod10.z.array(import_zod10.z.union([WebhookEventTypeSchema, import_zod10.z.literal(WEBHOOK_EVENTS_WILDCARD)])).max(Object.keys(EVENT_CATEGORY_MAP).length + 1).default([]).describe(
+  events: import_zod11.z.array(import_zod11.z.union([WebhookEventTypeSchema, import_zod11.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_zod10.z.array(WebhookCategorySchema).max(WebhookCategorySchema.options.length).default([]).describe(
+  eventCategories: import_zod11.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_zod10.z.array(WebhookEventTypeSchema).max(Object.keys(EVENT_CATEGORY_MAP).length).default([]).describe(
+  excludeEvents: import_zod11.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_zod10.z.object({
-  id: import_zod10.z.string(),
+var WebhookSchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
   environment: EnvironmentSchema.nullable().describe(
     "Which environment's API key created this webhook \u2014 `live` or `test`. Charge/webhook-delivery-health events are 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). Account/security events (`payout_address.changed`, `member.*`, `auth.*`, `fee_tier.updated`) have no environment concept and are delivered regardless."
   ),
-  url: import_zod10.z.string(),
-  events: import_zod10.z.array(WebhookEventTypeSchema),
-  eventCategories: import_zod10.z.array(WebhookCategorySchema),
-  excludeEvents: import_zod10.z.array(WebhookEventTypeSchema),
-  isWildcard: import_zod10.z.boolean(),
-  secret: import_zod10.z.string().describe(
+  url: import_zod11.z.string(),
+  events: import_zod11.z.array(WebhookEventTypeSchema),
+  eventCategories: import_zod11.z.array(WebhookCategorySchema),
+  excludeEvents: import_zod11.z.array(WebhookEventTypeSchema),
+  isWildcard: import_zod11.z.boolean(),
+  secret: import_zod11.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_zod10.z.string().datetime()
+  createdAt: import_zod11.z.string().datetime()
 });
 var WebhookListItemSchema = WebhookSchema.omit({ secret: true }).extend({
-  hint: import_zod10.z.string().describe("A truncated, safe-to-display form of the secret (e.g. `whsec_...ab12`).")
+  hint: import_zod11.z.string().describe("A truncated, safe-to-display form of the secret (e.g. `whsec_...ab12`).")
 });
-var WebhookPayloadSchema = import_zod10.z.object({
-  id: import_zod10.z.string().describe(
+var WebhookPayloadSchema = import_zod11.z.object({
+  id: import_zod11.z.string().describe(
     "Unique id for this specific delivery \u2014 also sent as the `X-Klappay-Delivery` header."
   ),
   event: WebhookEventTypeSchema,
-  createdAt: import_zod10.z.string().datetime(),
-  data: import_zod10.z.unknown().describe(
+  createdAt: import_zod11.z.string().datetime(),
+  data: import_zod11.z.unknown().describe(
     "Event-specific data. Charge events (`charge.*`) carry the full `Charge` object; account/security/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_zod10.z.enum(["pending", "delivered", "failed"]);
-var WebhookDeliverySchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  webhookId: import_zod10.z.string(),
+var WebhookDeliveryStatusSchema = import_zod11.z.enum(["pending", "delivered", "failed"]);
+var WebhookDeliverySchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  webhookId: import_zod11.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_zod10.z.number(),
-  responseCode: import_zod10.z.number().nullable().describe(
+  attempts: import_zod11.z.number(),
+  responseCode: import_zod11.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_zod10.z.string().datetime().nullable(),
-  deliveredAt: import_zod10.z.string().datetime().nullable(),
-  createdAt: import_zod10.z.string().datetime()
+  nextRetryAt: import_zod11.z.string().datetime().nullable(),
+  deliveredAt: import_zod11.z.string().datetime().nullable(),
+  createdAt: import_zod11.z.string().datetime()
 });
 var ListWebhookDeliveriesSchema = PaginationQuerySchema;
 var PaginatedWebhookDeliveriesSchema = paginatedSchema(WebhookDeliverySchema);
 
 // src/api-keys.ts
-var import_zod11 = require("zod");
-var CreateApiKeySchema = import_zod11.z.object({
-  name: import_zod11.z.string().min(1).max(64).describe(
+var import_zod12 = require("zod");
+var CreateApiKeySchema = import_zod12.z.object({
+  name: import_zod12.z.string().min(1).max(64).describe(
     'A label to help you tell keys apart (e.g. `"production backend"`). Not used for anything functional.'
   ),
   environment: EnvironmentSchema.describe(
     "`live` keys move real funds on Base mainnet; `test` keys settle on Base Sepolia (a real testnet, no real money) and additionally unlock `POST /v1/sandbox/*` for simulating events with zero on-chain activity at all."
   )
 });
-var ApiKeySchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
+var ApiKeySchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
   environment: EnvironmentSchema.describe(
     "`live` keys authenticate real charges on Base mainnet; `test` keys authenticate the same charge lifecycle on Base Sepolia (a real testnet) and additionally unlock `/v1/sandbox/*` for synthetic event simulation."
   ),
-  key: import_zod11.z.string().optional().describe(
+  key: import_zod12.z.string().optional().describe(
     "The full secret key (`klap_live_...` / `klap_test_...`), used as the `Authorization: Bearer` value on `/v1/charges`, `/v1/webhooks`, and `/v1/sandbox` requests. Present only in the response to `POST /v1/api-keys` \u2014 never returned again afterward, so store it immediately."
   ),
-  hint: import_zod11.z.string().describe(
+  hint: import_zod12.z.string().describe(
     "A truncated, always-safe-to-display form of the key (e.g. `klap_live_...ab12`), returned everywhere the full key isn't."
   ),
-  createdAt: import_zod11.z.string().datetime(),
-  lastUsedAt: import_zod11.z.string().datetime().nullable().describe("Updated on every successful authenticated request. `null` if never used."),
-  createdByUserId: import_zod11.z.string().nullable().describe(
+  createdAt: import_zod12.z.string().datetime(),
+  lastUsedAt: import_zod12.z.string().datetime().nullable().describe("Updated on every successful authenticated request. `null` if never used."),
+  createdByUserId: import_zod12.z.string().nullable().describe(
     "Which member of the organization created this key. `null` for a key created before this field existed."
   )
 });
@@ -876,93 +913,93 @@ var ListApiKeysSchema = PaginationQuerySchema;
 var PaginatedApiKeysSchema = paginatedSchema(ApiKeySchema);
 
 // src/users.ts
-var import_zod12 = require("zod");
-var UserRoleSchema = import_zod12.z.enum(["owner", "admin", "member"]).describe(
+var import_zod13 = require("zod");
+var UserRoleSchema = import_zod13.z.enum(["owner", "admin", "member"]).describe(
   "`owner`: full access, and the organization must always keep at least one. `admin`: can manage `member`s but not other `admin`s. `member`: no management permissions. You can only manage a member with a strictly lower role than your own, unless you're an `owner`."
 );
-var UpdateUserRoleSchema = import_zod12.z.object({
+var UpdateUserRoleSchema = import_zod13.z.object({
   role: UserRoleSchema
 });
-var UserSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  email: import_zod12.z.string(),
-  name: import_zod12.z.string().nullable(),
+var UserSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  email: import_zod13.z.string(),
+  name: import_zod13.z.string().nullable(),
   role: UserRoleSchema.describe("Your role within the organization this user was fetched from."),
-  emailVerifiedAt: import_zod12.z.string().datetime().nullable().describe(
+  emailVerifiedAt: import_zod13.z.string().datetime().nullable().describe(
     "When this address was confirmed via the emailed verification link. `null` until then. Required (non-null) for two specific actions: creating a `live` API key (`POST /v1/api-keys`) and changing `Organization.payoutAddress` (`PATCH /v1/organization`) \u2014 everything else works regardless of verification status."
   ),
-  createdAt: import_zod12.z.string().datetime()
+  createdAt: import_zod13.z.string().datetime()
 });
 var ListUsersSchema = PaginationQuerySchema;
 var PaginatedUsersSchema = paginatedSchema(UserSchema);
 
 // src/auth.ts
-var import_zod13 = require("zod");
-var NormalizedEmailSchema = import_zod13.z.string().trim().max(255).toLowerCase().email().transform((email) => email.normalize("NFC")).describe(
+var import_zod14 = require("zod");
+var NormalizedEmailSchema = import_zod14.z.string().trim().max(255).toLowerCase().email().transform((email) => email.normalize("NFC")).describe(
   "Trimmed, lowercased, and NFC-normalized server-side before use \u2014 case/whitespace don't matter."
 );
-var SignupSchema = import_zod13.z.object({
+var SignupSchema = import_zod14.z.object({
   email: NormalizedEmailSchema,
-  password: import_zod13.z.string().min(8).max(128).describe("8-128 characters. No other complexity rule.")
+  password: import_zod14.z.string().min(8).max(128).describe("8-128 characters. No other complexity rule.")
 });
-var LoginSchema = import_zod13.z.object({
+var LoginSchema = import_zod14.z.object({
   email: NormalizedEmailSchema,
-  password: import_zod13.z.string().min(1).max(128)
+  password: import_zod14.z.string().min(1).max(128)
 });
-var VerifyEmailSchema = import_zod13.z.object({
-  token: import_zod13.z.string().min(1).describe("The token from the verification email \u2014 passed as-is, not the account email.")
+var VerifyEmailSchema = import_zod14.z.object({
+  token: import_zod14.z.string().min(1).describe("The token from the verification email \u2014 passed as-is, not the account email.")
 });
-var ForgotPasswordSchema = import_zod13.z.object({
+var ForgotPasswordSchema = import_zod14.z.object({
   email: NormalizedEmailSchema
 });
-var ResetPasswordSchema = import_zod13.z.object({
-  token: import_zod13.z.string().min(1).describe("The token from the password reset email."),
-  newPassword: import_zod13.z.string().min(8).max(128)
+var ResetPasswordSchema = import_zod14.z.object({
+  token: import_zod14.z.string().min(1).describe("The token from the password reset email."),
+  newPassword: import_zod14.z.string().min(8).max(128)
 });
-var MessageResponseSchema = import_zod13.z.object({
-  message: import_zod13.z.string().describe("Human-readable confirmation, safe to show a user directly.")
+var MessageResponseSchema = import_zod14.z.object({
+  message: import_zod14.z.string().describe("Human-readable confirmation, safe to show a user directly.")
 });
 var SelfUserSchema = UserSchema.omit({ createdAt: true, role: true });
-var AuthResponseSchema = import_zod13.z.object({
-  token: import_zod13.z.string().describe(
+var AuthResponseSchema = import_zod14.z.object({
+  token: import_zod14.z.string().describe(
     "Session JWT, valid 7 days \u2014 use as `Authorization: Bearer <token>` on every `/v1/organizations/*` request (which nests API keys, members, and invitations \u2014 see `GET /v1/organizations`). This token identifies only you; it carries no organization or role \u2014 every `/v1/organizations/{id}/*` request is authorized fresh against your actual membership in that specific organization. This is a separate credential from an API key: it authenticates a human/dashboard session, not payment operations. Create an API key with it before you can create charges."
   ),
   user: SelfUserSchema
 });
-var ChangeNameSchema = import_zod13.z.object({
-  name: import_zod13.z.string().min(1).max(255).describe("Your display name.")
+var ChangeNameSchema = import_zod14.z.object({
+  name: import_zod14.z.string().min(1).max(255).describe("Your display name.")
 });
-var ChangePasswordSchema = import_zod13.z.object({
-  currentPassword: import_zod13.z.string().min(1).max(128),
-  newPassword: import_zod13.z.string().min(8).max(128)
+var ChangePasswordSchema = import_zod14.z.object({
+  currentPassword: import_zod14.z.string().min(1).max(128),
+  newPassword: import_zod14.z.string().min(8).max(128)
 });
-var ChangeEmailSchema = import_zod13.z.object({
-  currentPassword: import_zod13.z.string().min(1).max(128),
+var ChangeEmailSchema = import_zod14.z.object({
+  currentPassword: import_zod14.z.string().min(1).max(128),
   newEmail: NormalizedEmailSchema
 });
-var ConfirmEmailChangeSchema = import_zod13.z.object({
-  token: import_zod13.z.string().min(1).describe("The token from the confirmation email sent to your current address.")
+var ConfirmEmailChangeSchema = import_zod14.z.object({
+  token: import_zod14.z.string().min(1).describe("The token from the confirmation email sent to your current address.")
 });
 
 // src/organization.ts
-var import_zod14 = require("zod");
-var UpdateOrganizationSchema = import_zod14.z.object({
-  name: import_zod14.z.string().min(1).max(255).optional().describe("The organization's display name."),
-  payoutAddress: import_zod14.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "must be a valid EVM address").optional().describe(
+var import_zod15 = require("zod");
+var UpdateOrganizationSchema = import_zod15.z.object({
+  name: import_zod15.z.string().min(1).max(255).optional().describe("The organization's display name."),
+  payoutAddress: import_zod15.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "must be a valid EVM address").optional().describe(
     "The wallet that receives the merchant's share of every future charge. Changing this only affects charges created after the change \u2014 an already-created charge's payout split is frozen from creation and is never retroactively affected. Required before you can create any charge. Any casing is accepted \u2014 EIP-55 checksum casing is not required or verified."
   )
 });
-var OrganizationSchema = import_zod14.z.object({
-  id: import_zod14.z.string(),
-  name: import_zod14.z.string(),
-  payoutAddress: import_zod14.z.string().nullable().describe("`null` until configured \u2014 `POST /v1/charges` fails until this is set."),
-  currentFeePercent: import_zod14.z.number().describe(
+var OrganizationSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  name: import_zod15.z.string(),
+  payoutAddress: import_zod15.z.string().nullable().describe("`null` until configured \u2014 `POST /v1/charges` fails until this is set."),
+  currentFeePercent: import_zod15.z.number().describe(
     "Your current platform fee percentage \u2014 `1.5` means 1.5%, not a 0\u20131 fraction. Funds the infrastructure Klappay runs on your behalf (on-chain monitoring, settlement, webhook delivery, support) the same way any payment processor's fee does; this is not optional or removable. Dynamic, not fixed: it's based on your trailing monthly volume, with lower volume paying a higher percentage \u2014 higher-volume organizations, or ones with a specific negotiated arrangement, can be assigned a different rate at Klappay's discretion. Frozen onto each charge at creation, so a rate change never retroactively affects a charge already created; see `feeUpdatedAt` for when it last changed. Contact Klappay if you'd like your rate reviewed."
   ),
-  feeUpdatedAt: import_zod14.z.string().datetime().nullable().describe(
+  feeUpdatedAt: import_zod15.z.string().datetime().nullable().describe(
     "When `currentFeePercent` last changed. `null` if it has never changed since this organization signed up."
   ),
-  createdAt: import_zod14.z.string().datetime()
+  createdAt: import_zod15.z.string().datetime()
 });
 var OrganizationWithRoleSchema = OrganizationSchema.extend({
   role: UserRoleSchema.describe("Your own role within this specific organization.")
@@ -971,50 +1008,51 @@ var PaginatedOrganizationsSchema = paginatedSchema(OrganizationWithRoleSchema);
 var ListOrganizationsSchema = PaginationQuerySchema;
 
 // src/invitations.ts
-var import_zod15 = require("zod");
-var InviteUserSchema = import_zod15.z.object({
+var import_zod16 = require("zod");
+var InviteUserSchema = import_zod16.z.object({
   email: NormalizedEmailSchema,
   role: UserRoleSchema.default("member").describe(
     "The role the invitee will hold once they accept \u2014 subject to the same management-hierarchy rule as `PATCH /v1/organizations/{id}/users/{userId}`: an `admin` inviter cannot invite an `admin` or `owner`."
   )
 });
-var AcceptInvitationSchema = import_zod15.z.object({
-  token: import_zod15.z.string().min(1).describe("The token from the invitation email."),
-  password: import_zod15.z.string().min(8).max(128).optional().describe(
+var AcceptInvitationSchema = import_zod16.z.object({
+  token: import_zod16.z.string().min(1).describe("The token from the invitation email."),
+  password: import_zod16.z.string().min(8).max(128).optional().describe(
     "Required only if the invited email has no existing Klappay account \u2014 a new account is created along with the membership. Ignored if the account already exists."
   )
 });
-var InvitationSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  organizationId: import_zod15.z.string(),
-  email: import_zod15.z.string(),
+var InvitationSchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  organizationId: import_zod16.z.string(),
+  email: import_zod16.z.string(),
   role: UserRoleSchema,
-  invitedByUserId: import_zod15.z.string().describe("Which member of the organization sent this invitation."),
-  expiresAt: import_zod15.z.string().datetime(),
-  createdAt: import_zod15.z.string().datetime()
+  invitedByUserId: import_zod16.z.string().describe("Which member of the organization sent this invitation."),
+  expiresAt: import_zod16.z.string().datetime(),
+  createdAt: import_zod16.z.string().datetime()
 });
 
 // src/timeline.ts
-var import_zod16 = require("zod");
-var TransactionSourceSchema = import_zod16.z.enum(["moralis_webhook", "reconciliation_job", "sandbox"]).describe(
+var import_zod17 = require("zod");
+var TransactionSourceSchema = import_zod17.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_zod16.z.enum([
+var TimelineEventTypeSchema = import_zod17.z.enum([
   "charge.created",
   "charge.expired",
+  "charge.canceled",
   "transaction.detected",
   "split.distributed",
   "webhook.dispatched",
   "webhook.delivered",
   "webhook.failed"
 ]).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)."
+  "`charge.created`: the charge was created. `charge.expired`: `expiresAt` passed with no full payment. `charge.canceled`: the merchant explicitly canceled it via `POST /v1/charges/{id}/cancel`. `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_zod16.z.object({
+var TimelineEventSchema = import_zod17.z.object({
   type: TimelineEventTypeSchema,
-  at: import_zod16.z.string().datetime(),
-  txHash: import_zod16.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
-  amount: import_zod16.z.number().optional().describe(
+  at: import_zod17.z.string().datetime(),
+  txHash: import_zod17.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
+  amount: import_zod17.z.number().optional().describe(
     "Present for `transaction.detected` events only \u2014 the amount that specific transfer carried."
   ),
   source: TransactionSourceSchema.optional().describe(
@@ -1026,66 +1064,20 @@ var TimelineEventSchema = import_zod16.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_zod16.z.boolean().optional().describe(
+  causedTransition: import_zod17.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_zod16.z.number().nullable().optional().describe(
+  responseCode: import_zod17.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_zod16.z.number().optional().describe(
+  attempts: import_zod17.z.number().optional().describe(
     "Present for `webhook.*` events only \u2014 how many delivery attempts have been made so far."
   )
 });
 
-// src/verify.ts
-var import_zod17 = require("zod");
-var SplitRecipientRoleSchema = import_zod17.z.enum(["merchant", "klap_fee", "distributor_incentive"]).describe(
-  "`merchant`: the payout recipient. `klap_fee`: the platform fee. `distributor_incentive`: the (usually small) reward paid to whoever triggered the on-chain settlement \u2014 may be Klappay or a third party, see `address`."
-);
-var VerifySplitEntrySchema = import_zod17.z.object({
-  role: SplitRecipientRoleSchema,
-  address: import_zod17.z.string().nullable().describe(
-    "On-chain recipient address for this share. For `distributor_incentive`, this is `null` until settlement actually happens \u2014 there is no fixed address, it goes to whoever calls the settlement transaction."
-  ),
-  percentAllocation: import_zod17.z.number().describe("This entry's share of `amountReceived`, as a percentage (e.g. `99` = 99%)."),
-  amountUSD: import_zod17.z.number()
-});
-var VerifyPaymentSchema = import_zod17.z.object({
-  token: TokenSchema,
-  network: NetworkSchema,
-  amountReceived: import_zod17.z.number().describe("Cumulative amount received on this specific `(token, network)` pair."),
-  txHash: import_zod17.z.string().describe("The on-chain transaction hash of the most recent transfer on this pair."),
-  explorerTxUrl: import_zod17.z.string().describe("Direct link to `txHash` on the relevant block explorer."),
-  split: import_zod17.z.array(VerifySplitEntrySchema).describe(
-    "The exact breakdown of where this pair's payment went \u2014 merchant's share, Klappay's fee, and (once settled) the settlement incentive."
-  ),
-  splitTxHash: import_zod17.z.string().nullable().describe(
-    "Transaction hash of the payout to the merchant for this pair, once settlement has happened. `null` until then."
-  ),
-  settledAt: import_zod17.z.string().datetime().nullable().describe(
-    "When settlement completed for this pair \u2014 the merchant's wallet actually has the funds. `null` until then."
-  )
-});
-var VerifyChargeSchema = import_zod17.z.object({
-  id: import_zod17.z.string(),
-  amount: import_zod17.z.number().nullable().describe("The amount originally requested. `null` if the charge accepted any amount."),
-  amountReceived: import_zod17.z.number().describe(
-    "The actual cumulative amount received across every contributing pair \u2014 can exceed `amount` on an overpayment."
-  ),
-  confirmedAt: import_zod17.z.string().datetime().nullable().describe(
-    "When the charge reached `confirmed`. `null` for a `mode: continuous` charge \u2014 it never reaches a single confirmed moment (`status` stays `pending` for its whole life, see `Charge.mode`); use each entry in `payments[].settledAt` for per-contribution timing instead."
-  ),
-  splitAddress: import_zod17.z.string().describe(
-    "The on-chain address the payment was sent to \u2014 identical across every accepted network."
-  ),
-  payments: import_zod17.z.array(VerifyPaymentSchema).describe(
-    "One entry per `(token, network)` pair that actually contributed funds \u2014 a charge accepting several pairs can be confirmed by a combination of them, each proven and settled independently."
-  )
-});
-
 // src/health.ts
 var import_zod18 = require("zod");
 var HealthSchema = import_zod18.z.object({
@@ -1140,7 +1132,6 @@ var CapabilitiesSchema = import_zod20.z.object({
   ChangePasswordSchema,
   ChargeModeSchema,
   ChargeSchema,
-  ChargeStatusEventSchema,
   ChargeStatusSchema,
   ChargeWebhookEventTypeSchema,
   ChargesDateFieldSchema,
@@ -1159,6 +1150,7 @@ var CapabilitiesSchema = import_zod20.z.object({
   ErrorPayloadSchema,
   ForgotPasswordSchema,
   GetChargeQrCodeQuerySchema,
+  GetPublicChargeQuerySchema,
   HealthSchema,
   InvitationSchema,
   InviteUserSchema,
@@ -1167,6 +1159,7 @@ var CapabilitiesSchema = import_zod20.z.object({
   ListOrganizationsSchema,
   ListUsersSchema,
   ListWebhookDeliveriesSchema,
+  ListenPendingDistributionsQuerySchema,
   LoginSchema,
   MAX_METRICS_QUERY_DATE_RANGE_DAYS,
   METRICS_QUERY_DEFAULT_ROW_LIMIT,
@@ -1197,12 +1190,14 @@ var CapabilitiesSchema = import_zod20.z.object({
   PaginatedApiKeysSchema,
   PaginatedChargesSchema,
   PaginatedOrganizationsSchema,
+  PaginatedPendingDistributionsSchema,
   PaginatedUsersSchema,
   PaginatedWebhookDeliveriesSchema,
   PaginationQuerySchema,
   PendingDistributionEventSchema,
   PendingDistributionRecipientSchema,
   PendingDistributionSchema,
+  PublicChargeSchema,
   ResetPasswordSchema,
   SandboxEventTriggerSchema,
   SandboxTriggerSchema,
@@ -1211,7 +1206,6 @@ var CapabilitiesSchema = import_zod20.z.object({
   SettlementStatusSchema,
   SignupSchema,
   SplitDistributionStatusSchema,
-  SplitRecipientRoleSchema,
   TOKEN_ADDRESSES,
   TOKEN_DECIMALS,
   TimelineEventSchema,
@@ -1226,10 +1220,7 @@ var CapabilitiesSchema = import_zod20.z.object({
   UpdateUserRoleSchema,
   UserRoleSchema,
   UserSchema,
-  VerifyChargeSchema,
   VerifyEmailSchema,
-  VerifyPaymentSchema,
-  VerifySplitEntrySchema,
   WEBHOOK_EVENTS_WILDCARD,
   WEBHOOK_EVENT_CATEGORIES,
   WebhookCategorySchema,