@strimz/shared-types 0.1.0

package/src/api-keys.ts

@@ -0,0 +1,78 @@
+/**
+ * API keys.
+ *
+ * A merchant has independent test and live keys. The full secret is shown
+ * exactly once at creation; the backend stores only a hash and a display prefix.
+ */
+
+import { z } from 'zod'
+import { idSchema, isoTimestampSchema, modeSchema } from './common.js'
+
+export const apiKeyKindSchema = z.enum(['secret', 'publishable'])
+export type ApiKeyKind = z.infer<typeof apiKeyKindSchema>
+
+/**
+ * Underscore-separated to match the Prisma `ApiKeyScope` enum (Prisma
+ * does not allow `:` in enum values). The DB and the wire format use the
+ * same form so there is no boundary translation.
+ */
+export const apiKeyScopeSchema = 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',
+])
+export type ApiKeyScope = z.infer<typeof apiKeyScopeSchema>
+
+export const apiKeySchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  name: z.string().min(1).max(60),
+  kind: apiKeyKindSchema,
+  mode: modeSchema,
+  prefix: z.string().min(8).max(24),
+  lastFour: z.string().length(4),
+  scopes: z.array(apiKeyScopeSchema).nonempty(),
+  createdAt: isoTimestampSchema,
+  lastUsedAt: isoTimestampSchema.nullable(),
+  revokedAt: isoTimestampSchema.nullable(),
+})
+export type ApiKey = z.infer<typeof apiKeySchema>
+
+// ---------- DTOs ----------
+
+export const createApiKeyInputSchema = z.object({
+  name: z.string().min(1).max(60),
+  kind: apiKeyKindSchema,
+  mode: modeSchema,
+  scopes: z.array(apiKeyScopeSchema).nonempty(),
+})
+export type CreateApiKeyInput = z.infer<typeof createApiKeyInputSchema>
+
+export const createApiKeyOutputSchema = z.object({
+  apiKey: apiKeySchema,
+  /** Full plaintext key — shown exactly once. */
+  secret: z.string(),
+})
+export type CreateApiKeyOutput = z.infer<typeof createApiKeyOutputSchema>
+
+export const rotateApiKeyInputSchema = z.object({
+  id: idSchema,
+})
+export type RotateApiKeyInput = z.infer<typeof rotateApiKeyInputSchema>

package/src/common.ts

@@ -0,0 +1,113 @@
+/**
+ * Primitive schemas shared across every entity.
+ * Every higher-level schema builds on these so validation is consistent.
+ */
+
+import { z } from 'zod'
+
+/** CUID2 or UUID-style opaque identifier. */
+export const idSchema = z
+  .string()
+  .min(1)
+  .max(64)
+  .regex(/^[a-zA-Z0-9_-]+$/, 'id must be URL-safe')
+
+/** EVM address. Hex-encoded, 0x-prefixed, 20 bytes. Normalised to lowercase. */
+export const evmAddressSchema = z
+  .string()
+  .regex(/^0x[a-fA-F0-9]{40}$/, 'must be a 0x-prefixed 40-character hex EVM address')
+  .transform((v) => v.toLowerCase())
+
+/** EVM transaction hash. 32-byte hex. */
+export const evmTxHashSchema = z
+  .string()
+  .regex(/^0x[a-fA-F0-9]{64}$/, 'must be a 0x-prefixed 64-character hex EVM transaction hash')
+
+/** Email address, trimmed and lower-cased. */
+export const emailSchema = z.string().email().trim().toLowerCase().max(320)
+
+/** HTTPS URL. No http:// allowed outside dev. */
+export const httpsUrlSchema = z
+  .string()
+  .url()
+  .refine((v) => v.startsWith('https://'), {
+    message: 'must be an https:// URL',
+  })
+
+/** URL permitting http and https (dev + prod). */
+export const httpUrlSchema = z.string().url()
+
+/**
+ * Amount expressed in the token's smallest unit, serialised as a string to
+ * preserve precision beyond `Number.MAX_SAFE_INTEGER`. For USDC (6 decimals),
+ * 1 USDC is the string "1000000".
+ */
+export const tokenAmountSchema = z
+  .string()
+  .regex(/^[0-9]+$/, 'must be a non-negative integer string (base-10)')
+  .refine((v) => BigInt(v) >= 0n, 'must be >= 0')
+
+/** Unsigned integer up to 2^53 - 1; validated and returned as number. */
+export const uintSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+
+/** ISO-8601 timestamp string (`.toISOString()`-compatible). */
+export const isoTimestampSchema = z
+  .string()
+  .datetime({ offset: true, message: 'must be an ISO-8601 timestamp' })
+
+/** Two-letter ISO-3166 country code. */
+export const countryCodeSchema = z
+  .string()
+  .length(2)
+  .regex(/^[A-Z]{2}$/, 'must be an ISO-3166 alpha-2 country code')
+
+/** Pagination inputs used by every list endpoint. */
+export const paginationInputSchema = z.object({
+  limit: z.number().int().min(1).max(100).default(25),
+  cursor: z.string().min(1).max(200).nullish(),
+})
+export type PaginationInput = z.infer<typeof paginationInputSchema>
+
+/** Pagination envelope used by every list response. */
+export const makePaginatedSchema = <T extends z.ZodTypeAny>(item: T) =>
+  z.object({
+    data: z.array(item),
+    nextCursor: z.string().nullable(),
+    hasMore: z.boolean(),
+  })
+
+/** Free-form metadata bag the API round-trips for merchants. */
+export const metadataSchema = z
+  .record(
+    z.string().min(1).max(40),
+    z.union([z.string().max(500), z.number(), z.boolean(), z.null()]),
+  )
+  .refine((m) => Object.keys(m).length <= 50, 'at most 50 metadata keys')
+  .default({})
+
+/** Environment mode carried on every mode-scoped resource. */
+export const modeSchema = z.enum(['test', 'live'])
+export type Mode = z.infer<typeof modeSchema>
+
+/** Payment token enum — mirrors `@strimz/shared-config`. */
+export const paymentCurrencySchema = z.enum(['USDC', 'EURC'])
+export type PaymentCurrency = z.infer<typeof paymentCurrencySchema>
+
+/** Every display-level currency (payment + treasury). */
+export const tokenSymbolSchema = z.enum(['USDC', 'EURC', 'USYC'])
+export type TokenSymbol = z.infer<typeof tokenSymbolSchema>
+
+/** Merchant tier enum — mirrors `@strimz/shared-config`. */
+export const merchantTierSchema = z.enum(['free', 'growth', 'business', 'enterprise'])
+export type MerchantTier = z.infer<typeof merchantTierSchema>
+
+/** Arc environment enum. */
+export const arcEnvironmentSchema = z.enum(['testnet', 'mainnet'])
+export type ArcEnvironment = z.infer<typeof arcEnvironmentSchema>
+
+export type Id = z.infer<typeof idSchema>
+export type EvmAddress = z.infer<typeof evmAddressSchema>
+export type EvmTxHash = z.infer<typeof evmTxHashSchema>
+export type TokenAmount = z.infer<typeof tokenAmountSchema>
+export type IsoTimestamp = z.infer<typeof isoTimestampSchema>
+export type Metadata = z.infer<typeof metadataSchema>

package/src/compliance.ts

@@ -0,0 +1,40 @@
+/**
+ * Compliance — sanctions/AML screening log.
+ *
+ * Every wallet address that interacts with Strimz (merchant payout,
+ * subscriber, payer) is screened. Results are logged; provider and score
+ * are recorded for later audit.
+ */
+
+import { z } from 'zod'
+import { evmAddressSchema, idSchema, isoTimestampSchema } from './common.js'
+
+export const complianceProviderSchema = z.enum(['trm', 'elliptic', 'disabled'])
+export type ComplianceProvider = z.infer<typeof complianceProviderSchema>
+
+export const complianceStatusSchema = z.enum(['clear', 'flagged', 'blocked', 'error'])
+export type ComplianceStatus = z.infer<typeof complianceStatusSchema>
+
+export const complianceScreeningContextSchema = z.enum([
+  'merchant_onboarding',
+  'payer_checkout',
+  'subscriber_signup',
+  'refund_recipient',
+])
+export type ComplianceScreeningContext = z.infer<typeof complianceScreeningContextSchema>
+
+export const complianceLogSchema = z.object({
+  id: idSchema,
+  walletAddress: evmAddressSchema,
+  provider: complianceProviderSchema,
+  status: complianceStatusSchema,
+  riskScore: z.number().min(0).max(100).nullable(),
+  flags: z.array(z.string().max(120)).default([]),
+  context: complianceScreeningContextSchema,
+  merchantId: idSchema.nullable(),
+  sessionId: idSchema.nullable(),
+  subscriptionId: idSchema.nullable(),
+  providerRequestId: z.string().max(200).nullable(),
+  createdAt: isoTimestampSchema,
+})
+export type ComplianceLog = z.infer<typeof complianceLogSchema>

package/src/customers.ts

@@ -0,0 +1,40 @@
+/**
+ * Customer — the payer on the merchant's side.
+ *
+ * Customers are uniquely identified by (merchantId, walletAddress). Email and
+ * externalRef are optional; merchants can associate their own customer id.
+ */
+
+import { z } from 'zod'
+import {
+  emailSchema,
+  evmAddressSchema,
+  idSchema,
+  isoTimestampSchema,
+  metadataSchema,
+} from './common.js'
+
+export const customerSchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  walletAddress: evmAddressSchema,
+  email: emailSchema.nullable(),
+  /** Merchant-provided external identifier (e.g. their own user id). */
+  externalRef: z.string().min(1).max(120).nullable(),
+  displayName: z.string().min(1).max(120).nullable(),
+  metadata: metadataSchema,
+  firstSeenAt: isoTimestampSchema,
+  lastSeenAt: isoTimestampSchema,
+})
+export type Customer = z.infer<typeof customerSchema>
+
+// ---------- DTOs ----------
+
+export const upsertCustomerInputSchema = z.object({
+  walletAddress: evmAddressSchema,
+  email: emailSchema.optional(),
+  externalRef: z.string().min(1).max(120).optional(),
+  displayName: z.string().min(1).max(120).optional(),
+  metadata: metadataSchema.optional(),
+})
+export type UpsertCustomerInput = z.infer<typeof upsertCustomerInputSchema>

package/src/events.ts

@@ -0,0 +1,176 @@
+/**
+ * Canonical webhook event envelopes.
+ *
+ * The event envelope is what Strimz signs, stores, and delivers. Every
+ * webhook-delivered payload is an instance of `webhookEventSchema` for a
+ * specific event name, with `data` typed to the matching entity schema.
+ *
+ * SDK consumers import `StrimzWebhookEvent` to get a discriminated union
+ * over every possible event name → payload shape.
+ */
+
+import { z } from 'zod'
+import { idSchema, isoTimestampSchema, modeSchema } from './common.js'
+import { paymentSessionSchema } from './payment-sessions.js'
+import { transactionSchema } from './transactions.js'
+import { subscriptionSchema, subscriptionChargeSchema } from './subscriptions.js'
+import { refundSchema } from './refunds.js'
+import { invoiceSchema } from './invoices.js'
+import { agentActivityLogSchema, agentJobSchema } from './agents.js'
+import { complianceLogSchema } from './compliance.js'
+import { webhookEventNameSchema } from './webhooks.js'
+
+/** Common envelope wrapping every webhook payload. */
+const envelope = <N extends string, D extends z.ZodTypeAny>(name: N, data: D) =>
+  z.object({
+    id: idSchema,
+    type: z.literal(name),
+    apiVersion: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    mode: modeSchema,
+    createdAt: isoTimestampSchema,
+    data,
+  })
+
+// ---------- Payment ----------
+
+export const paymentCreatedEventSchema = envelope('payment.created', paymentSessionSchema)
+export const paymentCompletedEventSchema = envelope(
+  'payment.completed',
+  z.object({ session: paymentSessionSchema, transaction: transactionSchema }),
+)
+export const paymentFailedEventSchema = envelope(
+  'payment.failed',
+  z.object({ session: paymentSessionSchema, reason: z.string() }),
+)
+
+// ---------- Subscription ----------
+
+export const subscriptionCreatedEventSchema = envelope('subscription.created', subscriptionSchema)
+export const subscriptionChargedEventSchema = envelope(
+  'subscription.charged',
+  z.object({
+    subscription: subscriptionSchema,
+    charge: subscriptionChargeSchema,
+    transaction: transactionSchema,
+  }),
+)
+export const subscriptionChargeFailedEventSchema = envelope(
+  'subscription.charge_failed',
+  z.object({ subscription: subscriptionSchema, charge: subscriptionChargeSchema }),
+)
+export const subscriptionRecoveryAttemptEventSchema = envelope(
+  'subscription.recovery_attempt',
+  z.object({ subscription: subscriptionSchema, attemptNumber: z.number().int().min(1) }),
+)
+export const subscriptionRecoveryOutcomeEventSchema = envelope(
+  'subscription.recovery_outcome',
+  z.object({
+    subscription: subscriptionSchema,
+    outcome: z.enum(['recovered', 'churned']),
+  }),
+)
+export const subscriptionCancelledEventSchema = envelope(
+  'subscription.cancelled',
+  subscriptionSchema,
+)
+export const subscriptionLapsedEventSchema = envelope('subscription.lapsed', subscriptionSchema)
+
+// ---------- Refund ----------
+
+export const refundCreatedEventSchema = envelope('refund.created', refundSchema)
+export const refundCompletedEventSchema = envelope(
+  'refund.completed',
+  z.object({ refund: refundSchema, transaction: transactionSchema }),
+)
+export const refundFailedEventSchema = envelope(
+  'refund.failed',
+  z.object({ refund: refundSchema, reason: z.string() }),
+)
+
+// ---------- Invoice ----------
+
+export const invoiceCreatedEventSchema = envelope('invoice.created', invoiceSchema)
+export const invoicePaidEventSchema = envelope(
+  'invoice.paid',
+  z.object({ invoice: invoiceSchema, transaction: transactionSchema }),
+)
+export const invoiceOverdueEventSchema = envelope('invoice.overdue', invoiceSchema)
+
+// ---------- Agent ----------
+
+export const agentActionExecutedEventSchema = envelope(
+  'agent.action_executed',
+  agentActivityLogSchema,
+)
+export const agentJobProposedEventSchema = envelope('agent.job_proposed', agentJobSchema)
+export const agentJobCompletedEventSchema = envelope('agent.job_completed', agentJobSchema)
+export const agentJobDisputedEventSchema = envelope('agent.job_disputed', agentJobSchema)
+
+// ---------- Compliance ----------
+
+export const complianceWalletFlaggedEventSchema = envelope(
+  'compliance.wallet_flagged',
+  complianceLogSchema,
+)
+export const complianceWalletBlockedEventSchema = envelope(
+  'compliance.wallet_blocked',
+  complianceLogSchema,
+)
+
+// ---------- Discriminated union ----------
+
+export const webhookEventSchema = 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,
+])
+export type StrimzWebhookEvent = z.infer<typeof webhookEventSchema>
+
+/** Per-event-name inferred payload types. */
+export type PaymentCreatedEvent = z.infer<typeof paymentCreatedEventSchema>
+export type PaymentCompletedEvent = z.infer<typeof paymentCompletedEventSchema>
+export type PaymentFailedEvent = z.infer<typeof paymentFailedEventSchema>
+export type SubscriptionCreatedEvent = z.infer<typeof subscriptionCreatedEventSchema>
+export type SubscriptionChargedEvent = z.infer<typeof subscriptionChargedEventSchema>
+export type SubscriptionChargeFailedEvent = z.infer<typeof subscriptionChargeFailedEventSchema>
+export type SubscriptionRecoveryAttemptEvent = z.infer<
+  typeof subscriptionRecoveryAttemptEventSchema
+>
+export type SubscriptionRecoveryOutcomeEvent = z.infer<
+  typeof subscriptionRecoveryOutcomeEventSchema
+>
+export type SubscriptionCancelledEvent = z.infer<typeof subscriptionCancelledEventSchema>
+export type SubscriptionLapsedEvent = z.infer<typeof subscriptionLapsedEventSchema>
+export type RefundCreatedEvent = z.infer<typeof refundCreatedEventSchema>
+export type RefundCompletedEvent = z.infer<typeof refundCompletedEventSchema>
+export type RefundFailedEvent = z.infer<typeof refundFailedEventSchema>
+export type InvoiceCreatedEvent = z.infer<typeof invoiceCreatedEventSchema>
+export type InvoicePaidEvent = z.infer<typeof invoicePaidEventSchema>
+export type InvoiceOverdueEvent = z.infer<typeof invoiceOverdueEventSchema>
+export type AgentActionExecutedEvent = z.infer<typeof agentActionExecutedEventSchema>
+export type AgentJobProposedEvent = z.infer<typeof agentJobProposedEventSchema>
+export type AgentJobCompletedEvent = z.infer<typeof agentJobCompletedEventSchema>
+export type AgentJobDisputedEvent = z.infer<typeof agentJobDisputedEventSchema>
+export type ComplianceWalletFlaggedEvent = z.infer<typeof complianceWalletFlaggedEventSchema>
+export type ComplianceWalletBlockedEvent = z.infer<typeof complianceWalletBlockedEventSchema>
+
+export { webhookEventNameSchema }

package/src/index.ts

@@ -0,0 +1,23 @@
+/**
+ * @strimz/shared-types
+ *
+ * Zod schemas and inferred TypeScript types for every platform entity,
+ * API input, and webhook event. The schema is the source of truth; types
+ * are inferred from schemas so wire format and compile-time shape never drift.
+ */
+
+export * from './common.js'
+export * from './merchants.js'
+export * from './api-keys.js'
+export * from './customers.js'
+export * from './payment-sessions.js'
+export * from './transactions.js'
+export * from './subscriptions.js'
+export * from './refunds.js'
+export * from './webhooks.js'
+export * from './compliance.js'
+export * from './agents.js'
+export * from './storefronts.js'
+export * from './invoices.js'
+export * from './events.js'
+export * from './tokens.js'

package/src/invoices.ts

@@ -0,0 +1,53 @@
+/**
+ * Invoices — shareable, expirable payment requests with structured line items.
+ */
+
+import { z } from 'zod'
+import {
+  emailSchema,
+  idSchema,
+  isoTimestampSchema,
+  paymentCurrencySchema,
+  tokenAmountSchema,
+} from './common.js'
+
+export const invoiceStatusSchema = z.enum(['draft', 'sent', 'paid', 'overdue', 'void'])
+export type InvoiceStatus = z.infer<typeof invoiceStatusSchema>
+
+export const invoiceLineItemSchema = z.object({
+  description: z.string().min(1).max(500),
+  quantity: z.number().int().min(1).max(10_000),
+  unitAmount: tokenAmountSchema,
+})
+export type InvoiceLineItem = z.infer<typeof invoiceLineItemSchema>
+
+export const invoiceSchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  number: z.string().min(1).max(40),
+  customerName: z.string().min(1).max(200).nullable(),
+  customerEmail: emailSchema.nullable(),
+  lineItems: z.array(invoiceLineItemSchema).nonempty(),
+  subtotal: tokenAmountSchema,
+  total: tokenAmountSchema,
+  currency: paymentCurrencySchema,
+  status: invoiceStatusSchema,
+  note: z.string().max(2000).nullable(),
+  sessionId: idSchema.nullable(),
+  dueAt: isoTimestampSchema,
+  paidAt: isoTimestampSchema.nullable(),
+  sentAt: isoTimestampSchema.nullable(),
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type Invoice = z.infer<typeof invoiceSchema>
+
+export const createInvoiceInputSchema = z.object({
+  customerName: z.string().min(1).max(200).optional(),
+  customerEmail: emailSchema.optional(),
+  lineItems: z.array(invoiceLineItemSchema).nonempty(),
+  currency: paymentCurrencySchema,
+  note: z.string().max(2000).optional(),
+  dueInDays: z.number().int().min(1).max(90).default(7),
+})
+export type CreateInvoiceInput = z.infer<typeof createInvoiceInputSchema>

package/src/merchants.ts

@@ -0,0 +1,104 @@
+/**
+ * Merchant entity and lifecycle DTOs.
+ *
+ * A merchant is the platform's first-class tenant. Merchants have a tier,
+ * a payout wallet address, and an on-chain merchantId registered in the
+ * StrimzRegistry contract.
+ */
+
+import { z } from 'zod'
+import {
+  emailSchema,
+  evmAddressSchema,
+  idSchema,
+  isoTimestampSchema,
+  merchantTierSchema,
+  metadataSchema,
+} from './common.js'
+
+export const merchantStatusSchema = z.enum(['active', 'suspended', 'closed'])
+export type MerchantStatus = z.infer<typeof merchantStatusSchema>
+
+export const merchantRoleSchema = z.enum(['owner', 'admin', 'developer', 'read_only'])
+export type MerchantRole = z.infer<typeof merchantRoleSchema>
+
+export const merchantSchema = z.object({
+  id: idSchema,
+  onchainMerchantId: z.number().int().nonnegative().nullable(),
+  businessName: z.string().min(2).max(120),
+  email: emailSchema,
+  tier: merchantTierSchema,
+  status: merchantStatusSchema,
+  payoutAddress: evmAddressSchema.nullable(),
+  defaultCurrency: z.enum(['USDC', 'EURC']),
+  countryCode: z.string().length(2).nullable(),
+  websiteUrl: z.string().url().nullable(),
+  logoUrl: z.string().url().nullable(),
+  whitelabelEnabled: z.boolean(),
+  metadata: metadataSchema,
+  createdAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema,
+})
+export type Merchant = z.infer<typeof merchantSchema>
+
+// ---------- DTOs ----------
+
+export const createMerchantInputSchema = z.object({
+  businessName: z.string().min(2).max(120),
+  email: emailSchema,
+  password: z.string().min(12).max(128),
+  countryCode: z.string().length(2).optional(),
+  websiteUrl: z.string().url().optional(),
+})
+export type CreateMerchantInput = z.infer<typeof createMerchantInputSchema>
+
+export const updateMerchantInputSchema = z
+  .object({
+    businessName: z.string().min(2).max(120),
+    payoutAddress: evmAddressSchema,
+    defaultCurrency: z.enum(['USDC', 'EURC']),
+    websiteUrl: z.string().url().nullable(),
+    logoUrl: z.string().url().nullable(),
+    countryCode: z.string().length(2).nullable(),
+    metadata: metadataSchema,
+  })
+  .partial()
+export type UpdateMerchantInput = z.infer<typeof updateMerchantInputSchema>
+
+export const changeTierInputSchema = z.object({
+  tier: merchantTierSchema,
+})
+export type ChangeTierInput = z.infer<typeof changeTierInputSchema>
+
+// ---------- Team members ----------
+
+export const merchantMemberSchema = z.object({
+  id: idSchema,
+  merchantId: idSchema,
+  email: emailSchema,
+  role: merchantRoleSchema,
+  invitedAt: isoTimestampSchema,
+  acceptedAt: isoTimestampSchema.nullable(),
+})
+export type MerchantMember = z.infer<typeof merchantMemberSchema>
+
+export const inviteMemberInputSchema = z.object({
+  email: emailSchema,
+  role: merchantRoleSchema,
+})
+export type InviteMemberInput = z.infer<typeof inviteMemberInputSchema>
+
+// ---------- Auth ----------
+
+export const loginInputSchema = z.object({
+  email: emailSchema,
+  password: z.string().min(1).max(128),
+})
+export type LoginInput = z.infer<typeof loginInputSchema>
+
+export const loginOutputSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string(),
+  merchant: merchantSchema,
+})
+export type LoginOutput = z.infer<typeof loginOutputSchema>