@klappay/types 1.1.2 → 2.0.1

package/dist/index.js

@@ -20,28 +20,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AcceptInvitationSchema: () => AcceptInvitationSchema,
+  API_KEY_SCOPES: () => API_KEY_SCOPES,
   AcceptedPaymentSchema: () => AcceptedPaymentSchema,
-  AccountWebhookEventTypeSchema: () => AccountWebhookEventTypeSchema,
-  ApiKeySchema: () => ApiKeySchema,
-  AuthResponseSchema: () => AuthResponseSchema,
+  ApiKeyScopeSchema: () => ApiKeyScopeSchema,
   CHARGE_ACCEPTED_PAYMENTS_MAX: () => CHARGE_ACCEPTED_PAYMENTS_MAX,
   CHARGE_AMOUNT_MAX: () => CHARGE_AMOUNT_MAX,
   CHARGE_EXPIRES_IN_MAX_SECONDS: () => CHARGE_EXPIRES_IN_MAX_SECONDS,
   CHARGE_EXPIRES_IN_MIN_SECONDS: () => CHARGE_EXPIRES_IN_MIN_SECONDS,
   CapabilitiesSchema: () => CapabilitiesSchema,
-  ChangeEmailSchema: () => ChangeEmailSchema,
-  ChangeNameSchema: () => ChangeNameSchema,
-  ChangePasswordSchema: () => ChangePasswordSchema,
-  ChargeModeSchema: () => ChargeModeSchema,
   ChargeSchema: () => ChargeSchema,
   ChargeStatusSchema: () => ChargeStatusSchema,
   ChargeWebhookEventTypeSchema: () => ChargeWebhookEventTypeSchema,
   ChargesDateFieldSchema: () => ChargesDateFieldSchema,
   ChargesMetricFieldSchema: () => ChargesMetricFieldSchema,
   ChargesQueryFieldSchema: () => ChargesQueryFieldSchema,
-  ConfirmEmailChangeSchema: () => ConfirmEmailChangeSchema,
-  CreateApiKeySchema: () => CreateApiKeySchema,
   CreateChargeSchema: () => CreateChargeSchema,
   CreateWebhookSchema: () => CreateWebhookSchema,
   DistributionsDateFieldSchema: () => DistributionsDateFieldSchema,
@@ -51,62 +43,40 @@ __export(index_exports, {
   EVM_NETWORKS: () => EVM_NETWORKS,
   EnvironmentSchema: () => EnvironmentSchema,
   ErrorPayloadSchema: () => ErrorPayloadSchema,
-  ForgotPasswordSchema: () => ForgotPasswordSchema,
   GetChargeQrCodeQuerySchema: () => GetChargeQrCodeQuerySchema,
   HealthSchema: () => HealthSchema,
-  InvitationSchema: () => InvitationSchema,
-  InviteUserSchema: () => InviteUserSchema,
-  ListApiKeysSchema: () => ListApiKeysSchema,
   ListChargesSchema: () => ListChargesSchema,
-  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,
   METRICS_QUERY_MAX_FILTERS: () => METRICS_QUERY_MAX_FILTERS,
   METRICS_QUERY_MAX_GROUP_BY: () => METRICS_QUERY_MAX_GROUP_BY,
   METRICS_QUERY_MAX_METRICS: () => METRICS_QUERY_MAX_METRICS,
   METRICS_QUERY_MAX_ROW_LIMIT: () => METRICS_QUERY_MAX_ROW_LIMIT,
-  MessageResponseSchema: () => MessageResponseSchema,
   MetricsAggregationSchema: () => MetricsAggregationSchema,
   MetricsDateGranularitySchema: () => MetricsDateGranularitySchema,
   MetricsFilterOperatorSchema: () => MetricsFilterOperatorSchema,
   MetricsQueryResultRowSchema: () => MetricsQueryResultRowSchema,
   MetricsQueryResultSchema: () => MetricsQueryResultSchema,
   MetricsQuerySchema: () => MetricsQuerySchema,
-  MetricsQueryScopeSchema: () => MetricsQueryScopeSchema,
   MetricsResourceSchema: () => MetricsResourceSchema,
   NETWORK_EXPLORERS: () => NETWORK_EXPLORERS,
   NETWORK_LABELS: () => NETWORK_LABELS,
   NetworkSchema: () => NetworkSchema,
-  NonChargeTriggerableEventSchema: () => NonChargeTriggerableEventSchema,
-  NormalizedEmailSchema: () => NormalizedEmailSchema,
   OPERATIONAL_NETWORKS: () => OPERATIONAL_NETWORKS,
-  OrganizationSchema: () => OrganizationSchema,
-  OrganizationWithRoleSchema: () => OrganizationWithRoleSchema,
   PAGINATION_LIMIT_DEFAULT: () => PAGINATION_LIMIT_DEFAULT,
   PAGINATION_LIMIT_MAX: () => PAGINATION_LIMIT_MAX,
   PAGINATION_LIMIT_MIN: () => PAGINATION_LIMIT_MIN,
-  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,
-  SecurityWebhookEventTypeSchema: () => SecurityWebhookEventTypeSchema,
-  SelfUserSchema: () => SelfUserSchema,
   SettlementStatusSchema: () => SettlementStatusSchema,
-  SignupSchema: () => SignupSchema,
   SplitDistributionStatusSchema: () => SplitDistributionStatusSchema,
   TOKEN_ADDRESSES: () => TOKEN_ADDRESSES,
   TOKEN_DECIMALS: () => TOKEN_DECIMALS,
@@ -118,11 +88,6 @@ __export(index_exports, {
   TransactionsMetricFieldSchema: () => TransactionsMetricFieldSchema,
   TransactionsQueryFieldSchema: () => TransactionsQueryFieldSchema,
   TriggerableChargeEventSchema: () => TriggerableChargeEventSchema,
-  UpdateOrganizationSchema: () => UpdateOrganizationSchema,
-  UpdateUserRoleSchema: () => UpdateUserRoleSchema,
-  UserRoleSchema: () => UserRoleSchema,
-  UserSchema: () => UserSchema,
-  VerifyEmailSchema: () => VerifyEmailSchema,
   WEBHOOK_EVENTS_WILDCARD: () => WEBHOOK_EVENTS_WILDCARD,
   WEBHOOK_EVENT_CATEGORIES: () => WEBHOOK_EVENT_CATEGORIES,
   WebhookCategorySchema: () => WebhookCategorySchema,
@@ -142,7 +107,7 @@ var import_zod = require("zod");
 var ErrorPayloadSchema = import_zod.z.object({
   error: import_zod.z.object({
     code: import_zod.z.string().describe(
-      "A stable, machine-readable error identifier (e.g. `validation_error`, `invalid_credentials`)."
+      "A stable, machine-readable error identifier (e.g. `validation_error`, `charge_not_found`)."
     ),
     message: import_zod.z.string().describe(
       "Human-readable explanation, safe to log or show a developer \u2014 not meant for end users."
@@ -157,9 +122,27 @@ var EnvironmentSchema = import_zod2.z.enum(["live", "test"]).describe(
   "`live` or `test`, matching the `klap_live_.../klap_test_...` prefix of the API key that created or is scoped to this resource. `live` settles on Base mainnet with real funds; `test` settles on Base Sepolia, a separate testnet \u2014 real on-chain activity, but never real money."
 );
 
-// src/networks.ts
+// src/api-key-scopes.ts
 var import_zod3 = require("zod");
-var NetworkSchema = import_zod3.z.enum(["base", "optimism", "polygon", "ethereum", "arbitrum", "avalanche", "bnb"]).describe("The blockchain a charge/payment is on.");
+var ApiKeyScopeSchema = import_zod3.z.enum([
+  "charges:read",
+  "charges:write",
+  "webhooks:read",
+  "webhooks:write",
+  "webhooks:manage_secret",
+  "metrics:read",
+  "metrics:charges:read",
+  "metrics:transactions:read",
+  "metrics:distributions:read",
+  "sandbox:trigger"
+]).describe(
+  "What an API key is allowed to do, independent of `tenantId`/`environment` (which scope *whose* data, not *what actions*). A key with none of these can still authenticate but every scoped route rejects it with `403 insufficient_scope`. `metrics:read` alone grants every metrics resource; `metrics:{resource}:read` grants only that one \u2014 a key can hold either or both."
+);
+var API_KEY_SCOPES = ApiKeyScopeSchema.options;
+
+// src/networks.ts
+var import_zod4 = require("zod");
+var NetworkSchema = import_zod4.z.enum(["base", "optimism", "polygon", "ethereum", "arbitrum", "avalanche", "bnb"]).describe("The blockchain a charge/payment is on.");
 var NETWORK_LABELS = {
   base: "Base",
   optimism: "Optimism",
@@ -198,29 +181,29 @@ var OPERATIONAL_NETWORKS = [
 ];
 
 // src/pagination.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var PAGINATION_LIMIT_MIN = 1;
 var PAGINATION_LIMIT_MAX = 100;
 var PAGINATION_LIMIT_DEFAULT = 20;
-var PaginationQuerySchema = import_zod4.z.object({
-  limit: import_zod4.z.coerce.number().min(PAGINATION_LIMIT_MIN).max(PAGINATION_LIMIT_MAX).default(PAGINATION_LIMIT_DEFAULT).describe(
+var PaginationQuerySchema = import_zod5.z.object({
+  limit: import_zod5.z.coerce.number().min(PAGINATION_LIMIT_MIN).max(PAGINATION_LIMIT_MAX).default(PAGINATION_LIMIT_DEFAULT).describe(
     `Max items to return per page (${PAGINATION_LIMIT_MIN}\u2013${PAGINATION_LIMIT_MAX}, default ${PAGINATION_LIMIT_DEFAULT}).`
   ),
-  cursor: import_zod4.z.string().max(500).optional().describe(
+  cursor: import_zod5.z.string().max(500).optional().describe(
     "Opaque \u2014 pass the previous response's `nextCursor` verbatim to fetch the next page. Never construct or parse this value yourself; its shape is not part of the public contract and may change."
   )
 });
 function paginatedSchema(itemSchema) {
-  return import_zod4.z.object({
-    data: import_zod4.z.array(itemSchema),
-    nextCursor: import_zod4.z.string().nullable().describe("Pass as `cursor` to fetch the next page. `null` when there are no more results."),
-    hasMore: import_zod4.z.boolean()
+  return import_zod5.z.object({
+    data: import_zod5.z.array(itemSchema),
+    nextCursor: import_zod5.z.string().nullable().describe("Pass as `cursor` to fetch the next page. `null` when there are no more results."),
+    hasMore: import_zod5.z.boolean()
   });
 }
 
 // src/tokens.ts
-var import_zod5 = require("zod");
-var TokenSchema = import_zod5.z.enum(["USDC", "USDT"]).describe(
+var import_zod6 = require("zod");
+var TokenSchema = import_zod6.z.enum(["USDC", "USDT"]).describe(
   `Which stablecoin the payer will send. Support depends on both \`network\` and \`environment\` \u2014 not every token/network/environment combination is deployed; today, both \`USDC\` and \`USDT\` are deployed on every operational network's \`live\` side except BNB Chain (\`${OPERATIONAL_NETWORKS.join(", ")}\`), but \`test\` coverage varies per network \u2014 Base, Optimism, and Ethereum each have a \`test\` environment (\`USDC\` only; none has an official Sepolia USDT), Arbitrum, Polygon, Avalanche, and BNB Chain have none yet (0xSplits hasn't deployed on Arbitrum Sepolia and has no Polygon, Avalanche Fuji, or BNB testnet support at all). An unconfigured combination is rejected with \`422 token_not_supported\`, not silently accepted. **BNB Chain's \`USDC\` address is Binance-Peg USDC, not an official Circle deployment** \u2014 Circle does not issue native USDC on BNB Chain at all; this is a Binance-custodied, 1:1-pegged BEP-20 token, a materially different trust model than every other \`TOKEN_ADDRESSES\` entry (all verified directly against their real issuer). Accepted at the payer's own risk \u2014 Klappay does not verify or guarantee Binance's collateral backing it. \`USDT\` on BNB Chain is Tether's own official issuance, same trust model as everywhere else. More tokens/networks are expected to be added over time \u2014 check \`TOKEN_ADDRESSES\` in \`@klappay/types\` (or a future \`GET /v1/networks\` capabilities endpoint) for the exact current matrix rather than assuming full coverage.`
 );
 var TOKEN_DECIMALS = 6;
@@ -255,30 +238,27 @@ var TOKEN_ADDRESSES = {
 };
 
 // src/charges.ts
-var import_zod6 = require("zod");
-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 import_zod7 = require("zod");
+var ChargeStatusSchema = import_zod7.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_zod6.z.enum(["pending", "completed", "failed"]).describe(
+var SettlementStatusSchema = import_zod7.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 ChargeModeSchema = import_zod6.z.enum(["standard", "continuous"]).describe(
-  "`standard` (default): the usual lifecycle \u2014 accumulates transfers toward one resolution (`confirmed`/`expired`/`underpaid`), settles once. `continuous`: never resolves \u2014 `status` stays `pending` for the charge's entire life, and every credited transfer settles independently instead of accumulating toward one confirmation (see `charge.contribution_received`/`charge.contribution_settled`). Requires both `amount` and `expiresIn` to be omitted \u2014 there's no goal to accumulate toward and no deadline for something meant to run indefinitely (a link in a creator's bio, a permanent collection address). Not inferred from omitting those two fields \u2014 an explicit, deliberate choice, since silently changing a charge's entire settlement lifecycle based on which optional fields happened to be left out would be a footgun."
-);
 var CHARGE_EXPIRES_IN_MIN_SECONDS = 60;
-var CHARGE_EXPIRES_IN_MAX_SECONDS = 365 * 24 * 60 * 60;
+var CHARGE_EXPIRES_IN_MAX_SECONDS = 3600;
 var CHARGE_ACCEPTED_PAYMENTS_MAX = 14;
-var AcceptedPaymentSchema = import_zod6.z.object({
+var AcceptedPaymentSchema = import_zod7.z.object({
   token: TokenSchema,
   network: NetworkSchema
 });
-var AcceptedPaymentsSchema = import_zod6.z.array(AcceptedPaymentSchema).min(1, "At least one accepted payment is required.").max(CHARGE_ACCEPTED_PAYMENTS_MAX).superRefine((pairs, ctx) => {
+var AcceptedPaymentsSchema = import_zod7.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_zod6.z.ZodIssueCode.custom,
+        code: import_zod7.z.ZodIssueCode.custom,
         message: `Duplicate accepted payment: ${pair.token} on ${pair.network}.`,
         path: [index]
       });
@@ -286,7 +266,7 @@ var AcceptedPaymentsSchema = import_zod6.z.array(AcceptedPaymentSchema).min(1, "
     seen.add(key);
     if (!OPERATIONAL_NETWORKS.includes(pair.network)) {
       ctx.addIssue({
-        code: import_zod6.z.ZodIssueCode.custom,
+        code: import_zod7.z.ZodIssueCode.custom,
         message: `Network "${pair.network}" isn't live yet \u2014 only ${OPERATIONAL_NETWORKS.join(", ")} today.`,
         path: [index, "network"]
       });
@@ -296,88 +276,77 @@ var AcceptedPaymentsSchema = import_zod6.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_AMOUNT_MAX = 999999999999;
-var CreateChargeSchema = import_zod6.z.object({
-  mode: ChargeModeSchema.default("standard"),
-  amount: import_zod6.z.number().positive().max(CHARGE_AMOUNT_MAX).optional().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. Omit entirely for a charge that accepts any amount \u2014 the first credited transfer of any size confirms it, and `isOverpaid` never applies (there is no target to exceed)."
+var CreateChargeSchema = import_zod7.z.object({
+  amount: import_zod7.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_zod6.z.literal("USD").default("USD").describe("Always `USD` today \u2014 the only supported currency."),
+  currency: import_zod7.z.literal("USD").default("USD").describe("Always `USD` today \u2014 the only supported currency."),
   acceptedPayments: AcceptedPaymentsSchema,
-  expiresIn: import_zod6.z.number().int().min(CHARGE_EXPIRES_IN_MIN_SECONDS).max(CHARGE_EXPIRES_IN_MAX_SECONDS).optional().describe(
-    "Seconds, not minutes or milliseconds \u2014 how long the charge stays open, min 60, max 31,536,000 = 365 days. Omit entirely for a charge that never expires (`expiresAt` is `null`) \u2014 useful for donations, investments, or any charge with no natural deadline. Cannot be extended or shortened after creation either way."
+  expiresIn: import_zod7.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_zod6.z.string().min(1).max(255).optional().describe(
-    "Scoped to your organization. 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."
+  idempotencyKey: import_zod7.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_zod6.z.string().min(1).max(255).optional().describe(
+  externalRef: import_zod7.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_zod6.z.string().min(1).max(64).optional().describe(
+  source: import_zod7.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: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional().describe("Arbitrary key/value data to attach to the charge, returned as-is on every read.")
-}).superRefine((input, ctx) => {
-  if (input.mode === "continuous" && (input.amount !== void 0 || input.expiresIn !== void 0)) {
-    ctx.addIssue({
-      code: import_zod6.z.ZodIssueCode.custom,
-      message: 'mode: "continuous" requires both amount and expiresIn to be omitted.',
-      path: ["mode"]
-    });
-  }
+  metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional().describe("Arbitrary key/value data to attach to the charge, returned as-is on every read."),
+  redirectUrl: import_zod7.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."
+  )
 });
-var ChargeSchema = import_zod6.z.object({
-  id: import_zod6.z.string().describe("Klappay-generated id, e.g. `ch_...`. Use this to look up the charge later."),
-  mode: ChargeModeSchema,
-  amount: import_zod6.z.number().nullable().describe(
-    "The amount originally requested, in `currency` units (up to 6 decimal places). `null` if `amount` was omitted at creation \u2014 this charge accepts any amount, and the first credited transfer confirms it."
-  ),
-  amountReceived: import_zod6.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` \u2014 unless `amount` itself is `null`, in which case `isOverpaid` never applies."
+var ChargeSchema = import_zod7.z.object({
+  id: import_zod7.z.string().describe("Klappay-generated id, e.g. `ch_...`. Use this to look up the charge later."),
+  amount: import_zod7.z.number().describe("The amount originally requested, in `currency` units (up to 6 decimal places)."),
+  amountReceived: import_zod7.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_zod6.z.boolean().describe(
+  isOverpaid: import_zod7.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_zod6.z.string().describe("Always `USD` today \u2014 the only supported currency."),
-  acceptedPayments: import_zod6.z.array(AcceptedPaymentSchema).describe(
+  currency: import_zod7.z.string().describe("Always `USD` today \u2014 the only supported currency."),
+  acceptedPayments: import_zod7.z.array(AcceptedPaymentSchema).describe(
     "Every `(token, network)` pair this charge was configured to accept, unchanged after creation."
   ),
-  paidWith: import_zod6.z.array(AcceptedPaymentSchema).describe(
+  paidWith: import_zod7.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_zod6.z.string().describe(
+  address: import_zod7.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_zod6.z.string().nullable().describe(
+  apiKeyId: import_zod7.z.string().nullable().describe(
     "Which of your API keys created this charge. `null` for a charge created before this field existed."
   ),
-  txHash: import_zod6.z.string().nullable().describe(
+  txHash: import_zod7.z.string().nullable().describe(
     "Transaction hash of the most recent transfer detected for this charge. `null` until a payment is detected."
   ),
-  externalRef: import_zod6.z.string().nullable(),
-  source: import_zod6.z.string().nullable(),
-  metadata: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).nullable(),
-  createdAt: import_zod6.z.string().datetime(),
-  expiresAt: import_zod6.z.string().datetime().nullable().describe(
-    "When this charge stops accepting payment, if still `pending`/`partially_paid` by then. `null` if `expiresIn` was omitted at creation \u2014 the charge never expires on its own and must be dealt with manually (or left open indefinitely)."
+  externalRef: import_zod7.z.string().nullable(),
+  source: import_zod7.z.string().nullable(),
+  metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).nullable(),
+  redirectUrl: import_zod7.z.string().nullable().describe("Echoes the `redirectUrl` set at creation, if any. `null` if none was set."),
+  checkoutUrl: import_zod7.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."
   ),
-  confirmedAt: import_zod6.z.string().datetime().nullable().describe("When `status` first reached `confirmed`. `null` until then."),
-  settledAt: import_zod6.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_zod6.z.string().datetime().describe(
-    "When a transfer was last credited toward this charge, or `createdAt` if none has arrived yet. Only meaningful for a charge with no `expiresAt` \u2014 see `pausedAt`."
+  createdAt: import_zod7.z.string().datetime(),
+  expiresAt: import_zod7.z.string().datetime().describe(
+    "When this charge stops accepting payment, if still `pending`/`partially_paid` by then."
   ),
-  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."
+  confirmedAt: import_zod7.z.string().datetime().nullable().describe("When `status` first reached `confirmed`. `null` until then."),
+  settledAt: import_zod7.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`."
   ),
-  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."
+  lastActivityAt: import_zod7.z.string().datetime().describe(
+    "When a transfer was last credited toward this charge, or `createdAt` if none has arrived yet."
   )
 });
-var ListChargesSchema = import_zod6.z.object({
+var ListChargesSchema = import_zod7.z.object({
   status: ChargeStatusSchema.optional(),
   token: TokenSchema.optional().describe(
     "Filters on `paidWith.token` \u2014 the pair actually paid, not accepted."
@@ -386,47 +355,19 @@ var ListChargesSchema = import_zod6.z.object({
     "Filters on `paidWith.network` \u2014 the pair actually paid, not accepted."
   ),
   environment: EnvironmentSchema.optional(),
-  since: import_zod6.z.string().datetime().optional().describe(
+  since: import_zod7.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_zod6.z.enum(["true", "false"]).transform((v) => v === "true").optional()
+  isOverpaid: import_zod7.z.enum(["true", "false"]).transform((v) => v === "true").optional()
 }).extend(PaginationQuerySchema.shape);
 var PaginatedChargesSchema = paginatedSchema(ChargeSchema);
-var GetChargeQrCodeQuerySchema = import_zod6.z.object({
+var GetChargeQrCodeQuerySchema = import_zod7.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."
   ),
   network: NetworkSchema.optional()
 });
 
-// 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_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()
-});
-
 // src/distributions.ts
 var import_zod8 = require("zod");
 var SplitDistributionStatusSchema = import_zod8.z.enum(["pending", "processing", "completed", "failed"]).describe(
@@ -482,11 +423,11 @@ var MetricsAggregationSchema = import_zod9.z.enum(["count", "sum", "avg", "min",
 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_zod9.z.enum(["day", "week", "month"]).describe(
+var MetricsDateGranularitySchema = import_zod9.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(
-  "Which environment's data to query \u2014 `live` or `test`. Independent of your session (a dashboard user isn't scoped to one environment the way an API key is) \u2014 scopes the query to charges/transactions/distributions created under a `live` or `test` API key respectively."
+  "Which environment's data to query \u2014 `live` or `test`. Must match the environment of the API key used to authenticate \u2014 scopes the query to charges/transactions/distributions created under a `live` or `test` API key respectively."
 );
 var MAX_METRICS_QUERY_DATE_RANGE_DAYS = 366;
 var METRICS_QUERY_MAX_ROW_LIMIT = 1e3;
@@ -519,14 +460,14 @@ var orderBySchema = import_zod9.z.object({
 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_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 ChargesQueryFieldSchema = import_zod9.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_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_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 ChargesDateFieldSchema = import_zod9.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_zod9.z.object({
   field: ChargesQueryFieldSchema,
@@ -597,14 +538,14 @@ var TransactionsMetricsQuerySchema = import_zod9.z.object({
   orderBy: orderBySchema.optional(),
   limit: limitSchema
 });
-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 DistributionsQueryFieldSchema = import_zod9.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_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_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 DistributionsDateFieldSchema = import_zod9.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_zod9.z.object({
   field: DistributionsQueryFieldSchema,
@@ -701,15 +642,11 @@ 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_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_zod9.z.object({
   data: import_zod9.z.array(MetricsQueryResultRowSchema),
   meta: import_zod9.z.object({
     resource: MetricsResourceSchema,
     environment: EnvironmentSchema,
-    scope: MetricsQueryScopeSchema,
     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`."
@@ -727,86 +664,43 @@ var ChargeWebhookEventTypeSchema = import_zod10.z.enum([
   "charge.underpaid",
   "charge.settled",
   "charge.settlement_failed",
-  "charge.overpaid",
-  "charge.paused",
-  "charge.reactivated",
-  "charge.contribution_received",
-  "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`/`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_zod10.z.enum([
-  "payout_address.changed",
-  "api_key.created",
-  "api_key.revoked",
-  "webhook.created",
-  "webhook.deleted",
-  "webhook.secret_rotated",
-  "fee_tier.updated",
-  "member.removed",
-  "member.role_changed",
-  "member.invited"
+  "charge.overpaid"
 ]).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 }`."
+  '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_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_zod10.z.enum([
-  "auth.login",
-  "auth.login_failed",
-  "auth.suspicious_activity",
-  "auth.email_verified",
-  "auth.password_reset_requested",
-  "auth.password_reset_completed",
-  "auth.password_changed",
-  "auth.email_change_requested",
-  "auth.email_changed"
-]).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_zod10.z.union([
   ChargeWebhookEventTypeSchema,
-  AccountWebhookEventTypeSchema,
-  WebhookDeliveryEventTypeSchema,
-  SecurityWebhookEventTypeSchema
+  WebhookDeliveryEventTypeSchema
 ]);
-var WebhookCategorySchema = import_zod10.z.enum(["payments", "account", "webhooks", "security"]).describe(
+var WebhookCategorySchema = import_zod10.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() {
   const map = {};
   for (const event of ChargeWebhookEventTypeSchema.options) map[event] = "payments";
-  for (const event of AccountWebhookEventTypeSchema.options) map[event] = "account";
   for (const event of WebhookDeliveryEventTypeSchema.options) map[event] = "webhooks";
-  for (const event of SecurityWebhookEventTypeSchema.options) map[event] = "security";
+  for (const event of WebhookEventTypeSchema.options.flatMap((schema) => schema.options)) {
+    if (!(event in map)) {
+      throw new Error(
+        `buildCategoryMap: "${event}" has no category \u2014 a new event sub-schema was unioned into WebhookEventTypeSchema without a matching loop added here.`
+      );
+    }
+  }
   return map;
 }
 var EVENT_CATEGORY_MAP = buildCategoryMap();
 var WEBHOOK_EVENT_CATEGORIES = {
   payments: ChargeWebhookEventTypeSchema.options,
-  account: AccountWebhookEventTypeSchema.options,
-  webhooks: WebhookDeliveryEventTypeSchema.options,
-  security: SecurityWebhookEventTypeSchema.options
+  webhooks: WebhookDeliveryEventTypeSchema.options
 };
 var TriggerableChargeEventSchema = ChargeWebhookEventTypeSchema.exclude([
-  "charge.created",
-  "charge.paused",
-  "charge.reactivated",
-  "charge.contribution_received",
-  "charge.contribution_settled",
-  "charge.canceled",
-  "charge.paid_after_cancel"
+  "charge.created"
 ]).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), `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)."
+  "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)."
 );
-var NonChargeTriggerableEventSchema = import_zod10.z.union([
-  AccountWebhookEventTypeSchema,
-  WebhookDeliveryEventTypeSchema,
-  SecurityWebhookEventTypeSchema
-]);
 
 // src/webhooks.ts
 var import_zod11 = require("zod");
@@ -831,7 +725,7 @@ var CreateWebhookSchema = import_zod11.z.object({
 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."
+    "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_zod11.z.string(),
   events: import_zod11.z.array(WebhookEventTypeSchema),
@@ -853,7 +747,7 @@ var WebhookPayloadSchema = import_zod11.z.object({
   event: WebhookEventTypeSchema,
   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."
+    "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_zod11.z.enum(["pending", "delivered", "failed"]);
@@ -875,178 +769,27 @@ var WebhookDeliverySchema = import_zod11.z.object({
 var ListWebhookDeliveriesSchema = PaginationQuerySchema;
 var PaginatedWebhookDeliveriesSchema = paginatedSchema(WebhookDeliverySchema);
 
-// src/api-keys.ts
-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_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_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_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_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."
-  )
-});
-var ListApiKeysSchema = PaginationQuerySchema;
-var PaginatedApiKeysSchema = paginatedSchema(ApiKeySchema);
-
-// src/users.ts
-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_zod13.z.object({
-  role: UserRoleSchema
-});
-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_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_zod13.z.string().datetime()
-});
-var ListUsersSchema = PaginationQuerySchema;
-var PaginatedUsersSchema = paginatedSchema(UserSchema);
-
-// src/auth.ts
-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_zod14.z.object({
-  email: NormalizedEmailSchema,
-  password: import_zod14.z.string().min(8).max(128).describe("8-128 characters. No other complexity rule.")
-});
-var LoginSchema = import_zod14.z.object({
-  email: NormalizedEmailSchema,
-  password: import_zod14.z.string().min(1).max(128)
-});
-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_zod14.z.object({
-  email: NormalizedEmailSchema
-});
-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_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_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_zod14.z.object({
-  name: import_zod14.z.string().min(1).max(255).describe("Your display name.")
-});
-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_zod14.z.object({
-  currentPassword: import_zod14.z.string().min(1).max(128),
-  newEmail: NormalizedEmailSchema
-});
-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_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_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_zod15.z.string().datetime().nullable().describe(
-    "When `currentFeePercent` last changed. `null` if it has never changed since this organization signed up."
-  ),
-  createdAt: import_zod15.z.string().datetime()
-});
-var OrganizationWithRoleSchema = OrganizationSchema.extend({
-  role: UserRoleSchema.describe("Your own role within this specific organization.")
-});
-var PaginatedOrganizationsSchema = paginatedSchema(OrganizationWithRoleSchema);
-var ListOrganizationsSchema = PaginationQuerySchema;
-
-// src/invitations.ts
-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_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_zod16.z.object({
-  id: import_zod16.z.string(),
-  organizationId: import_zod16.z.string(),
-  email: import_zod16.z.string(),
-  role: UserRoleSchema,
-  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_zod17 = require("zod");
-var TransactionSourceSchema = import_zod17.z.enum(["moralis_webhook", "reconciliation_job", "sandbox"]).describe(
+var import_zod12 = require("zod");
+var TransactionSourceSchema = import_zod12.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_zod17.z.enum([
+var TimelineEventTypeSchema = import_zod12.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. `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)."
+  "`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_zod17.z.object({
+var TimelineEventSchema = import_zod12.z.object({
   type: TimelineEventTypeSchema,
-  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(
+  at: import_zod12.z.string().datetime(),
+  txHash: import_zod12.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
+  amount: import_zod12.z.number().optional().describe(
     "Present for `transaction.detected` events only \u2014 the amount that specific transfer carried."
   ),
   source: TransactionSourceSchema.optional().describe(
@@ -1058,81 +801,68 @@ var TimelineEventSchema = import_zod17.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_zod17.z.boolean().optional().describe(
+  causedTransition: import_zod12.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_zod17.z.number().nullable().optional().describe(
+  responseCode: import_zod12.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_zod17.z.number().optional().describe(
+  attempts: import_zod12.z.number().optional().describe(
     "Present for `webhook.*` events only \u2014 how many delivery attempts have been made so far."
   )
 });
 
 // src/health.ts
-var import_zod18 = require("zod");
-var HealthSchema = import_zod18.z.object({
-  status: import_zod18.z.enum(["ok", "error"]).describe(
+var import_zod13 = require("zod");
+var HealthSchema = import_zod13.z.object({
+  status: import_zod13.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_zod18.z.string(),
-  timestamp: import_zod18.z.string().datetime(),
-  db: import_zod18.z.enum(["ok", "error"]).describe("Result of a real database connectivity check, not just a process-alive check."),
-  pendingWebhooks: import_zod18.z.number().describe("Count of webhook deliveries still awaiting a successful attempt."),
-  oldestPendingChargeAgeSeconds: import_zod18.z.number().nullable().describe("Age of the oldest still-unpaid charge, in seconds. `null` if there are none."),
-  lastMoralisEventAgeSeconds: import_zod18.z.number().nullable().describe(
+  version: import_zod13.z.string(),
+  timestamp: import_zod13.z.string().datetime(),
+  db: import_zod13.z.enum(["ok", "error"]).describe("Result of a real database connectivity check, not just a process-alive check."),
+  pendingWebhooks: import_zod13.z.number().describe("Count of webhook deliveries still awaiting a successful attempt."),
+  oldestPendingChargeAgeSeconds: import_zod13.z.number().nullable().describe("Age of the oldest still-unpaid charge, in seconds. `null` if there are none."),
+  lastMoralisEventAgeSeconds: import_zod13.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_zod19 = require("zod");
-var SandboxTriggerSchema = import_zod19.z.object({
+var import_zod14 = require("zod");
+var SandboxTriggerSchema = import_zod14.z.object({
   event: TriggerableChargeEventSchema,
-  amount: import_zod19.z.number().positive().max(CHARGE_AMOUNT_MAX).optional().describe(
+  amount: import_zod14.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."
   )
 });
-var SandboxEventTriggerSchema = import_zod19.z.object({
-  event: NonChargeTriggerableEventSchema.describe(
-    "Any account, security, or webhook-delivery event \u2014 simulates it with synthetic data against your own webhooks, no real state change or precondition required (unlike `POST /v1/sandbox/charges/{id}/trigger`, which acts on a real charge)."
-  )
-});
 
 // src/capabilities.ts
-var import_zod20 = require("zod");
-var CapabilitiesSchema = import_zod20.z.object({
-  acceptedPayments: import_zod20.z.array(AcceptedPaymentSchema).describe(
+var import_zod15 = require("zod");
+var CapabilitiesSchema = import_zod15.z.object({
+  acceptedPayments: import_zod15.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."
   )
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AcceptInvitationSchema,
+  API_KEY_SCOPES,
   AcceptedPaymentSchema,
-  AccountWebhookEventTypeSchema,
-  ApiKeySchema,
-  AuthResponseSchema,
+  ApiKeyScopeSchema,
   CHARGE_ACCEPTED_PAYMENTS_MAX,
   CHARGE_AMOUNT_MAX,
   CHARGE_EXPIRES_IN_MAX_SECONDS,
   CHARGE_EXPIRES_IN_MIN_SECONDS,
   CapabilitiesSchema,
-  ChangeEmailSchema,
-  ChangeNameSchema,
-  ChangePasswordSchema,
-  ChargeModeSchema,
   ChargeSchema,
   ChargeStatusSchema,
   ChargeWebhookEventTypeSchema,
   ChargesDateFieldSchema,
   ChargesMetricFieldSchema,
   ChargesQueryFieldSchema,
-  ConfirmEmailChangeSchema,
-  CreateApiKeySchema,
   CreateChargeSchema,
   CreateWebhookSchema,
   DistributionsDateFieldSchema,
@@ -1142,62 +872,40 @@ var CapabilitiesSchema = import_zod20.z.object({
   EVM_NETWORKS,
   EnvironmentSchema,
   ErrorPayloadSchema,
-  ForgotPasswordSchema,
   GetChargeQrCodeQuerySchema,
   HealthSchema,
-  InvitationSchema,
-  InviteUserSchema,
-  ListApiKeysSchema,
   ListChargesSchema,
-  ListOrganizationsSchema,
-  ListUsersSchema,
   ListWebhookDeliveriesSchema,
   ListenPendingDistributionsQuerySchema,
-  LoginSchema,
   MAX_METRICS_QUERY_DATE_RANGE_DAYS,
   METRICS_QUERY_DEFAULT_ROW_LIMIT,
   METRICS_QUERY_MAX_FILTERS,
   METRICS_QUERY_MAX_GROUP_BY,
   METRICS_QUERY_MAX_METRICS,
   METRICS_QUERY_MAX_ROW_LIMIT,
-  MessageResponseSchema,
   MetricsAggregationSchema,
   MetricsDateGranularitySchema,
   MetricsFilterOperatorSchema,
   MetricsQueryResultRowSchema,
   MetricsQueryResultSchema,
   MetricsQuerySchema,
-  MetricsQueryScopeSchema,
   MetricsResourceSchema,
   NETWORK_EXPLORERS,
   NETWORK_LABELS,
   NetworkSchema,
-  NonChargeTriggerableEventSchema,
-  NormalizedEmailSchema,
   OPERATIONAL_NETWORKS,
-  OrganizationSchema,
-  OrganizationWithRoleSchema,
   PAGINATION_LIMIT_DEFAULT,
   PAGINATION_LIMIT_MAX,
   PAGINATION_LIMIT_MIN,
-  PaginatedApiKeysSchema,
   PaginatedChargesSchema,
-  PaginatedOrganizationsSchema,
   PaginatedPendingDistributionsSchema,
-  PaginatedUsersSchema,
   PaginatedWebhookDeliveriesSchema,
   PaginationQuerySchema,
   PendingDistributionEventSchema,
   PendingDistributionRecipientSchema,
   PendingDistributionSchema,
-  PublicChargeSchema,
-  ResetPasswordSchema,
-  SandboxEventTriggerSchema,
   SandboxTriggerSchema,
-  SecurityWebhookEventTypeSchema,
-  SelfUserSchema,
   SettlementStatusSchema,
-  SignupSchema,
   SplitDistributionStatusSchema,
   TOKEN_ADDRESSES,
   TOKEN_DECIMALS,
@@ -1209,11 +917,6 @@ var CapabilitiesSchema = import_zod20.z.object({
   TransactionsMetricFieldSchema,
   TransactionsQueryFieldSchema,
   TriggerableChargeEventSchema,
-  UpdateOrganizationSchema,
-  UpdateUserRoleSchema,
-  UserRoleSchema,
-  UserSchema,
-  VerifyEmailSchema,
   WEBHOOK_EVENTS_WILDCARD,
   WEBHOOK_EVENT_CATEGORIES,
   WebhookCategorySchema,