@strimz/shared-types 0.1.0

package/dist/index.cjs

@@ -0,0 +1,976 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/common.ts
+var idSchema = zod.z.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/, "id must be URL-safe");
+var evmAddressSchema = zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "must be a 0x-prefixed 40-character hex EVM address").transform((v) => v.toLowerCase());
+var evmTxHashSchema = zod.z.string().regex(/^0x[a-fA-F0-9]{64}$/, "must be a 0x-prefixed 64-character hex EVM transaction hash");
+var emailSchema = zod.z.string().email().trim().toLowerCase().max(320);
+var httpsUrlSchema = zod.z.string().url().refine((v) => v.startsWith("https://"), {
+  message: "must be an https:// URL"
+});
+var httpUrlSchema = zod.z.string().url();
+var tokenAmountSchema = zod.z.string().regex(/^[0-9]+$/, "must be a non-negative integer string (base-10)").refine((v) => BigInt(v) >= 0n, "must be >= 0");
+var uintSchema = zod.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var isoTimestampSchema = zod.z.string().datetime({ offset: true, message: "must be an ISO-8601 timestamp" });
+var countryCodeSchema = zod.z.string().length(2).regex(/^[A-Z]{2}$/, "must be an ISO-3166 alpha-2 country code");
+var paginationInputSchema = zod.z.object({
+  limit: zod.z.number().int().min(1).max(100).default(25),
+  cursor: zod.z.string().min(1).max(200).nullish()
+});
+var makePaginatedSchema = (item) => zod.z.object({
+  data: zod.z.array(item),
+  nextCursor: zod.z.string().nullable(),
+  hasMore: zod.z.boolean()
+});
+var metadataSchema = zod.z.record(
+  zod.z.string().min(1).max(40),
+  zod.z.union([zod.z.string().max(500), zod.z.number(), zod.z.boolean(), zod.z.null()])
+).refine((m) => Object.keys(m).length <= 50, "at most 50 metadata keys").default({});
+var modeSchema = zod.z.enum(["test", "live"]);
+var paymentCurrencySchema = zod.z.enum(["USDC", "EURC"]);
+var tokenSymbolSchema = zod.z.enum(["USDC", "EURC", "USYC"]);
+var merchantTierSchema = zod.z.enum(["free", "growth", "business", "enterprise"]);
+var arcEnvironmentSchema = zod.z.enum(["testnet", "mainnet"]);
+var merchantStatusSchema = zod.z.enum(["active", "suspended", "closed"]);
+var merchantRoleSchema = zod.z.enum(["owner", "admin", "developer", "read_only"]);
+var merchantSchema = zod.z.object({
+  id: idSchema,
+  onchainMerchantId: zod.z.number().int().nonnegative().nullable(),
+  businessName: zod.z.string().min(2).max(120),
+  email: emailSchema,
+  tier: merchantTierSchema,
+  status: merchantStatusSchema,
+  payoutAddress: evmAddressSchema.nullable(),
+  defaultCurrency: zod.z.enum(["USDC", "EURC"]),
+  countryCode: zod.z.string().length(2).nullable(),
+  websiteUrl: zod.z.string().url().nullable(),
+  logoUrl: zod.z.string().url().nullable(),
+  whitelabelEnabled: zod.z.boolean(),
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createMerchantInputSchema = zod.z.object({
+  businessName: zod.z.string().min(2).max(120),
+  email: emailSchema,
+  password: zod.z.string().min(12).max(128),
+  countryCode: zod.z.string().length(2).optional(),
+  websiteUrl: zod.z.string().url().optional()
+});
+var updateMerchantInputSchema = zod.z.object({
+  businessName: zod.z.string().min(2).max(120),
+  payoutAddress: evmAddressSchema,
+  defaultCurrency: zod.z.enum(["USDC", "EURC"]),
+  websiteUrl: zod.z.string().url().nullable(),
+  logoUrl: zod.z.string().url().nullable(),
+  countryCode: zod.z.string().length(2).nullable(),
+  metadata: metadataSchema
+}).partial();
+var changeTierInputSchema = zod.z.object({
+  tier: merchantTierSchema
+});
+var merchantMemberSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  email: emailSchema,
+  role: merchantRoleSchema,
+  invitedAt: isoTimestampSchema,
+  acceptedAt: isoTimestampSchema.nullable()
+});
+var inviteMemberInputSchema = zod.z.object({
+  email: emailSchema,
+  role: merchantRoleSchema
+});
+var loginInputSchema = zod.z.object({
+  email: emailSchema,
+  password: zod.z.string().min(1).max(128)
+});
+var loginOutputSchema = zod.z.object({
+  accessToken: zod.z.string(),
+  refreshToken: zod.z.string(),
+  merchant: merchantSchema
+});
+var apiKeyKindSchema = zod.z.enum(["secret", "publishable"]);
+var apiKeyScopeSchema = zod.z.enum([
+  "sessions_read",
+  "sessions_write",
+  "subscriptions_read",
+  "subscriptions_write",
+  "refunds_read",
+  "refunds_write",
+  "transactions_read",
+  "webhooks_read",
+  "webhooks_write",
+  "invoices_read",
+  "invoices_write",
+  "storefronts_read",
+  "storefronts_write",
+  "agents_read",
+  "agents_write",
+  // Meta-tx relayer — submitting payer-signed EIP-3009 / EIP-2612
+  // authorizations on the merchant's behalf. Granted to keys used by
+  // hosted checkout and merchants embedding the SDK.
+  "relay_read",
+  "relay_write"
+]);
+var apiKeySchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  name: zod.z.string().min(1).max(60),
+  kind: apiKeyKindSchema,
+  mode: modeSchema,
+  prefix: zod.z.string().min(8).max(24),
+  lastFour: zod.z.string().length(4),
+  scopes: zod.z.array(apiKeyScopeSchema).nonempty(),
+  createdAt: isoTimestampSchema,
+  lastUsedAt: isoTimestampSchema.nullable(),
+  revokedAt: isoTimestampSchema.nullable()
+});
+var createApiKeyInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(60),
+  kind: apiKeyKindSchema,
+  mode: modeSchema,
+  scopes: zod.z.array(apiKeyScopeSchema).nonempty()
+});
+var createApiKeyOutputSchema = zod.z.object({
+  apiKey: apiKeySchema,
+  /** Full plaintext key — shown exactly once. */
+  secret: zod.z.string()
+});
+var rotateApiKeyInputSchema = zod.z.object({
+  id: idSchema
+});
+var customerSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  walletAddress: evmAddressSchema,
+  email: emailSchema.nullable(),
+  /** Merchant-provided external identifier (e.g. their own user id). */
+  externalRef: zod.z.string().min(1).max(120).nullable(),
+  displayName: zod.z.string().min(1).max(120).nullable(),
+  metadata: metadataSchema,
+  firstSeenAt: isoTimestampSchema,
+  lastSeenAt: isoTimestampSchema
+});
+var upsertCustomerInputSchema = zod.z.object({
+  walletAddress: evmAddressSchema,
+  email: emailSchema.optional(),
+  externalRef: zod.z.string().min(1).max(120).optional(),
+  displayName: zod.z.string().min(1).max(120).optional(),
+  metadata: metadataSchema.optional()
+});
+var paymentSessionStatusSchema = zod.z.enum([
+  "created",
+  "awaiting_payment",
+  "submitted",
+  "confirmed",
+  "failed",
+  "expired",
+  "cancelled"
+]);
+var paymentSessionSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  /**
+   * On-chain StrimzRegistry merchant id (uint96) as a decimal string.
+   * Set when the merchant has been registered on-chain; null when the
+   * merchant exists in our DB but the registry transaction hasn't
+   * been broadcast yet. Hosted checkout uses this to populate the
+   * meta-tx calldata; if null, the checkout refuses to accept
+   * payments.
+   */
+  chainMerchantId: zod.z.string().regex(/^[0-9]+$/u, "must be a non-negative decimal integer string").nullable(),
+  /**
+   * ERC-20 token contract address resolved from `currency` on the
+   * active chain (Arc Testnet / Mainnet). Used as the `verifyingContract`
+   * in the EIP-712 domain for both EIP-3009 and EIP-2612 signing.
+   * Null on the (vanishingly unlikely) path where the API has no
+   * configured address for the session's currency.
+   */
+  tokenAddress: evmAddressSchema.nullable(),
+  customerId: idSchema.nullable(),
+  status: paymentSessionStatusSchema,
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  feeAmount: tokenAmountSchema,
+  netAmount: tokenAmountSchema,
+  description: zod.z.string().max(500).nullable(),
+  payerWalletAddress: evmAddressSchema.nullable(),
+  payerEmail: zod.z.string().email().nullable(),
+  successUrl: zod.z.string().url().nullable(),
+  cancelUrl: zod.z.string().url().nullable(),
+  sourceChain: zod.z.enum(["arc", "ethereum", "base", "polygon", "arbitrum", "optimism", "avalanche", "solana"]).nullable(),
+  bridgeTxHash: evmTxHashSchema.nullable(),
+  onchainTxHash: evmTxHashSchema.nullable(),
+  checkoutUrl: zod.z.string().url(),
+  metadata: metadataSchema,
+  expiresAt: isoTimestampSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createPaymentSessionInputSchema = zod.z.object({
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  description: zod.z.string().max(500).optional(),
+  customer: zod.z.object({
+    walletAddress: evmAddressSchema.optional(),
+    email: zod.z.string().email().optional(),
+    externalRef: zod.z.string().max(120).optional()
+  }).optional(),
+  successUrl: zod.z.string().url().optional(),
+  cancelUrl: zod.z.string().url().optional(),
+  /** Minutes until the session expires. Default 30, max 60*24 (one day). */
+  expiresInMinutes: zod.z.number().int().min(1).max(60 * 24).default(30),
+  /**
+   * Allowed source chains a payer can bridge USDC from via CCTP. Omit to
+   * accept every CCTP-supported chain.
+   */
+  supportedSourceChains: zod.z.array(
+    zod.z.enum(["arc", "ethereum", "base", "polygon", "arbitrum", "optimism", "avalanche", "solana"])
+  ).optional(),
+  metadata: metadataSchema.optional()
+});
+var submitPaymentSessionInputSchema = zod.z.object({
+  sourceChain: zod.z.enum([
+    "arc",
+    "ethereum",
+    "base",
+    "polygon",
+    "arbitrum",
+    "optimism",
+    "avalanche",
+    "solana"
+  ]),
+  onchainTxHash: evmTxHashSchema,
+  bridgeTxHash: evmTxHashSchema.optional(),
+  payerWalletAddress: evmAddressSchema
+});
+var transactionKindSchema = zod.z.enum([
+  "one_shot",
+  "subscription_charge",
+  "refund",
+  "invoice_payment",
+  "storefront_purchase"
+]);
+var transactionStatusSchema = zod.z.enum(["pending", "confirmed", "failed"]);
+var transactionSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  kind: transactionKindSchema,
+  status: transactionStatusSchema,
+  sessionId: idSchema.nullable(),
+  subscriptionId: idSchema.nullable(),
+  subscriptionChargeId: idSchema.nullable(),
+  refundId: idSchema.nullable(),
+  customerId: idSchema.nullable(),
+  amount: tokenAmountSchema,
+  feeAmount: tokenAmountSchema,
+  netAmount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  payerAddress: evmAddressSchema,
+  merchantAddress: evmAddressSchema,
+  onchainTxHash: evmTxHashSchema,
+  blockNumber: zod.z.number().int().nonnegative(),
+  blockTimestamp: isoTimestampSchema,
+  createdAt: isoTimestampSchema
+});
+var subscriptionIntervalSchema = zod.z.enum([
+  "daily",
+  "weekly",
+  "monthly",
+  "quarterly",
+  "yearly"
+]);
+var subscriptionPlanStatusSchema = zod.z.enum(["active", "archived"]);
+var subscriptionPlanSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  /**
+   * On-chain StrimzRegistry merchant id (uint96) as a decimal string.
+   * See `paymentSessionSchema.chainMerchantId`. Null when the merchant
+   * hasn't been registered on-chain yet — the hosted enrolment page
+   * refuses to take signatures in that state.
+   */
+  chainMerchantId: zod.z.string().regex(/^[0-9]+$/u, "must be a non-negative decimal integer string").nullable(),
+  /**
+   * ERC-20 token contract address resolved from `currency` — the
+   * EIP-2612 `verifyingContract` the wallet signs over.
+   */
+  tokenAddress: evmAddressSchema.nullable(),
+  /**
+   * Charge cadence in seconds, derived from `interval` + `intervalCount`
+   * so the meta-tx layer can pass a uint32 to StrimzSubscriptions
+   * without re-deriving the conversion on the client.
+   */
+  intervalSeconds: zod.z.number().int().positive(),
+  name: zod.z.string().min(1).max(120),
+  description: zod.z.string().max(500).nullable(),
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  interval: subscriptionIntervalSchema,
+  intervalCount: zod.z.number().int().min(1).max(365),
+  trialPeriodDays: zod.z.number().int().min(0).max(365).nullable(),
+  status: subscriptionPlanStatusSchema,
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createSubscriptionPlanInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(120),
+  description: zod.z.string().max(500).optional(),
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  interval: subscriptionIntervalSchema,
+  intervalCount: zod.z.number().int().min(1).max(365).default(1),
+  trialPeriodDays: zod.z.number().int().min(0).max(365).optional(),
+  metadata: metadataSchema.optional()
+});
+var subscriptionStatusSchema = zod.z.enum([
+  "trialing",
+  "active",
+  "at_risk",
+  "paused",
+  "cancelled",
+  "lapsed"
+]);
+var subscriptionSchema = zod.z.object({
+  id: idSchema,
+  onchainSubscriptionId: zod.z.number().int().nonnegative().nullable(),
+  merchantId: idSchema,
+  customerId: idSchema,
+  planId: idSchema,
+  status: subscriptionStatusSchema,
+  payerAddress: evmAddressSchema,
+  currency: paymentCurrencySchema,
+  amount: tokenAmountSchema,
+  interval: subscriptionIntervalSchema,
+  intervalCount: zod.z.number().int().min(1),
+  trialEndsAt: isoTimestampSchema.nullable(),
+  currentPeriodStartAt: isoTimestampSchema,
+  currentPeriodEndAt: isoTimestampSchema,
+  nextChargeAt: isoTimestampSchema.nullable(),
+  gracePeriodHours: zod.z.number().int().min(0).max(72),
+  cancelledAt: isoTimestampSchema.nullable(),
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createSubscriptionInputSchema = zod.z.object({
+  planId: idSchema,
+  customer: zod.z.object({
+    walletAddress: evmAddressSchema,
+    email: zod.z.string().email().optional(),
+    externalRef: zod.z.string().max(120).optional()
+  }),
+  gracePeriodHours: zod.z.union([zod.z.literal(24), zod.z.literal(48), zod.z.literal(72)]).default(48),
+  metadata: metadataSchema.optional()
+});
+var cancelSubscriptionInputSchema = zod.z.object({
+  id: idSchema,
+  reason: zod.z.string().max(500).optional()
+});
+var subscriptionChargeOutcomeSchema = zod.z.enum([
+  "charged",
+  "insufficient_funds",
+  "revoked_approval",
+  "cancelled",
+  "skipped"
+]);
+var subscriptionChargeStatusSchema = zod.z.enum([
+  "pending",
+  "in_flight",
+  "succeeded",
+  "failed",
+  "retrying",
+  "abandoned"
+]);
+var subscriptionChargeSchema = zod.z.object({
+  id: idSchema,
+  subscriptionId: idSchema,
+  merchantId: idSchema,
+  chargeAttemptId: zod.z.string().length(66, "must be a 32-byte 0x-prefixed hex string"),
+  periodStartAt: isoTimestampSchema,
+  periodEndAt: isoTimestampSchema,
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  status: subscriptionChargeStatusSchema,
+  outcome: subscriptionChargeOutcomeSchema.nullable(),
+  attemptNumber: zod.z.number().int().min(1),
+  scheduledAt: isoTimestampSchema,
+  executedAt: isoTimestampSchema.nullable(),
+  onchainTxHash: evmTxHashSchema.nullable(),
+  failureReason: zod.z.string().max(500).nullable(),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var refundReasonSchema = zod.z.enum([
+  "customer_request",
+  "product_issue",
+  "duplicate_charge",
+  "fraudulent",
+  "other"
+]);
+var refundStatusSchema = zod.z.enum([
+  "pending",
+  "awaiting_signature",
+  "submitted",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var refundSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  transactionId: idSchema,
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  reason: refundReasonSchema,
+  note: zod.z.string().max(500).nullable(),
+  status: refundStatusSchema,
+  payerAddress: evmAddressSchema,
+  refundTxHash: evmTxHashSchema.nullable(),
+  failureReason: zod.z.string().max(500).nullable(),
+  initiatedBy: idSchema,
+  createdAt: isoTimestampSchema,
+  completedAt: isoTimestampSchema.nullable()
+});
+var createRefundInputSchema = zod.z.object({
+  transactionId: idSchema,
+  amount: tokenAmountSchema,
+  reason: refundReasonSchema,
+  note: zod.z.string().max(500).optional()
+});
+var submitRefundSignatureInputSchema = zod.z.object({
+  id: idSchema,
+  refundTxHash: evmTxHashSchema
+});
+var webhookEventNameSchema = zod.z.enum([
+  "payment.created",
+  "payment.completed",
+  "payment.failed",
+  "subscription.created",
+  "subscription.charged",
+  "subscription.charge_failed",
+  "subscription.recovery_attempt",
+  "subscription.recovery_outcome",
+  "subscription.cancelled",
+  "subscription.lapsed",
+  "refund.created",
+  "refund.completed",
+  "refund.failed",
+  "invoice.created",
+  "invoice.paid",
+  "invoice.overdue",
+  "agent.action_executed",
+  "agent.job_proposed",
+  "agent.job_completed",
+  "agent.job_disputed",
+  "compliance.wallet_flagged",
+  "compliance.wallet_blocked"
+]);
+var webhookEndpointStatusSchema = zod.z.enum(["active", "disabled"]);
+var webhookEndpointSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  mode: modeSchema,
+  url: httpsUrlSchema,
+  description: zod.z.string().max(200).nullable(),
+  events: zod.z.array(webhookEventNameSchema).nonempty(),
+  status: webhookEndpointStatusSchema,
+  signingSecretPrefix: zod.z.string().min(4).max(12),
+  lastDeliveredAt: isoTimestampSchema.nullable(),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createWebhookEndpointInputSchema = zod.z.object({
+  url: httpsUrlSchema,
+  events: zod.z.array(webhookEventNameSchema).nonempty(),
+  description: zod.z.string().max(200).optional(),
+  mode: modeSchema
+});
+var createWebhookEndpointOutputSchema = zod.z.object({
+  endpoint: webhookEndpointSchema,
+  /** Full signing secret — shown exactly once. */
+  signingSecret: zod.z.string()
+});
+var webhookDeliveryStatusSchema = zod.z.enum([
+  "pending",
+  "delivered",
+  "retrying",
+  "permanently_failed"
+]);
+var webhookDeliverySchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  endpointId: idSchema,
+  eventId: idSchema,
+  eventName: webhookEventNameSchema,
+  status: webhookDeliveryStatusSchema,
+  attempt: zod.z.number().int().min(1).max(6),
+  responseCode: zod.z.number().int().min(100).max(599).nullable(),
+  responseMs: zod.z.number().int().min(0).nullable(),
+  lastError: zod.z.string().max(1e3).nullable(),
+  nextAttemptAt: isoTimestampSchema.nullable(),
+  deliveredAt: isoTimestampSchema.nullable(),
+  createdAt: isoTimestampSchema
+});
+var replayDeliveryInputSchema = zod.z.object({
+  id: idSchema
+});
+var complianceProviderSchema = zod.z.enum(["trm", "elliptic", "disabled"]);
+var complianceStatusSchema = zod.z.enum(["clear", "flagged", "blocked", "error"]);
+var complianceScreeningContextSchema = zod.z.enum([
+  "merchant_onboarding",
+  "payer_checkout",
+  "subscriber_signup",
+  "refund_recipient"
+]);
+var complianceLogSchema = zod.z.object({
+  id: idSchema,
+  walletAddress: evmAddressSchema,
+  provider: complianceProviderSchema,
+  status: complianceStatusSchema,
+  riskScore: zod.z.number().min(0).max(100).nullable(),
+  flags: zod.z.array(zod.z.string().max(120)).default([]),
+  context: complianceScreeningContextSchema,
+  merchantId: idSchema.nullable(),
+  sessionId: idSchema.nullable(),
+  subscriptionId: idSchema.nullable(),
+  providerRequestId: zod.z.string().max(200).nullable(),
+  createdAt: isoTimestampSchema
+});
+var agentIdentitySchema = zod.z.object({
+  id: idSchema,
+  /** ERC-8004 on-chain identity address. */
+  onchainAddress: evmAddressSchema,
+  /** Public key or agent credential digest, as emitted by ERC-8004. */
+  credentialDigest: zod.z.string().regex(/^0x[a-fA-F0-9]+$/),
+  name: zod.z.string().min(1).max(120),
+  version: zod.z.string().min(1).max(40),
+  reputationScore: zod.z.number().min(0).max(100).nullable(),
+  registeredAt: isoTimestampSchema
+});
+var agentCapabilitySchema = zod.z.enum([
+  "identity",
+  "recovery",
+  "routing",
+  "cashflow",
+  "commerce",
+  "pricing_intelligence"
+]);
+var agentMerchantConfigSchema = zod.z.object({
+  merchantId: idSchema,
+  enabledCapabilities: zod.z.array(agentCapabilitySchema).default([]),
+  recovery: zod.z.object({
+    gracePeriodHours: zod.z.union([zod.z.literal(24), zod.z.literal(48), zod.z.literal(72)]).default(48),
+    strategy: zod.z.enum(["once", "twice", "until_grace_ends"]).default("twice"),
+    notificationTemplate: zod.z.string().max(2e3).nullable()
+  }),
+  cashflow: zod.z.object({
+    digestEnabled: zod.z.boolean().default(false),
+    anomalySensitivity: zod.z.enum(["low", "medium", "high"]).default("medium"),
+    autoConvertToYield: zod.z.boolean().default(false),
+    minimumLiquidReserveCents: zod.z.number().int().nonnegative().default(1e5)
+  }),
+  commerce: zod.z.object({
+    requireHumanApprovalAboveUsdCents: zod.z.number().int().nonnegative().default(1e5),
+    approvedVendors: zod.z.array(evmAddressSchema).default([]),
+    monthlySpendCapUsdCents: zod.z.number().int().nonnegative().nullable()
+  }),
+  updatedAt: isoTimestampSchema
+});
+var updateAgentConfigInputSchema = agentMerchantConfigSchema.omit({ merchantId: true, updatedAt: true }).partial();
+var agentActionTypeSchema = zod.z.enum([
+  "recovery_notification_sent",
+  "recovery_retry_scheduled",
+  "recovery_retry_executed",
+  "recovery_abandoned",
+  "routing_bridge_initiated",
+  "routing_payment_completed",
+  "cashflow_digest_sent",
+  "cashflow_anomaly_flagged",
+  "cashflow_yield_converted",
+  "commerce_job_created",
+  "commerce_job_approved",
+  "commerce_job_completed",
+  "commerce_job_disputed"
+]);
+var agentActionOutcomeSchema = zod.z.enum(["success", "failure", "pending", "skipped"]);
+var agentActivityLogSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  capability: agentCapabilitySchema,
+  actionType: agentActionTypeSchema,
+  outcome: agentActionOutcomeSchema,
+  subscriptionId: idSchema.nullable(),
+  transactionId: idSchema.nullable(),
+  jobId: idSchema.nullable(),
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema
+});
+var agentJobStatusSchema = zod.z.enum([
+  "proposed",
+  "accepted",
+  "in_progress",
+  "delivered",
+  "approved",
+  "completed",
+  "disputed",
+  "cancelled"
+]);
+var agentJobSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  /** On-chain job id from StrimzAgentEscrow. */
+  onchainJobId: zod.z.number().int().nonnegative().nullable(),
+  vendorAddress: evmAddressSchema,
+  description: zod.z.string().min(1).max(2e3),
+  amount: tokenAmountSchema,
+  currency: zod.z.enum(["USDC", "EURC"]),
+  status: agentJobStatusSchema,
+  assessorAddress: evmAddressSchema,
+  deliverableHash: zod.z.string().regex(/^0x[a-fA-F0-9]+$/).nullable(),
+  escrowTxHash: evmTxHashSchema.nullable(),
+  releaseTxHash: evmTxHashSchema.nullable(),
+  createdAt: isoTimestampSchema,
+  completedAt: isoTimestampSchema.nullable()
+});
+var createAgentJobInputSchema = zod.z.object({
+  vendorAddress: evmAddressSchema,
+  description: zod.z.string().min(1).max(2e3),
+  amount: tokenAmountSchema,
+  currency: zod.z.enum(["USDC", "EURC"]),
+  assessorAddress: evmAddressSchema.optional()
+});
+var storefrontStatusSchema = zod.z.enum(["draft", "published", "archived"]);
+var storefrontSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  slug: zod.z.string().min(3).max(40).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be lowercase alphanumeric with hyphens"),
+  name: zod.z.string().min(2).max(120),
+  description: zod.z.string().max(2e3).nullable(),
+  logoUrl: httpsUrlSchema.nullable(),
+  coverImageUrl: httpsUrlSchema.nullable(),
+  accentColor: zod.z.string().regex(/^#[0-9a-fA-F]{6}$/).nullable(),
+  socialLinks: zod.z.array(httpsUrlSchema).max(10).default([]),
+  status: storefrontStatusSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createStorefrontInputSchema = storefrontSchema.pick({
+  slug: true,
+  name: true,
+  description: true,
+  logoUrl: true,
+  coverImageUrl: true,
+  accentColor: true,
+  socialLinks: true
+});
+var storefrontProductTypeSchema = zod.z.enum(["one_time", "subscription"]);
+var storefrontProductSchema = zod.z.object({
+  id: idSchema,
+  storefrontId: idSchema,
+  name: zod.z.string().min(1).max(120),
+  description: zod.z.string().max(2e3).nullable(),
+  imageUrl: httpsUrlSchema.nullable(),
+  price: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  type: storefrontProductTypeSchema,
+  interval: subscriptionIntervalSchema.nullable(),
+  intervalCount: zod.z.number().int().min(1).max(365).nullable(),
+  /** null = unlimited stock. */
+  stock: zod.z.number().int().min(0).nullable(),
+  planId: idSchema.nullable(),
+  isActive: zod.z.boolean(),
+  sortOrder: zod.z.number().int().nonnegative().default(0),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createStorefrontProductInputSchema = storefrontProductSchema.omit({
+  id: true,
+  storefrontId: true,
+  planId: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  imageUrl: httpsUrlSchema.optional()
+});
+var invoiceStatusSchema = zod.z.enum(["draft", "sent", "paid", "overdue", "void"]);
+var invoiceLineItemSchema = zod.z.object({
+  description: zod.z.string().min(1).max(500),
+  quantity: zod.z.number().int().min(1).max(1e4),
+  unitAmount: tokenAmountSchema
+});
+var invoiceSchema = zod.z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  number: zod.z.string().min(1).max(40),
+  customerName: zod.z.string().min(1).max(200).nullable(),
+  customerEmail: emailSchema.nullable(),
+  lineItems: zod.z.array(invoiceLineItemSchema).nonempty(),
+  subtotal: tokenAmountSchema,
+  total: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  status: invoiceStatusSchema,
+  note: zod.z.string().max(2e3).nullable(),
+  sessionId: idSchema.nullable(),
+  dueAt: isoTimestampSchema,
+  paidAt: isoTimestampSchema.nullable(),
+  sentAt: isoTimestampSchema.nullable(),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+});
+var createInvoiceInputSchema = zod.z.object({
+  customerName: zod.z.string().min(1).max(200).optional(),
+  customerEmail: emailSchema.optional(),
+  lineItems: zod.z.array(invoiceLineItemSchema).nonempty(),
+  currency: paymentCurrencySchema,
+  note: zod.z.string().max(2e3).optional(),
+  dueInDays: zod.z.number().int().min(1).max(90).default(7)
+});
+var envelope = (name, data) => zod.z.object({
+  id: idSchema,
+  type: zod.z.literal(name),
+  apiVersion: zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  mode: modeSchema,
+  createdAt: isoTimestampSchema,
+  data
+});
+var paymentCreatedEventSchema = envelope("payment.created", paymentSessionSchema);
+var paymentCompletedEventSchema = envelope(
+  "payment.completed",
+  zod.z.object({ session: paymentSessionSchema, transaction: transactionSchema })
+);
+var paymentFailedEventSchema = envelope(
+  "payment.failed",
+  zod.z.object({ session: paymentSessionSchema, reason: zod.z.string() })
+);
+var subscriptionCreatedEventSchema = envelope("subscription.created", subscriptionSchema);
+var subscriptionChargedEventSchema = envelope(
+  "subscription.charged",
+  zod.z.object({
+    subscription: subscriptionSchema,
+    charge: subscriptionChargeSchema,
+    transaction: transactionSchema
+  })
+);
+var subscriptionChargeFailedEventSchema = envelope(
+  "subscription.charge_failed",
+  zod.z.object({ subscription: subscriptionSchema, charge: subscriptionChargeSchema })
+);
+var subscriptionRecoveryAttemptEventSchema = envelope(
+  "subscription.recovery_attempt",
+  zod.z.object({ subscription: subscriptionSchema, attemptNumber: zod.z.number().int().min(1) })
+);
+var subscriptionRecoveryOutcomeEventSchema = envelope(
+  "subscription.recovery_outcome",
+  zod.z.object({
+    subscription: subscriptionSchema,
+    outcome: zod.z.enum(["recovered", "churned"])
+  })
+);
+var subscriptionCancelledEventSchema = envelope(
+  "subscription.cancelled",
+  subscriptionSchema
+);
+var subscriptionLapsedEventSchema = envelope("subscription.lapsed", subscriptionSchema);
+var refundCreatedEventSchema = envelope("refund.created", refundSchema);
+var refundCompletedEventSchema = envelope(
+  "refund.completed",
+  zod.z.object({ refund: refundSchema, transaction: transactionSchema })
+);
+var refundFailedEventSchema = envelope(
+  "refund.failed",
+  zod.z.object({ refund: refundSchema, reason: zod.z.string() })
+);
+var invoiceCreatedEventSchema = envelope("invoice.created", invoiceSchema);
+var invoicePaidEventSchema = envelope(
+  "invoice.paid",
+  zod.z.object({ invoice: invoiceSchema, transaction: transactionSchema })
+);
+var invoiceOverdueEventSchema = envelope("invoice.overdue", invoiceSchema);
+var agentActionExecutedEventSchema = envelope(
+  "agent.action_executed",
+  agentActivityLogSchema
+);
+var agentJobProposedEventSchema = envelope("agent.job_proposed", agentJobSchema);
+var agentJobCompletedEventSchema = envelope("agent.job_completed", agentJobSchema);
+var agentJobDisputedEventSchema = envelope("agent.job_disputed", agentJobSchema);
+var complianceWalletFlaggedEventSchema = envelope(
+  "compliance.wallet_flagged",
+  complianceLogSchema
+);
+var complianceWalletBlockedEventSchema = envelope(
+  "compliance.wallet_blocked",
+  complianceLogSchema
+);
+var webhookEventSchema = zod.z.discriminatedUnion("type", [
+  paymentCreatedEventSchema,
+  paymentCompletedEventSchema,
+  paymentFailedEventSchema,
+  subscriptionCreatedEventSchema,
+  subscriptionChargedEventSchema,
+  subscriptionChargeFailedEventSchema,
+  subscriptionRecoveryAttemptEventSchema,
+  subscriptionRecoveryOutcomeEventSchema,
+  subscriptionCancelledEventSchema,
+  subscriptionLapsedEventSchema,
+  refundCreatedEventSchema,
+  refundCompletedEventSchema,
+  refundFailedEventSchema,
+  invoiceCreatedEventSchema,
+  invoicePaidEventSchema,
+  invoiceOverdueEventSchema,
+  agentActionExecutedEventSchema,
+  agentJobProposedEventSchema,
+  agentJobCompletedEventSchema,
+  agentJobDisputedEventSchema,
+  complianceWalletFlaggedEventSchema,
+  complianceWalletBlockedEventSchema
+]);
+var addressSchema = zod.z.string().regex(/^0x[0-9a-fA-F]{40}$/u, "must be a 0x-prefixed 20-byte address");
+var tokenCapabilitiesSchema = zod.z.object({
+  permit2612: zod.z.boolean(),
+  transferAuth3009: zod.z.boolean()
+});
+var tokenMetadataSchema = zod.z.object({
+  address: addressSchema,
+  name: zod.z.string(),
+  symbol: zod.z.string(),
+  /**
+   * EIP-712 domain version. Read from ERC-5267 `eip712Domain()` when
+   * available; otherwise defaults to "1". Used by typed-data builders
+   * — domain mismatch produces a different digest and the contract's
+   * ecrecover would recover a different address.
+   */
+  version: zod.z.string(),
+  decimals: zod.z.number().int().min(0).max(255),
+  capabilities: tokenCapabilitiesSchema
+});
+var tokenPermitNonceSchema = zod.z.object({
+  token: addressSchema,
+  owner: addressSchema,
+  nonce: zod.z.string().regex(/^[0-9]+$/u, "must be a decimal integer string")
+});
+
+exports.agentActionExecutedEventSchema = agentActionExecutedEventSchema;
+exports.agentActionOutcomeSchema = agentActionOutcomeSchema;
+exports.agentActionTypeSchema = agentActionTypeSchema;
+exports.agentActivityLogSchema = agentActivityLogSchema;
+exports.agentCapabilitySchema = agentCapabilitySchema;
+exports.agentIdentitySchema = agentIdentitySchema;
+exports.agentJobCompletedEventSchema = agentJobCompletedEventSchema;
+exports.agentJobDisputedEventSchema = agentJobDisputedEventSchema;
+exports.agentJobProposedEventSchema = agentJobProposedEventSchema;
+exports.agentJobSchema = agentJobSchema;
+exports.agentJobStatusSchema = agentJobStatusSchema;
+exports.agentMerchantConfigSchema = agentMerchantConfigSchema;
+exports.apiKeyKindSchema = apiKeyKindSchema;
+exports.apiKeySchema = apiKeySchema;
+exports.apiKeyScopeSchema = apiKeyScopeSchema;
+exports.arcEnvironmentSchema = arcEnvironmentSchema;
+exports.cancelSubscriptionInputSchema = cancelSubscriptionInputSchema;
+exports.changeTierInputSchema = changeTierInputSchema;
+exports.complianceLogSchema = complianceLogSchema;
+exports.complianceProviderSchema = complianceProviderSchema;
+exports.complianceScreeningContextSchema = complianceScreeningContextSchema;
+exports.complianceStatusSchema = complianceStatusSchema;
+exports.complianceWalletBlockedEventSchema = complianceWalletBlockedEventSchema;
+exports.complianceWalletFlaggedEventSchema = complianceWalletFlaggedEventSchema;
+exports.countryCodeSchema = countryCodeSchema;
+exports.createAgentJobInputSchema = createAgentJobInputSchema;
+exports.createApiKeyInputSchema = createApiKeyInputSchema;
+exports.createApiKeyOutputSchema = createApiKeyOutputSchema;
+exports.createInvoiceInputSchema = createInvoiceInputSchema;
+exports.createMerchantInputSchema = createMerchantInputSchema;
+exports.createPaymentSessionInputSchema = createPaymentSessionInputSchema;
+exports.createRefundInputSchema = createRefundInputSchema;
+exports.createStorefrontInputSchema = createStorefrontInputSchema;
+exports.createStorefrontProductInputSchema = createStorefrontProductInputSchema;
+exports.createSubscriptionInputSchema = createSubscriptionInputSchema;
+exports.createSubscriptionPlanInputSchema = createSubscriptionPlanInputSchema;
+exports.createWebhookEndpointInputSchema = createWebhookEndpointInputSchema;
+exports.createWebhookEndpointOutputSchema = createWebhookEndpointOutputSchema;
+exports.customerSchema = customerSchema;
+exports.emailSchema = emailSchema;
+exports.evmAddressSchema = evmAddressSchema;
+exports.evmTxHashSchema = evmTxHashSchema;
+exports.httpUrlSchema = httpUrlSchema;
+exports.httpsUrlSchema = httpsUrlSchema;
+exports.idSchema = idSchema;
+exports.inviteMemberInputSchema = inviteMemberInputSchema;
+exports.invoiceCreatedEventSchema = invoiceCreatedEventSchema;
+exports.invoiceLineItemSchema = invoiceLineItemSchema;
+exports.invoiceOverdueEventSchema = invoiceOverdueEventSchema;
+exports.invoicePaidEventSchema = invoicePaidEventSchema;
+exports.invoiceSchema = invoiceSchema;
+exports.invoiceStatusSchema = invoiceStatusSchema;
+exports.isoTimestampSchema = isoTimestampSchema;
+exports.loginInputSchema = loginInputSchema;
+exports.loginOutputSchema = loginOutputSchema;
+exports.makePaginatedSchema = makePaginatedSchema;
+exports.merchantMemberSchema = merchantMemberSchema;
+exports.merchantRoleSchema = merchantRoleSchema;
+exports.merchantSchema = merchantSchema;
+exports.merchantStatusSchema = merchantStatusSchema;
+exports.merchantTierSchema = merchantTierSchema;
+exports.metadataSchema = metadataSchema;
+exports.modeSchema = modeSchema;
+exports.paginationInputSchema = paginationInputSchema;
+exports.paymentCompletedEventSchema = paymentCompletedEventSchema;
+exports.paymentCreatedEventSchema = paymentCreatedEventSchema;
+exports.paymentCurrencySchema = paymentCurrencySchema;
+exports.paymentFailedEventSchema = paymentFailedEventSchema;
+exports.paymentSessionSchema = paymentSessionSchema;
+exports.paymentSessionStatusSchema = paymentSessionStatusSchema;
+exports.refundCompletedEventSchema = refundCompletedEventSchema;
+exports.refundCreatedEventSchema = refundCreatedEventSchema;
+exports.refundFailedEventSchema = refundFailedEventSchema;
+exports.refundReasonSchema = refundReasonSchema;
+exports.refundSchema = refundSchema;
+exports.refundStatusSchema = refundStatusSchema;
+exports.replayDeliveryInputSchema = replayDeliveryInputSchema;
+exports.rotateApiKeyInputSchema = rotateApiKeyInputSchema;
+exports.storefrontProductSchema = storefrontProductSchema;
+exports.storefrontProductTypeSchema = storefrontProductTypeSchema;
+exports.storefrontSchema = storefrontSchema;
+exports.storefrontStatusSchema = storefrontStatusSchema;
+exports.submitPaymentSessionInputSchema = submitPaymentSessionInputSchema;
+exports.submitRefundSignatureInputSchema = submitRefundSignatureInputSchema;
+exports.subscriptionCancelledEventSchema = subscriptionCancelledEventSchema;
+exports.subscriptionChargeFailedEventSchema = subscriptionChargeFailedEventSchema;
+exports.subscriptionChargeOutcomeSchema = subscriptionChargeOutcomeSchema;
+exports.subscriptionChargeSchema = subscriptionChargeSchema;
+exports.subscriptionChargeStatusSchema = subscriptionChargeStatusSchema;
+exports.subscriptionChargedEventSchema = subscriptionChargedEventSchema;
+exports.subscriptionCreatedEventSchema = subscriptionCreatedEventSchema;
+exports.subscriptionIntervalSchema = subscriptionIntervalSchema;
+exports.subscriptionLapsedEventSchema = subscriptionLapsedEventSchema;
+exports.subscriptionPlanSchema = subscriptionPlanSchema;
+exports.subscriptionPlanStatusSchema = subscriptionPlanStatusSchema;
+exports.subscriptionRecoveryAttemptEventSchema = subscriptionRecoveryAttemptEventSchema;
+exports.subscriptionRecoveryOutcomeEventSchema = subscriptionRecoveryOutcomeEventSchema;
+exports.subscriptionSchema = subscriptionSchema;
+exports.subscriptionStatusSchema = subscriptionStatusSchema;
+exports.tokenAmountSchema = tokenAmountSchema;
+exports.tokenCapabilitiesSchema = tokenCapabilitiesSchema;
+exports.tokenMetadataSchema = tokenMetadataSchema;
+exports.tokenPermitNonceSchema = tokenPermitNonceSchema;
+exports.tokenSymbolSchema = tokenSymbolSchema;
+exports.transactionKindSchema = transactionKindSchema;
+exports.transactionSchema = transactionSchema;
+exports.transactionStatusSchema = transactionStatusSchema;
+exports.uintSchema = uintSchema;
+exports.updateAgentConfigInputSchema = updateAgentConfigInputSchema;
+exports.updateMerchantInputSchema = updateMerchantInputSchema;
+exports.upsertCustomerInputSchema = upsertCustomerInputSchema;
+exports.webhookDeliverySchema = webhookDeliverySchema;
+exports.webhookDeliveryStatusSchema = webhookDeliveryStatusSchema;
+exports.webhookEndpointSchema = webhookEndpointSchema;
+exports.webhookEndpointStatusSchema = webhookEndpointStatusSchema;
+exports.webhookEventNameSchema = webhookEventNameSchema;
+exports.webhookEventSchema = webhookEventSchema;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map