@strimz/shared-types 0.1.0

package/src/payment-sessions.ts

@@ -0,0 +1,131 @@
+/**
+ * Payment session — a one-shot checkout intent.
+ *
+ * State machine:
+ *   created → awaiting_payment → submitted → confirmed
+ *                                       \
+ *                                        → failed
+ *                               → expired
+ *                               → cancelled
+ */
+
+import { z } from 'zod'
+import {
+  evmAddressSchema,
+  evmTxHashSchema,
+  idSchema,
+  isoTimestampSchema,
+  metadataSchema,
+  paymentCurrencySchema,
+  tokenAmountSchema,
+} from './common.js'
+
+export const paymentSessionStatusSchema = z.enum([
+  'created',
+  'awaiting_payment',
+  'submitted',
+  'confirmed',
+  'failed',
+  'expired',
+  'cancelled',
+])
+export type PaymentSessionStatus = z.infer<typeof paymentSessionStatusSchema>
+
+export const paymentSessionSchema = 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: 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: z.string().max(500).nullable(),
+  payerWalletAddress: evmAddressSchema.nullable(),
+  payerEmail: z.string().email().nullable(),
+  successUrl: z.string().url().nullable(),
+  cancelUrl: z.string().url().nullable(),
+  sourceChain: z
+    .enum(['arc', 'ethereum', 'base', 'polygon', 'arbitrum', 'optimism', 'avalanche', 'solana'])
+    .nullable(),
+  bridgeTxHash: evmTxHashSchema.nullable(),
+  onchainTxHash: evmTxHashSchema.nullable(),
+  checkoutUrl: z.string().url(),
+  metadata: metadataSchema,
+  expiresAt: isoTimestampSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type PaymentSession = z.infer<typeof paymentSessionSchema>
+
+// ---------- DTOs ----------
+
+export const createPaymentSessionInputSchema = z.object({
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  description: z.string().max(500).optional(),
+  customer: z
+    .object({
+      walletAddress: evmAddressSchema.optional(),
+      email: z.string().email().optional(),
+      externalRef: z.string().max(120).optional(),
+    })
+    .optional(),
+  successUrl: z.string().url().optional(),
+  cancelUrl: z.string().url().optional(),
+  /** Minutes until the session expires. Default 30, max 60*24 (one day). */
+  expiresInMinutes: 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: z
+    .array(
+      z.enum(['arc', 'ethereum', 'base', 'polygon', 'arbitrum', 'optimism', 'avalanche', 'solana']),
+    )
+    .optional(),
+  metadata: metadataSchema.optional(),
+})
+export type CreatePaymentSessionInput = z.infer<typeof createPaymentSessionInputSchema>
+
+export const submitPaymentSessionInputSchema = z.object({
+  sourceChain: z.enum([
+    'arc',
+    'ethereum',
+    'base',
+    'polygon',
+    'arbitrum',
+    'optimism',
+    'avalanche',
+    'solana',
+  ]),
+  onchainTxHash: evmTxHashSchema,
+  bridgeTxHash: evmTxHashSchema.optional(),
+  payerWalletAddress: evmAddressSchema,
+})
+export type SubmitPaymentSessionInput = z.infer<typeof submitPaymentSessionInputSchema>

package/src/refunds.ts

@@ -0,0 +1,68 @@
+/**
+ * Refund — a merchant-initiated return of funds to a payer.
+ *
+ * Refunds are executed off-chain (from the merchant's wallet to the payer's
+ * wallet). Strimz records the intent, validates constraints, and reconciles
+ * via the merchant-signed on-chain transfer.
+ */
+
+import { z } from 'zod'
+import {
+  evmAddressSchema,
+  evmTxHashSchema,
+  idSchema,
+  isoTimestampSchema,
+  paymentCurrencySchema,
+  tokenAmountSchema,
+} from './common.js'
+
+export const refundReasonSchema = z.enum([
+  'customer_request',
+  'product_issue',
+  'duplicate_charge',
+  'fraudulent',
+  'other',
+])
+export type RefundReason = z.infer<typeof refundReasonSchema>
+
+export const refundStatusSchema = z.enum([
+  'pending',
+  'awaiting_signature',
+  'submitted',
+  'completed',
+  'failed',
+  'cancelled',
+])
+export type RefundStatus = z.infer<typeof refundStatusSchema>
+
+export const refundSchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  transactionId: idSchema,
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  reason: refundReasonSchema,
+  note: z.string().max(500).nullable(),
+  status: refundStatusSchema,
+  payerAddress: evmAddressSchema,
+  refundTxHash: evmTxHashSchema.nullable(),
+  failureReason: z.string().max(500).nullable(),
+  initiatedBy: idSchema,
+  createdAt: isoTimestampSchema,
+  completedAt: isoTimestampSchema.nullable(),
+})
+export type Refund = z.infer<typeof refundSchema>
+
+export const createRefundInputSchema = z.object({
+  transactionId: idSchema,
+  amount: tokenAmountSchema,
+  reason: refundReasonSchema,
+  note: z.string().max(500).optional(),
+})
+export type CreateRefundInput = z.infer<typeof createRefundInputSchema>
+
+export const submitRefundSignatureInputSchema = z.object({
+  id: idSchema,
+  refundTxHash: evmTxHashSchema,
+})
+export type SubmitRefundSignatureInput = z.infer<typeof submitRefundSignatureInputSchema>

package/src/storefronts.ts

@@ -0,0 +1,89 @@
+/**
+ * Storefronts — hosted product catalog with checkout baked in.
+ */
+
+import { z } from 'zod'
+import {
+  httpsUrlSchema,
+  idSchema,
+  isoTimestampSchema,
+  paymentCurrencySchema,
+  tokenAmountSchema,
+} from './common.js'
+import { subscriptionIntervalSchema } from './subscriptions.js'
+
+export const storefrontStatusSchema = z.enum(['draft', 'published', 'archived'])
+export type StorefrontStatus = z.infer<typeof storefrontStatusSchema>
+
+export const storefrontSchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  slug: z
+    .string()
+    .min(3)
+    .max(40)
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'slug must be lowercase alphanumeric with hyphens'),
+  name: z.string().min(2).max(120),
+  description: z.string().max(2000).nullable(),
+  logoUrl: httpsUrlSchema.nullable(),
+  coverImageUrl: httpsUrlSchema.nullable(),
+  accentColor: z
+    .string()
+    .regex(/^#[0-9a-fA-F]{6}$/)
+    .nullable(),
+  socialLinks: z.array(httpsUrlSchema).max(10).default([]),
+  status: storefrontStatusSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type Storefront = z.infer<typeof storefrontSchema>
+
+export const createStorefrontInputSchema = storefrontSchema.pick({
+  slug: true,
+  name: true,
+  description: true,
+  logoUrl: true,
+  coverImageUrl: true,
+  accentColor: true,
+  socialLinks: true,
+})
+export type CreateStorefrontInput = z.infer<typeof createStorefrontInputSchema>
+
+// ---------- Products ----------
+
+export const storefrontProductTypeSchema = z.enum(['one_time', 'subscription'])
+export type StorefrontProductType = z.infer<typeof storefrontProductTypeSchema>
+
+export const storefrontProductSchema = z.object({
+  id: idSchema,
+  storefrontId: idSchema,
+  name: z.string().min(1).max(120),
+  description: z.string().max(2000).nullable(),
+  imageUrl: httpsUrlSchema.nullable(),
+  price: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  type: storefrontProductTypeSchema,
+  interval: subscriptionIntervalSchema.nullable(),
+  intervalCount: z.number().int().min(1).max(365).nullable(),
+  /** null = unlimited stock. */
+  stock: z.number().int().min(0).nullable(),
+  planId: idSchema.nullable(),
+  isActive: z.boolean(),
+  sortOrder: z.number().int().nonnegative().default(0),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type StorefrontProduct = z.infer<typeof storefrontProductSchema>
+
+export const createStorefrontProductInputSchema = storefrontProductSchema
+  .omit({
+    id: true,
+    storefrontId: true,
+    planId: true,
+    createdAt: true,
+    updatedAt: true,
+  })
+  .extend({
+    imageUrl: httpsUrlSchema.optional(),
+  })
+export type CreateStorefrontProductInput = z.infer<typeof createStorefrontProductInputSchema>

package/src/subscriptions.ts

@@ -0,0 +1,180 @@
+/**
+ * Subscriptions — plans, active subscriptions, and individual charges.
+ *
+ * Design notes:
+ * - A SubscriptionPlan is the template a merchant defines.
+ * - A Subscription is an active, customer-scoped instance of a plan.
+ * - Each billing period produces a SubscriptionCharge with a unique
+ *   chargeAttemptId used to enforce idempotency at the contract level.
+ */
+
+import { z } from 'zod'
+import {
+  evmAddressSchema,
+  evmTxHashSchema,
+  idSchema,
+  isoTimestampSchema,
+  metadataSchema,
+  paymentCurrencySchema,
+  tokenAmountSchema,
+} from './common.js'
+
+// ---------- Plans ----------
+
+export const subscriptionIntervalSchema = z.enum([
+  'daily',
+  'weekly',
+  'monthly',
+  'quarterly',
+  'yearly',
+])
+export type SubscriptionInterval = z.infer<typeof subscriptionIntervalSchema>
+
+export const subscriptionPlanStatusSchema = z.enum(['active', 'archived'])
+export type SubscriptionPlanStatus = z.infer<typeof subscriptionPlanStatusSchema>
+
+export const subscriptionPlanSchema = 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: 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: z.number().int().positive(),
+  name: z.string().min(1).max(120),
+  description: z.string().max(500).nullable(),
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  interval: subscriptionIntervalSchema,
+  intervalCount: z.number().int().min(1).max(365),
+  trialPeriodDays: z.number().int().min(0).max(365).nullable(),
+  status: subscriptionPlanStatusSchema,
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type SubscriptionPlan = z.infer<typeof subscriptionPlanSchema>
+
+export const createSubscriptionPlanInputSchema = z.object({
+  name: z.string().min(1).max(120),
+  description: z.string().max(500).optional(),
+  amount: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  interval: subscriptionIntervalSchema,
+  intervalCount: z.number().int().min(1).max(365).default(1),
+  trialPeriodDays: z.number().int().min(0).max(365).optional(),
+  metadata: metadataSchema.optional(),
+})
+export type CreateSubscriptionPlanInput = z.infer<typeof createSubscriptionPlanInputSchema>
+
+// ---------- Subscriptions ----------
+
+export const subscriptionStatusSchema = z.enum([
+  'trialing',
+  'active',
+  'at_risk',
+  'paused',
+  'cancelled',
+  'lapsed',
+])
+export type SubscriptionStatus = z.infer<typeof subscriptionStatusSchema>
+
+export const subscriptionSchema = z.object({
+  id: idSchema,
+  onchainSubscriptionId: z.number().int().nonnegative().nullable(),
+  merchantId: idSchema,
+  customerId: idSchema,
+  planId: idSchema,
+  status: subscriptionStatusSchema,
+  payerAddress: evmAddressSchema,
+  currency: paymentCurrencySchema,
+  amount: tokenAmountSchema,
+  interval: subscriptionIntervalSchema,
+  intervalCount: z.number().int().min(1),
+  trialEndsAt: isoTimestampSchema.nullable(),
+  currentPeriodStartAt: isoTimestampSchema,
+  currentPeriodEndAt: isoTimestampSchema,
+  nextChargeAt: isoTimestampSchema.nullable(),
+  gracePeriodHours: z.number().int().min(0).max(72),
+  cancelledAt: isoTimestampSchema.nullable(),
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type Subscription = z.infer<typeof subscriptionSchema>
+
+export const createSubscriptionInputSchema = z.object({
+  planId: idSchema,
+  customer: z.object({
+    walletAddress: evmAddressSchema,
+    email: z.string().email().optional(),
+    externalRef: z.string().max(120).optional(),
+  }),
+  gracePeriodHours: z.union([z.literal(24), z.literal(48), z.literal(72)]).default(48),
+  metadata: metadataSchema.optional(),
+})
+export type CreateSubscriptionInput = z.infer<typeof createSubscriptionInputSchema>
+
+export const cancelSubscriptionInputSchema = z.object({
+  id: idSchema,
+  reason: z.string().max(500).optional(),
+})
+export type CancelSubscriptionInput = z.infer<typeof cancelSubscriptionInputSchema>
+
+// ---------- Charges ----------
+
+export const subscriptionChargeOutcomeSchema = z.enum([
+  'charged',
+  'insufficient_funds',
+  'revoked_approval',
+  'cancelled',
+  'skipped',
+])
+export type SubscriptionChargeOutcome = z.infer<typeof subscriptionChargeOutcomeSchema>
+
+export const subscriptionChargeStatusSchema = z.enum([
+  'pending',
+  'in_flight',
+  'succeeded',
+  'failed',
+  'retrying',
+  'abandoned',
+])
+export type SubscriptionChargeStatus = z.infer<typeof subscriptionChargeStatusSchema>
+
+export const subscriptionChargeSchema = z.object({
+  id: idSchema,
+  subscriptionId: idSchema,
+  merchantId: idSchema,
+  chargeAttemptId: 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: z.number().int().min(1),
+  scheduledAt: isoTimestampSchema,
+  executedAt: isoTimestampSchema.nullable(),
+  onchainTxHash: evmTxHashSchema.nullable(),
+  failureReason: z.string().max(500).nullable(),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type SubscriptionCharge = z.infer<typeof subscriptionChargeSchema>

package/src/tokens.ts

@@ -0,0 +1,60 @@
+/**
+ * Token metadata + capability descriptor.
+ *
+ * Read by the SDK's BrowserClient to (1) pick the right meta-tx path
+ * for a given token and (2) build the EIP-712 typed-data domain. The
+ * shape is intentionally derived from on-chain reads — name / version
+ * from the token's ERC-5267 `eip712Domain()` (falling back to a
+ * default), capabilities from Strimz's TokenWhitelist contract.
+ *
+ * `capabilities.permit2612` means the token implements EIP-2612 (the
+ * gasless allowance + subscription enrolment path).
+ * `capabilities.transferAuth3009` means the token implements EIP-3009
+ * (the gasless one-shot payment path).
+ *
+ * Tokens may have one capability or both — USDC and EURC on Arc
+ * advertise both.
+ */
+
+import { z } from 'zod'
+
+const addressSchema = z
+  .string()
+  .regex(/^0x[0-9a-fA-F]{40}$/u, 'must be a 0x-prefixed 20-byte address')
+
+export const tokenCapabilitiesSchema = z.object({
+  permit2612: z.boolean(),
+  transferAuth3009: z.boolean(),
+})
+export type TokenCapabilities = z.infer<typeof tokenCapabilitiesSchema>
+
+export const tokenMetadataSchema = z.object({
+  address: addressSchema,
+  name: z.string(),
+  symbol: 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: z.string(),
+  decimals: z.number().int().min(0).max(255),
+  capabilities: tokenCapabilitiesSchema,
+})
+export type TokenMetadata = z.infer<typeof tokenMetadataSchema>
+
+/**
+ * Owner-specific permit nonce. The EIP-2612 standard tracks a per-
+ * owner monotonic counter — every successful permit consumes one,
+ * so signers must read the current value immediately before signing.
+ *
+ * Returned as a decimal string to avoid JS number truncation on the
+ * uint256 values some long-lived owners can accumulate.
+ */
+export const tokenPermitNonceSchema = z.object({
+  token: addressSchema,
+  owner: addressSchema,
+  nonce: z.string().regex(/^[0-9]+$/u, 'must be a decimal integer string'),
+})
+export type TokenPermitNonce = z.infer<typeof tokenPermitNonceSchema>

package/src/transactions.ts

@@ -0,0 +1,52 @@
+/**
+ * Transaction — the record of a confirmed on-chain payment.
+ *
+ * Every transaction corresponds to either a paid PaymentSession, a
+ * SubscriptionCharge, or a Refund. The indexer writes these from the
+ * `PaymentExecuted`, `SubscriptionCharged`, and `RefundRecorded` events.
+ */
+
+import { z } from 'zod'
+import {
+  evmAddressSchema,
+  evmTxHashSchema,
+  idSchema,
+  isoTimestampSchema,
+  paymentCurrencySchema,
+  tokenAmountSchema,
+} from './common.js'
+
+export const transactionKindSchema = z.enum([
+  'one_shot',
+  'subscription_charge',
+  'refund',
+  'invoice_payment',
+  'storefront_purchase',
+])
+export type TransactionKind = z.infer<typeof transactionKindSchema>
+
+export const transactionStatusSchema = z.enum(['pending', 'confirmed', 'failed'])
+export type TransactionStatus = z.infer<typeof transactionStatusSchema>
+
+export const transactionSchema = 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: z.number().int().nonnegative(),
+  blockTimestamp: isoTimestampSchema,
+  createdAt: isoTimestampSchema,
+})
+export type Transaction = z.infer<typeof transactionSchema>

package/src/webhooks.ts

@@ -0,0 +1,109 @@
+/**
+ * Webhook endpoints and deliveries.
+ *
+ * Endpoint = the URL the merchant registered.
+ * Event    = the thing that happened.
+ * Delivery = one attempt to POST a specific event to a specific endpoint.
+ */
+
+import { z } from 'zod'
+import { httpsUrlSchema, idSchema, isoTimestampSchema, modeSchema } from './common.js'
+
+// ---------- Event name ----------
+
+/**
+ * Every webhook event name in the system. Listed here (not imported from
+ * `@strimz/shared-config`) so Zod can produce a concrete string union.
+ */
+export const webhookEventNameSchema = 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',
+])
+export type WebhookEventName = z.infer<typeof webhookEventNameSchema>
+
+// ---------- Endpoints ----------
+
+export const webhookEndpointStatusSchema = z.enum(['active', 'disabled'])
+export type WebhookEndpointStatus = z.infer<typeof webhookEndpointStatusSchema>
+
+export const webhookEndpointSchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  mode: modeSchema,
+  url: httpsUrlSchema,
+  description: z.string().max(200).nullable(),
+  events: z.array(webhookEventNameSchema).nonempty(),
+  status: webhookEndpointStatusSchema,
+  signingSecretPrefix: z.string().min(4).max(12),
+  lastDeliveredAt: isoTimestampSchema.nullable(),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type WebhookEndpoint = z.infer<typeof webhookEndpointSchema>
+
+export const createWebhookEndpointInputSchema = z.object({
+  url: httpsUrlSchema,
+  events: z.array(webhookEventNameSchema).nonempty(),
+  description: z.string().max(200).optional(),
+  mode: modeSchema,
+})
+export type CreateWebhookEndpointInput = z.infer<typeof createWebhookEndpointInputSchema>
+
+export const createWebhookEndpointOutputSchema = z.object({
+  endpoint: webhookEndpointSchema,
+  /** Full signing secret — shown exactly once. */
+  signingSecret: z.string(),
+})
+export type CreateWebhookEndpointOutput = z.infer<typeof createWebhookEndpointOutputSchema>
+
+// ---------- Deliveries ----------
+
+export const webhookDeliveryStatusSchema = z.enum([
+  'pending',
+  'delivered',
+  'retrying',
+  'permanently_failed',
+])
+export type WebhookDeliveryStatus = z.infer<typeof webhookDeliveryStatusSchema>
+
+export const webhookDeliverySchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  endpointId: idSchema,
+  eventId: idSchema,
+  eventName: webhookEventNameSchema,
+  status: webhookDeliveryStatusSchema,
+  attempt: z.number().int().min(1).max(6),
+  responseCode: z.number().int().min(100).max(599).nullable(),
+  responseMs: z.number().int().min(0).nullable(),
+  lastError: z.string().max(1000).nullable(),
+  nextAttemptAt: isoTimestampSchema.nullable(),
+  deliveredAt: isoTimestampSchema.nullable(),
+  createdAt: isoTimestampSchema,
+})
+export type WebhookDelivery = z.infer<typeof webhookDeliverySchema>
+
+export const replayDeliveryInputSchema = z.object({
+  id: idSchema,
+})
+export type ReplayDeliveryInput = z.infer<typeof replayDeliveryInputSchema>