@strimz/shared-types 0.1.0

package/dist/events.cjs

@@ -0,0 +1,675 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/events.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"
+});
+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");
+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" });
+zod.z.string().length(2).regex(/^[A-Z]{2}$/, "must be an ISO-3166 alpha-2 country code");
+zod.z.object({
+  limit: zod.z.number().int().min(1).max(100).default(25),
+  cursor: zod.z.string().min(1).max(200).nullish()
+});
+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"]);
+zod.z.enum(["USDC", "EURC", "USYC"]);
+zod.z.enum(["free", "growth", "business", "enterprise"]);
+zod.z.enum(["testnet", "mainnet"]);
+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
+});
+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()
+});
+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"]);
+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
+});
+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
+});
+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()
+});
+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()
+});
+zod.z.object({
+  transactionId: idSchema,
+  amount: tokenAmountSchema,
+  reason: refundReasonSchema,
+  note: zod.z.string().max(500).optional()
+});
+zod.z.object({
+  id: idSchema,
+  refundTxHash: evmTxHashSchema
+});
+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
+});
+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)
+});
+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
+});
+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()
+});
+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 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 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
+});
+zod.z.object({
+  url: httpsUrlSchema,
+  events: zod.z.array(webhookEventNameSchema).nonempty(),
+  description: zod.z.string().max(200).optional(),
+  mode: modeSchema
+});
+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"
+]);
+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
+});
+zod.z.object({
+  id: idSchema
+});
+
+// src/events.ts
+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
+]);
+
+exports.agentActionExecutedEventSchema = agentActionExecutedEventSchema;
+exports.agentJobCompletedEventSchema = agentJobCompletedEventSchema;
+exports.agentJobDisputedEventSchema = agentJobDisputedEventSchema;
+exports.agentJobProposedEventSchema = agentJobProposedEventSchema;
+exports.complianceWalletBlockedEventSchema = complianceWalletBlockedEventSchema;
+exports.complianceWalletFlaggedEventSchema = complianceWalletFlaggedEventSchema;
+exports.invoiceCreatedEventSchema = invoiceCreatedEventSchema;
+exports.invoiceOverdueEventSchema = invoiceOverdueEventSchema;
+exports.invoicePaidEventSchema = invoicePaidEventSchema;
+exports.paymentCompletedEventSchema = paymentCompletedEventSchema;
+exports.paymentCreatedEventSchema = paymentCreatedEventSchema;
+exports.paymentFailedEventSchema = paymentFailedEventSchema;
+exports.refundCompletedEventSchema = refundCompletedEventSchema;
+exports.refundCreatedEventSchema = refundCreatedEventSchema;
+exports.refundFailedEventSchema = refundFailedEventSchema;
+exports.subscriptionCancelledEventSchema = subscriptionCancelledEventSchema;
+exports.subscriptionChargeFailedEventSchema = subscriptionChargeFailedEventSchema;
+exports.subscriptionChargedEventSchema = subscriptionChargedEventSchema;
+exports.subscriptionCreatedEventSchema = subscriptionCreatedEventSchema;
+exports.subscriptionLapsedEventSchema = subscriptionLapsedEventSchema;
+exports.subscriptionRecoveryAttemptEventSchema = subscriptionRecoveryAttemptEventSchema;
+exports.subscriptionRecoveryOutcomeEventSchema = subscriptionRecoveryOutcomeEventSchema;
+exports.webhookEventNameSchema = webhookEventNameSchema;
+exports.webhookEventSchema = webhookEventSchema;
+//# sourceMappingURL=events.cjs.map
+//# sourceMappingURL=events.cjs.map