@klappay/types 2.0.3 → 3.0.0

package/dist/index.js

@@ -28,6 +28,8 @@ __export(index_exports, {
   CHARGE_EXPIRES_IN_MAX_SECONDS: () => CHARGE_EXPIRES_IN_MAX_SECONDS,
   CHARGE_EXPIRES_IN_MIN_SECONDS: () => CHARGE_EXPIRES_IN_MIN_SECONDS,
   CHARGE_SPLIT_RECIPIENTS_MAX: () => CHARGE_SPLIT_RECIPIENTS_MAX,
+  CHECKOUT_PRODUCTS_MAX: () => CHECKOUT_PRODUCTS_MAX,
+  CONFLICTING_SCOPE_PAIRS: () => CONFLICTING_SCOPE_PAIRS,
   CapabilitiesSchema: () => CapabilitiesSchema,
   ChargeSchema: () => ChargeSchema,
   ChargeStatusSchema: () => ChargeStatusSchema,
@@ -35,7 +37,9 @@ __export(index_exports, {
   ChargesDateFieldSchema: () => ChargesDateFieldSchema,
   ChargesMetricFieldSchema: () => ChargesMetricFieldSchema,
   ChargesQueryFieldSchema: () => ChargesQueryFieldSchema,
+  CheckoutProductSchema: () => CheckoutProductSchema,
   CreateChargeSchema: () => CreateChargeSchema,
+  CreateRecipientSchema: () => CreateRecipientSchema,
   CreateWebhookSchema: () => CreateWebhookSchema,
   DistributionsDateFieldSchema: () => DistributionsDateFieldSchema,
   DistributionsMetricFieldSchema: () => DistributionsMetricFieldSchema,
@@ -46,6 +50,7 @@ __export(index_exports, {
   ErrorPayloadSchema: () => ErrorPayloadSchema,
   GetChargeQrCodeQuerySchema: () => GetChargeQrCodeQuerySchema,
   HealthSchema: () => HealthSchema,
+  KlappayCheckoutMetadataSchema: () => KlappayCheckoutMetadataSchema,
   ListChargesSchema: () => ListChargesSchema,
   ListWebhookDeliveriesSchema: () => ListWebhookDeliveriesSchema,
   ListenPendingDistributionsQuerySchema: () => ListenPendingDistributionsQuerySchema,
@@ -55,6 +60,7 @@ __export(index_exports, {
   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,
+  MetadataWithKlappaySchema: () => MetadataWithKlappaySchema,
   MetricsAggregationSchema: () => MetricsAggregationSchema,
   MetricsDateGranularitySchema: () => MetricsDateGranularitySchema,
   MetricsFilterOperatorSchema: () => MetricsFilterOperatorSchema,
@@ -76,9 +82,12 @@ __export(index_exports, {
   PendingDistributionEventSchema: () => PendingDistributionEventSchema,
   PendingDistributionRecipientSchema: () => PendingDistributionRecipientSchema,
   PendingDistributionSchema: () => PendingDistributionSchema,
+  RecipientSchema: () => RecipientSchema,
   SandboxTriggerSchema: () => SandboxTriggerSchema,
+  SetRecipientPayoutSchema: () => SetRecipientPayoutSchema,
   SettlementStatusSchema: () => SettlementStatusSchema,
   SplitDistributionStatusSchema: () => SplitDistributionStatusSchema,
+  SplitRecipientInputSchema: () => SplitRecipientInputSchema,
   SplitRecipientSchema: () => SplitRecipientSchema,
   TOKEN_ADDRESSES: () => TOKEN_ADDRESSES,
   TOKEN_DECIMALS: () => TOKEN_DECIMALS,
@@ -100,6 +109,7 @@ __export(index_exports, {
   WebhookListItemSchema: () => WebhookListItemSchema,
   WebhookPayloadSchema: () => WebhookPayloadSchema,
   WebhookSchema: () => WebhookSchema,
+  findConflictingScopes: () => findConflictingScopes,
   paginatedSchema: () => paginatedSchema
 });
 module.exports = __toCommonJS(index_exports);
@@ -136,11 +146,26 @@ var ApiKeyScopeSchema = import_zod3.z.enum([
   "metrics:charges:read",
   "metrics:transactions:read",
   "metrics:distributions:read",
-  "sandbox:trigger"
+  "sandbox:trigger",
+  "charges:split_write",
+  "recipients:read",
+  "recipients:write",
+  "recipients:manage_payout"
 ]).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."
+  "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. `charges:split_write` is required on top of `charges:write` whenever a charge request includes `splitRecipients` \u2014 a key without it can create ordinary charges but never redirect part of the payout. `recipients:write` registers/revokes recipients (addresses eligible to be *referenced* in a split); `recipients:manage_payout` is separate and strictly more sensitive \u2014 it is what lets a recipient actually become an API key's `payoutAddress`, and should be granted only to a key that already went through out-of-band approval for that (Dashboard's own internal key, never a merchant-facing or third-party integration key like a marketplace's). `charges:split_write` can never be combined with `recipients:write`/`recipients:manage_payout` on the same key (see `CONFLICTING_SCOPE_PAIRS`) \u2014 Core rejects such a key outright, before any route runs."
 );
 var API_KEY_SCOPES = ApiKeyScopeSchema.options;
+var CONFLICTING_SCOPE_PAIRS = [
+  ["charges:split_write", "recipients:write"],
+  ["charges:split_write", "recipients:manage_payout"]
+];
+function findConflictingScopes(scopes) {
+  const held = new Set(scopes);
+  for (const [a, b] of CONFLICTING_SCOPE_PAIRS) {
+    if (held.has(a) && held.has(b)) return [a, b];
+  }
+  return null;
+}
 
 // src/networks.ts
 var import_zod4 = require("zod");
@@ -310,21 +335,31 @@ var SplitRecipientSchema = import_zod8.z.object({
     'Free-form label for your own bookkeeping (e.g. `"supplier"`, `"sales rep"`) \u2014 echoed back unchanged, never interpreted by Klappay.'
   )
 });
-var SplitRecipientsSchema = import_zod8.z.array(SplitRecipientSchema).max(CHARGE_SPLIT_RECIPIENTS_MAX).superRefine((recipients, ctx) => {
+var SplitRecipientInputSchema = import_zod8.z.object({
+  recipientId: import_zod8.z.string().describe(
+    "id of a `Recipient` you already registered via `POST /v1/recipients` (not a raw address) \u2014 see `recipients:write`/`charges:split_write` scopes. A leaked `charges:write`-only key can never redirect payout to a brand new address this way, only reference one already trusted."
+  ),
+  percent: import_zod8.z.number().positive().max(100).describe(
+    "Percent of *your own* net share (i.e. of `100 - feePercent`, not of the charge's gross `amount`) to route to this recipient instead of your own payout wallet. Klappay's fee is computed on the gross amount first and is never diluted by how you choose to split what's left \u2014 see `docs/payments.md`'s \"Settling the payout\" section for the exact math."
+  ),
+  label: import_zod8.z.string().min(1).max(64).optional().describe(
+    'Free-form label for your own bookkeeping (e.g. `"supplier"`, `"sales rep"`) \u2014 echoed back unchanged, never interpreted by Klappay. Independent of the label the recipient was registered with.'
+  )
+});
+var SplitRecipientsInputSchema = import_zod8.z.array(SplitRecipientInputSchema).max(CHARGE_SPLIT_RECIPIENTS_MAX).superRefine((recipients, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   recipients.forEach((recipient, index) => {
-    const key = recipient.address.toLowerCase();
-    if (seen.has(key)) {
+    if (seen.has(recipient.recipientId)) {
       ctx.addIssue({
         code: import_zod8.z.ZodIssueCode.custom,
-        message: `Duplicate split recipient address: ${recipient.address}.`,
-        path: [index, "address"]
+        message: `Duplicate split recipientId: ${recipient.recipientId}.`,
+        path: [index, "recipientId"]
       });
     }
-    seen.add(key);
+    seen.add(recipient.recipientId);
   });
 }).describe(
-  `Optional extra recipients for this charge's split \u2014 e.g. a supplier or the sales rep who closed the deal \u2014 up to ${CHARGE_SPLIT_RECIPIENTS_MAX}. Frozen at creation exactly like everything else that shapes the split address; cannot be changed afterward. The sum of every \`percent\` here must fit within \`100 - feePercent\` (your own net share) \u2014 a request that doesn't is rejected with \`422 split_recipients_exceed_available_percent\`.`
+  `Optional extra recipients for this charge's split \u2014 e.g. a supplier or the sales rep who closed the deal \u2014 up to ${CHARGE_SPLIT_RECIPIENTS_MAX}, each referenced by \`recipientId\` (see \`POST /v1/recipients\`), never a raw address. Requires the \`charges:split_write\` scope in addition to \`charges:write\`. Frozen at creation exactly like everything else that shapes the split address; cannot be changed afterward. The sum of every \`percent\` here must fit within \`100 - feePercent\` (your own net share) \u2014 a request that doesn't is rejected with \`422 split_recipients_exceed_available_percent\`.`
 );
 var CHARGE_AMOUNT_MAX = 999999999999;
 var CreateChargeSchema = import_zod8.z.object({
@@ -349,7 +384,7 @@ var CreateChargeSchema = import_zod8.z.object({
   redirectUrl: import_zod8.z.string().url().refine((value) => /^https?:\/\//.test(value), "must use http or https").optional().describe(
     "Where to send the payer once this charge resolves, if you use Klappay's hosted checkout page (see `checkoutUrl` on the read shape) \u2014 ignored otherwise. Must be `http(s)` \u2014 a browser will navigate here, so `javascript:`/`data:` and other non-navigational schemes are rejected. Otherwise not validated beyond being well-formed; what happens at that destination is yours to build."
   ),
-  splitRecipients: SplitRecipientsSchema.optional()
+  splitRecipients: SplitRecipientsInputSchema.optional()
 });
 var ChargeSchema = import_zod8.z.object({
   id: import_zod8.z.string().describe("Klappay-generated id, e.g. `ch_...`. Use this to look up the charge later."),
@@ -822,12 +857,35 @@ var WebhookDeliverySchema = import_zod12.z.object({
 var ListWebhookDeliveriesSchema = PaginationQuerySchema;
 var PaginatedWebhookDeliveriesSchema = paginatedSchema(WebhookDeliverySchema);
 
-// src/timeline.ts
+// src/recipients.ts
 var import_zod13 = require("zod");
-var TransactionSourceSchema = import_zod13.z.enum(["moralis_webhook", "reconciliation_job", "sandbox"]).describe(
+var EVM_ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+var CreateRecipientSchema = import_zod13.z.object({
+  address: import_zod13.z.string().regex(EVM_ADDRESS_REGEX, "must be a 20-byte hex address").describe("EVM address to register as a trusted split recipient for your organization."),
+  label: import_zod13.z.string().min(1).max(64).optional().describe('Free-form label for your own bookkeeping (e.g. `"supplier"`) \u2014 never interpreted.')
+});
+var RecipientSchema = import_zod13.z.object({
+  id: import_zod13.z.string().describe(
+    "Klappay-generated id, e.g. `rc_...` \u2014 this, not the raw address, is what a charge's `splitRecipients[].recipientId` references."
+  ),
+  environment: EnvironmentSchema,
+  address: import_zod13.z.string(),
+  label: import_zod13.z.string().nullable(),
+  payout: import_zod13.z.boolean().describe(
+    "Whether this recipient is eligible to be used as an API key's `payoutAddress` (in addition to being referenceable in a split, which every non-revoked recipient already is). Set via `PATCH /v1/recipients/{id}` \u2014 requires the `recipients:manage_payout` scope, deliberately separate from `recipients:write`."
+  ),
+  createdAt: import_zod13.z.string().datetime()
+});
+var SetRecipientPayoutSchema = import_zod13.z.object({
+  payout: import_zod13.z.boolean().describe("New payout-eligibility value for this recipient.")
+});
+
+// src/timeline.ts
+var import_zod14 = require("zod");
+var TransactionSourceSchema = import_zod14.z.enum(["moralis_webhook", "reconciliation_job", "sandbox"]).describe(
   "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_zod13.z.enum([
+var TimelineEventTypeSchema = import_zod14.z.enum([
   "charge.created",
   "charge.expired",
   "transaction.detected",
@@ -838,11 +896,11 @@ var TimelineEventTypeSchema = import_zod13.z.enum([
 ]).describe(
   "`charge.created`: the charge was created. `charge.expired`: `expiresAt` passed with no full payment. `transaction.detected`: a raw on-chain transfer was seen (see the `event`-shaped fields below for details \u2014 a charge can have more than one, e.g. a partial payment followed by the rest). `split.distributed`: a payout to the merchant completed on-chain, for one contributing `(token, network)` pair \u2014 a charge settled across more than one pair emits one of these per pair (see the `token`/`network` fields below). `webhook.dispatched`/`webhook.delivered`/`webhook.failed`: one specific delivery *attempt* for one webhook subscription \u2014 `failed` here means this single attempt failed, not that all retries were exhausted (see `WebhookDeliveryStatusSchema` for the exhausted-all-retries state)."
 );
-var TimelineEventSchema = import_zod13.z.object({
+var TimelineEventSchema = import_zod14.z.object({
   type: TimelineEventTypeSchema,
-  at: import_zod13.z.string().datetime(),
-  txHash: import_zod13.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
-  amount: import_zod13.z.number().optional().describe(
+  at: import_zod14.z.string().datetime(),
+  txHash: import_zod14.z.string().optional().describe("Present for `transaction.detected` and `split.distributed` events only."),
+  amount: import_zod14.z.number().optional().describe(
     "Present for `transaction.detected` events only \u2014 the amount that specific transfer carried."
   ),
   source: TransactionSourceSchema.optional().describe(
@@ -854,49 +912,49 @@ var TimelineEventSchema = import_zod13.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_zod13.z.boolean().optional().describe(
+  causedTransition: import_zod14.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_zod13.z.number().nullable().optional().describe(
+  responseCode: import_zod14.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_zod13.z.number().optional().describe(
+  attempts: import_zod14.z.number().optional().describe(
     "Present for `webhook.*` events only \u2014 how many delivery attempts have been made so far."
   )
 });
 
 // src/health.ts
-var import_zod14 = require("zod");
-var HealthSchema = import_zod14.z.object({
-  status: import_zod14.z.enum(["ok", "error"]).describe(
+var import_zod15 = require("zod");
+var HealthSchema = import_zod15.z.object({
+  status: import_zod15.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_zod14.z.string(),
-  timestamp: import_zod14.z.string().datetime(),
-  db: import_zod14.z.enum(["ok", "error"]).describe("Result of a real database connectivity check, not just a process-alive check."),
-  pendingWebhooks: import_zod14.z.number().describe("Count of webhook deliveries still awaiting a successful attempt."),
-  oldestPendingChargeAgeSeconds: import_zod14.z.number().nullable().describe("Age of the oldest still-unpaid charge, in seconds. `null` if there are none."),
-  lastMoralisEventAgeSeconds: import_zod14.z.number().nullable().describe(
+  version: import_zod15.z.string(),
+  timestamp: import_zod15.z.string().datetime(),
+  db: import_zod15.z.enum(["ok", "error"]).describe("Result of a real database connectivity check, not just a process-alive check."),
+  pendingWebhooks: import_zod15.z.number().describe("Count of webhook deliveries still awaiting a successful attempt."),
+  oldestPendingChargeAgeSeconds: import_zod15.z.number().nullable().describe("Age of the oldest still-unpaid charge, in seconds. `null` if there are none."),
+  lastMoralisEventAgeSeconds: import_zod15.z.number().nullable().describe(
     "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_zod15 = require("zod");
-var SandboxTriggerSchema = import_zod15.z.object({
+var import_zod16 = require("zod");
+var SandboxTriggerSchema = import_zod16.z.object({
   event: TriggerableChargeEventSchema,
-  amount: import_zod15.z.number().positive().max(CHARGE_AMOUNT_MAX).optional().describe(
+  amount: import_zod16.z.number().positive().max(CHARGE_AMOUNT_MAX).optional().describe(
     "Used with `charge.partially_paid` (amount to simulate as received so far \u2014 must be less than the charge amount, defaults to half of it if omitted) and with `charge.overpaid` (amount received \u2014 must be greater than the charge amount, defaults to 1.5x it if omitted). Ignored for every other event."
   )
 });
 
 // src/capabilities.ts
-var import_zod16 = require("zod");
-var CapabilitiesSchema = import_zod16.z.object({
-  acceptedPayments: import_zod16.z.array(AcceptedPaymentSchema).describe(
+var import_zod17 = require("zod");
+var CapabilitiesSchema = import_zod17.z.object({
+  acceptedPayments: import_zod17.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."
   )
 });
@@ -910,6 +968,8 @@ var CapabilitiesSchema = import_zod16.z.object({
   CHARGE_EXPIRES_IN_MAX_SECONDS,
   CHARGE_EXPIRES_IN_MIN_SECONDS,
   CHARGE_SPLIT_RECIPIENTS_MAX,
+  CHECKOUT_PRODUCTS_MAX,
+  CONFLICTING_SCOPE_PAIRS,
   CapabilitiesSchema,
   ChargeSchema,
   ChargeStatusSchema,
@@ -917,7 +977,9 @@ var CapabilitiesSchema = import_zod16.z.object({
   ChargesDateFieldSchema,
   ChargesMetricFieldSchema,
   ChargesQueryFieldSchema,
+  CheckoutProductSchema,
   CreateChargeSchema,
+  CreateRecipientSchema,
   CreateWebhookSchema,
   DistributionsDateFieldSchema,
   DistributionsMetricFieldSchema,
@@ -928,6 +990,7 @@ var CapabilitiesSchema = import_zod16.z.object({
   ErrorPayloadSchema,
   GetChargeQrCodeQuerySchema,
   HealthSchema,
+  KlappayCheckoutMetadataSchema,
   ListChargesSchema,
   ListWebhookDeliveriesSchema,
   ListenPendingDistributionsQuerySchema,
@@ -937,6 +1000,7 @@ var CapabilitiesSchema = import_zod16.z.object({
   METRICS_QUERY_MAX_GROUP_BY,
   METRICS_QUERY_MAX_METRICS,
   METRICS_QUERY_MAX_ROW_LIMIT,
+  MetadataWithKlappaySchema,
   MetricsAggregationSchema,
   MetricsDateGranularitySchema,
   MetricsFilterOperatorSchema,
@@ -958,9 +1022,12 @@ var CapabilitiesSchema = import_zod16.z.object({
   PendingDistributionEventSchema,
   PendingDistributionRecipientSchema,
   PendingDistributionSchema,
+  RecipientSchema,
   SandboxTriggerSchema,
+  SetRecipientPayoutSchema,
   SettlementStatusSchema,
   SplitDistributionStatusSchema,
+  SplitRecipientInputSchema,
   SplitRecipientSchema,
   TOKEN_ADDRESSES,
   TOKEN_DECIMALS,
@@ -982,6 +1049,7 @@ var CapabilitiesSchema = import_zod16.z.object({
   WebhookListItemSchema,
   WebhookPayloadSchema,
   WebhookSchema,
+  findConflictingScopes,
   paginatedSchema
 });
 //# sourceMappingURL=index.js.map