tapimo 0.14.0 → 0.15.0

package/src/db/Schema.ts

@@ -1,12 +1,15 @@
 import * as z from 'zod/mini'
+import type { Hex } from 'ox'
 import type { Address } from 'viem'
 
 import type * as EarnVaults from '../internal/EarnVaults.js'
-import type * as funding_Catalog from '../internal/funding/Catalog.js'
-import type * as funding_Deposit from '../internal/funding/Deposit.js'
-import type * as funding_DepositAddress from '../internal/funding/DepositAddress.js'
-import type * as funding_Provider from '../internal/funding/Provider.js'
-import type * as funding_Transfer from '../internal/funding/Transfer.js'
+import type * as Campaigns from '../internal/rewards/Campaigns.js'
+import type * as routes_Catalog from '../internal/routes/Catalog.js'
+import type * as routes_Deposit from '../internal/routes/Deposit.js'
+import type * as routes_DepositAddress from '../internal/routes/DepositAddress.js'
+import type * as routes_Provider from '../internal/routes/Provider.js'
+import type * as routes_Transfer from '../internal/routes/Transfer.js'
+import type * as routes_TransferSubsidy from '../internal/routes/TransferSubsidy.js'
 import type * as internal_Schema from '../internal/Schema.js'
 import type * as Webhooks from '../internal/Webhooks.js'
 
@@ -29,11 +32,111 @@ export const AdminAuditLog = z.object({
 /** Columns of the `admin_audit_logs` table. */
 export type AdminAuditLog = z.output<typeof AdminAuditLog>
 
-// Row schemas for database tables (`zod/mini`), the source of truth each
-// `tables/` module derives its `Table` type from. Nullable fields map to
-// nullable columns; the domain layer converts `null` back to absent fields.
-// Domain-owned unions and jsonb values stay typed by their owning module via
-// `z.custom` (type-only imports) so the two cannot drift.
+/** A durable fence for API keys attributed to a deleted organization or project. */
+export const ApiKeyOwnerTombstone = z.object({
+  createdAt: z.string().check(z.describe('When the owner deletion committed (ISO 8601).')),
+  id: z.string().check(z.describe('Deterministic organization or project owner key.')),
+})
+
+/** Columns of the `api_key_owner_tombstones` table. */
+export type ApiKeyOwnerTombstone = z.output<typeof ApiKeyOwnerTombstone>
+
+/** Legacy aggregate API-key admission count retained for migration compatibility. */
+export const ApiKeyOwnerAdmission = z.object({
+  liveKeys: z.number().check(z.int(), z.nonnegative()),
+  orgId: z.string(),
+  updatedAt: z.string(),
+})
+
+/** Columns of the `api_key_owner_admissions` table. */
+export type ApiKeyOwnerAdmission = z.output<typeof ApiKeyOwnerAdmission>
+
+/** One API key counted toward its organization's live-key admission limit. */
+export const ApiKeyAdmission = z.object({
+  expiresAt: z.nullable(z.string()),
+  id: z.string(),
+  orgId: z.string(),
+  projectId: z.nullable(z.string()),
+})
+
+/** Columns of the `api_key_admissions` table. */
+export type ApiKeyAdmission = z.output<typeof ApiKeyAdmission>
+
+/** Records an organization's latest bounded legacy-key admission reconciliation. */
+export const ApiKeyAdmissionBootstrap = z.object({
+  bootstrappedAt: z.string(),
+  orgId: z.string(),
+})
+
+/** Columns of the `api_key_admission_bootstraps` table. */
+export type ApiKeyAdmissionBootstrap = z.output<typeof ApiKeyAdmissionBootstrap>
+
+/** A retained revocation fence for one stable API-key id. */
+export const ApiKeyRevocation = z.object({
+  expiresAt: z.string(),
+  id: z.string(),
+  orgId: z.nullable(z.string()),
+  revokedAt: z.string(),
+})
+
+/** Columns of the `api_key_revocations` table. */
+export type ApiKeyRevocation = z.output<typeof ApiKeyRevocation>
+
+/** A Better Auth login method linked to a Tempo user. */
+export const AuthAccount = z.object({
+  accessToken: z.nullable(z.string()).check(z.describe('OAuth access token, or null.')),
+  accessTokenExpiresAt: z
+    .nullable(z.date())
+    .check(z.describe('When the OAuth access token expires, or null.')),
+  accountId: z.string().check(z.describe('Provider-side account identifier.')),
+  createdAt: z.date().check(z.describe('When Better Auth created the account.')),
+  id: z.string().check(z.describe('Better Auth account row id.')),
+  idToken: z.nullable(z.string()).check(z.describe('OpenID Connect identity token, or null.')),
+  issuer: z.string().check(z.describe('Issuer namespace for the provider account.')),
+  password: z.nullable(z.string()).check(z.describe('Credential password hash, or null.')),
+  providerId: z.string().check(z.describe('Authentication provider identifier.')),
+  refreshToken: z.nullable(z.string()).check(z.describe('OAuth refresh token, or null.')),
+  refreshTokenExpiresAt: z
+    .nullable(z.date())
+    .check(z.describe('When the OAuth refresh token expires, or null.')),
+  scope: z.nullable(z.string()).check(z.describe('Granted OAuth scopes, or null.')),
+  updatedAt: z.date().check(z.describe('When Better Auth last changed the account.')),
+  userId: z.string().check(z.describe('Tempo user id that owns the login method.')),
+})
+
+/** Columns of the `auth_accounts` table. */
+export type AuthAccount = z.output<typeof AuthAccount>
+
+/** A Better Auth session row for the pinned package schema. */
+export const AuthSession = z.object({
+  createdAt: z.date().check(z.describe('When Better Auth created the session.')),
+  expiresAt: z.date().check(z.describe('When the Better Auth session expires.')),
+  id: z.string().check(z.describe('Better Auth session row id.')),
+  ipAddress: z.nullable(z.string()).check(z.describe('Client IP address, or null.')),
+  provider: z
+    .nullable(z.string())
+    .check(z.describe('Authentication provider that established the session, or null.')),
+  token: z.string().check(z.describe('Opaque Better Auth session token.')),
+  updatedAt: z.date().check(z.describe('When Better Auth last changed the session.')),
+  userAgent: z.nullable(z.string()).check(z.describe('Client user agent, or null.')),
+  userId: z.string().check(z.describe('Owning Better Auth user id.')),
+})
+
+/** Columns of the `auth_sessions` table. */
+export type AuthSession = z.output<typeof AuthSession>
+
+/** A Better Auth verification row for the pinned package schema. */
+export const AuthVerification = z.object({
+  createdAt: z.date().check(z.describe('When Better Auth created the verification.')),
+  expiresAt: z.date().check(z.describe('When the verification expires.')),
+  id: z.string().check(z.describe('Better Auth verification row id.')),
+  identifier: z.string().check(z.describe('Lookup key for the verification purpose.')),
+  updatedAt: z.date().check(z.describe('When Better Auth last changed the verification.')),
+  value: z.string().check(z.describe('Stored verification credential.')),
+})
+
+/** Columns of the `auth_verifications` table. */
+export type AuthVerification = z.output<typeof AuthVerification>
 
 /** An organization's billing configuration; source-agnostic (limits apply to any billing source). */
 export const BillingSettings = z.object({
@@ -74,21 +177,6 @@ export const EarlyAccessEntry = z.object({
 /** Columns of the `early_access` table. */
 export type EarlyAccessEntry = z.output<typeof EarlyAccessEntry>
 
-/** One billing-source type enabled for an organization. */
-export const EnabledBillingSource = z.object({
-  createdAt: z.string().check(z.describe('When the billing source was enabled (ISO 8601).')),
-  createdBy: z
-    .string()
-    .check(z.describe('Identity that enabled the source, or `migration` for backfilled rows.')),
-  orgId: z.string().check(z.describe('Organization id (`org_…`) this source is enabled for.')),
-  source: z
-    .enum(['stripe', 'tempo'])
-    .check(z.describe('Enabled billing-source type; `stripe` or `tempo`.')),
-})
-
-/** Columns of the `enabled_billing_sources` table. */
-export type EnabledBillingSource = z.output<typeof EnabledBillingSource>
-
 /** One curated Earn vault. */
 export const EarnVault = z
   .object({
@@ -116,6 +204,21 @@ export const EarnVault = z
 /** Columns of the `earn_vaults` table. */
 export type EarnVault = z.output<typeof EarnVault>
 
+/** One billing-source type enabled for an organization. */
+export const EnabledBillingSource = z.object({
+  createdAt: z.string().check(z.describe('When the billing source was enabled (ISO 8601).')),
+  createdBy: z
+    .string()
+    .check(z.describe('Identity that enabled the source, or `migration` for backfilled rows.')),
+  orgId: z.string().check(z.describe('Organization id (`org_…`) this source is enabled for.')),
+  source: z
+    .enum(['stripe', 'tempo'])
+    .check(z.describe('Enabled billing-source type; `stripe` or `tempo`.')),
+})
+
+/** Columns of the `enabled_billing_sources` table. */
+export type EnabledBillingSource = z.output<typeof EnabledBillingSource>
+
 /** A pending, expiring offer of organization membership. */
 export const Invitation = z.object({
   acceptedAt: z
@@ -222,9 +325,12 @@ export const Organization = z.object({
   sponsorshipSubsidyDurationDays: z
     .nullable(z.number().check(z.int(), z.positive()))
     .check(z.describe('Promotional sponsorship duration in days, or null when disabled.')),
+  // The persisted column name predates attribution-scoped promotion limits.
   sponsorshipSubsidyProjectSpendLimit: z
     .nullable(z.string())
-    .check(z.describe('Per-project promotional spend cap in decimal USD, or null when disabled.')),
+    .check(
+      z.describe('Per-attribution promotional spend cap in decimal USD, or null when disabled.'),
+    ),
   updatedAt: z.string().check(z.describe('When the organization was last updated (ISO 8601).')),
   userId: z
     .nullable(z.string())
@@ -236,6 +342,21 @@ export const Organization = z.object({
 /** Columns of the `organizations` table. */
 export type Organization = z.output<typeof Organization>
 
+/** An organization Routes subsidy policy. */
+export const RoutesSubsidy = z.object({
+  createdAt: z.string().check(z.describe('When the Routes subsidy policy was created (ISO 8601).')),
+  enabled: z.boolean().check(z.describe('Whether the organization enables Routes subsidies.')),
+  frequency: z.literal('tx').check(z.describe('Interval over which the subsidy limit applies.')),
+  maxAmount: z
+    .nullable(z.string())
+    .check(z.describe('Maximum Routes subsidy gap in decimal USD, or null when disabled.')),
+  orgId: z.string().check(z.describe('Organization id (`org_…`).')),
+  updatedAt: z.string().check(z.describe('When the Routes subsidy policy was updated (ISO 8601).')),
+})
+
+/** Columns of the `routes_subsidies` table. */
+export type RoutesSubsidy = z.output<typeof RoutesSubsidy>
+
 /** A project: an app or integration within an organization. */
 export const Project = z.object({
   createdAt: z.string().check(z.describe('When the project was created (ISO 8601).')),
@@ -264,9 +385,283 @@ export const Project = z.object({
 /** Columns of the `projects` table. */
 export type Project = z.output<typeof Project>
 
+/** A per-hour request-count watermark: the running total already reported to the meter. */
+export const RequestUsageBucket = z.object({
+  bucketStart: z.string().check(z.describe('UTC hour start this bucket covers (ISO 8601).')),
+  environment: z
+    .enum(['production', 'sandbox'])
+    .check(z.describe('Environment the requests were served under; `production` or `sandbox`.')),
+  orgId: z.string().check(z.describe('Organization id (`org_…`) the requests attribute to.')),
+  reportedCount: z
+    .number()
+    .check(z.describe('Cumulative request count already reported to the meter for this bucket.')),
+  updatedAt: z.string().check(z.describe('When the watermark last advanced (ISO 8601).')),
+})
+
+/** Columns of the `request_usage_buckets` table. */
+export type RequestUsageBucket = z.output<typeof RequestUsageBucket>
+
+/** One request-count meter event: a frozen additive delta with its exactly-once state. */
+export const RequestUsageMeterEvent = z.object({
+  bucketStart: z.string().check(z.describe('UTC hour start this event bills for (ISO 8601).')),
+  deltaCount: z
+    .number()
+    .check(z.describe('Frozen request count this event bills; a positive additive delta.')),
+  environment: z
+    .enum(['production', 'sandbox'])
+    .check(z.describe('Environment the requests were served under; `production` or `sandbox`.')),
+  error: z.nullable(z.string()).check(z.describe('Last failure detail while `pending`, or null.')),
+  firstAttemptedAt: z.string().check(z.describe('When this event was first claimed (ISO 8601).')),
+  identifier: z
+    .string()
+    .check(z.describe('Deterministic id; also the Stripe meter-event identifier and idempotency key.')), // prettier-ignore
+  orgId: z.string().check(z.describe('Organization id (`org_…`) the requests attribute to.')),
+  reason: z
+    .nullable(z.string())
+    .check(z.describe('Skip reason when `state` is `skipped` (`no_customer` | `customer_canceled`), or null.')), // prettier-ignore
+  reportedAt: z
+    .nullable(z.string())
+    .check(z.describe('When Stripe acknowledged the event (ISO 8601), or null.')),
+  sequence: z
+    .number()
+    .check(z.describe('Reported-count watermark observed when this delta was claimed.')),
+  state: z
+    .enum(['pending', 'reported', 'skipped'])
+    .check(z.describe('Exactly-once state: `pending` retries, `reported` is done, `skipped` is audited.')), // prettier-ignore
+  stripeCustomerId: z.string().check(z.describe('Stripe customer id the event bills against.')),
+})
+
+/** Columns of the `request_usage_meter_events` table. */
+export type RequestUsageMeterEvent = z.output<typeof RequestUsageMeterEvent>
+
+/** One reward campaign bound to a verified Earn vault. */
+export const RewardCampaign = z.object({
+  assetAddress: z.custom<Address>().check(z.describe('Vault base-asset address (lowercase).')),
+  assetDecimals: z
+    .number()
+    .check(z.int(), z.nonnegative(), z.lte(255), z.describe('Vault base-asset decimals.')),
+  chainId: z.number().check(z.int(), z.positive(), z.describe('Chain containing the vault.')),
+  config: z.custom<Campaigns.Config>().check(z.describe('Active campaign configuration.')),
+  controllerAddress: z
+    .nullable(z.custom<Address>())
+    .check(z.describe('Target-yield controller, or null.')),
+  createdAt: z.string().check(z.describe('When the campaign was created (ISO 8601).')),
+  deliveredThrough: z.string().check(z.regex(/^\d+$/), z.describe('Last delivered Unix boundary.')),
+  distributorAddress: z
+    .nullable(z.custom<Address>())
+    .check(z.describe('Merkle distributor, or null.')),
+  earnShareAddress: z.custom<Address>().check(z.describe('Vault EarnShare address (lowercase).')),
+  earnShareDecimals: z
+    .number()
+    .check(z.int(), z.nonnegative(), z.lte(255), z.describe('Vault EarnShare decimals.')),
+  eventCursor: z
+    .nullable(z.custom<Campaigns.EventCursor>())
+    .check(z.describe('Last applied TIDX event, or null.')),
+  paused: z.boolean().check(z.describe('Whether new campaign work is paused.')),
+  pendingConfig: z
+    .nullable(z.custom<Campaigns.Config>())
+    .check(z.describe('Future configuration, or null.')),
+  pendingEffectiveAt: z.nullable(z.string()).check(z.describe('Pending Unix boundary, or null.')),
+  provisioningError: z
+    .nullable(z.string())
+    .check(z.describe('Actionable provisioning error, or null.')),
+  signerAddress: z
+    .nullable(z.custom<Address>())
+    .check(z.describe('Signer permanently bound when reward periphery is first provisioned.')),
+  updatedAt: z.string().check(z.describe('When campaign state last changed (ISO 8601).')),
+  vaultAddress: z.custom<Address>().check(z.describe('Verified EarnVault address (lowercase).')),
+})
+
+/** Columns of the `reward_campaigns` table. */
+export type RewardCampaign = z.output<typeof RewardCampaign>
+
+/** One verified reward distributor retained for historical payout recognition. */
+export const RewardCampaignDistributor = z.object({
+  chainId: z.number().check(z.int(), z.positive(), z.describe('Chain containing the vault.')),
+  createdAt: z.string().check(z.describe('When the distributor was first recorded (ISO 8601).')),
+  distributorAddress: z.custom<Address>().check(z.describe('Verified reward distributor address.')),
+  vaultAddress: z.custom<Address>().check(z.describe('Verified EarnVault address (lowercase).')),
+})
+
+/** Columns of the `reward_campaign_distributors` table. */
+export type RewardCampaignDistributor = z.output<typeof RewardCampaignDistributor>
+
+/** One current delivered recipient projection. */
+export const RewardAccount = z.object({
+  accrualRemainder: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Carried reward arithmetic remainder.')),
+  allocatedPrincipalAssets: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Principal allocated against campaign caps.')),
+  chainId: z.number().check(z.int(), z.positive(), z.describe('Chain containing the vault.')),
+  cumulativeEntitlement: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Cumulative EarnShare entitlement.')),
+  cumulativePaid: z.string().check(z.regex(/^\d+$/), z.describe('Cumulative EarnShare paid.')),
+  deferral: z.nullable(z.string()).check(z.describe('Current payout deferral reason, or null.')),
+  eligibilityRegisteredAt: z
+    .nullable(z.string())
+    .check(z.describe('Eligibility registration version consumed by this projection.')),
+  lots: z
+    .array(z.custom<Campaigns.DepositLot>())
+    .check(z.describe('Surviving qualified deposit lots.')),
+  pendingRewardAssets: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Unsettled base-asset reward units.')),
+  publicEarnShares: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Current attributable public EarnShare balance.')),
+  qualifiedEarnShares: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Current qualified EarnShare balance.')),
+  recipient: z.custom<Address>().check(z.describe('Registered reward recipient (lowercase).')),
+  registrationOrder: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Eligibility registration order.')),
+  updatedAt: z.string().check(z.describe('When delivered account state last changed (ISO 8601).')),
+  vaultAddress: z.custom<Address>().check(z.describe('EarnVault address (lowercase).')),
+})
+
+/** Columns of the `reward_accounts` table. */
+export type RewardAccount = z.output<typeof RewardAccount>
+
+/** One run-once manual reward credit added to a recipient's pending rewards. */
+export const RewardCredit = z.object({
+  assets: z.string().check(z.regex(/^\d+$/), z.describe('Credited base-asset reward units.')),
+  chainId: z.number().check(z.int(), z.positive(), z.describe('Chain containing the vault.')),
+  createdAt: z.string().check(z.describe('When the credit was applied (ISO 8601).')),
+  recipient: z.custom<Address>().check(z.describe('Credited reward recipient (lowercase).')),
+  reference: z
+    .string()
+    .check(z.describe('Operator reference identifying the credit batch; unique per recipient.')),
+  vaultAddress: z.custom<Address>().check(z.describe('EarnVault address (lowercase).')),
+})
+
+/** Columns of the `reward_credits` table. */
+export type RewardCredit = z.output<typeof RewardCredit>
+
+/** One durable reward execution. */
+export const RewardRun = z.object({
+  chainId: z.number().check(z.int(), z.positive(), z.describe('Chain containing the vault.')),
+  config: z
+    .custom<Campaigns.Config>()
+    .check(z.describe('Configuration snapshot consumed by the run.')),
+  createdAt: z.string().check(z.describe('When the run was created (ISO 8601).')),
+  endsAt: z.string().check(z.regex(/^\d+$/), z.describe('Exclusive final Unix boundary.')),
+  error: z.nullable(z.string()).check(z.describe('Actionable run error, or null.')),
+  evidence: z
+    .nullable(z.custom<Campaigns.RunEvidence>())
+    .check(z.describe('Resumable or completed calculation evidence, or null.')),
+  fence: z.string().check(z.regex(/^\d+$/), z.describe('Monotonic lease fencing token.')),
+  fundedAssets: z
+    .nullable(z.string())
+    .check(z.describe('Base assets pulled for boost settlement, or null.')),
+  id: z.string().check(z.describe('Opaque reward run id (`rrn_…`).')),
+  leaseExpiresAt: z
+    .nullable(z.string())
+    .check(z.describe('Worker lease expiry (ISO 8601), or null.')),
+  liability: z
+    .nullable(z.string())
+    .check(z.describe('Published cumulative EarnShare liability, or null.')),
+  mintedEarnShares: z.nullable(z.string()).check(z.describe('Measured EarnShare mint, or null.')),
+  phase: z
+    .enum([
+      'indexing',
+      'calculating',
+      'targetYield',
+      'statement',
+      'settling',
+      'publishing',
+      'paying',
+      'delivered',
+      'failed',
+    ])
+    .check(z.describe('Recoverable execution phase.')),
+  root: z.nullable(z.custom<Hex.Hex>()).check(z.describe('Published Merkle root, or null.')),
+  rootVersion: z.nullable(z.string()).check(z.describe('Published root version, or null.')),
+  startsAfter: z
+    .string()
+    .check(z.regex(/^\d+$/), z.describe('Previously delivered Unix boundary.')),
+  statement: z
+    .nullable(z.custom<Campaigns.Statement>())
+    .check(z.describe('Latest cumulative statement, or null.')),
+  statementHash: z
+    .nullable(z.custom<Hex.Hex>())
+    .check(z.describe('Statement content hash, or null.')),
+  updatedAt: z.string().check(z.describe('When run state last changed (ISO 8601).')),
+  vaultAddress: z.custom<Address>().check(z.describe('EarnVault address (lowercase).')),
+})
+
+/** Columns of the `reward_runs` table. */
+export type RewardRun = z.output<typeof RewardRun>
+
+/** One append-only signed reward transaction attempt. */
+export const RewardTransactionAttempt = z.object({
+  chainId: z.number().check(z.int(), z.positive(), z.describe('Chain receiving the transaction.')),
+  confirmedBlockHash: z
+    .nullable(z.custom<Hex.Hex>())
+    .check(z.describe('Confirmed canonical block hash, or null.')),
+  createdAt: z.string().check(z.describe('When the attempt was created (ISO 8601).')),
+  expiresAt: z
+    .nullable(z.string())
+    .check(z.describe('Expiring nonce deadline (ISO 8601), or null.')),
+  id: z.string().check(z.describe('Opaque transaction attempt id (`rat_…`).')),
+  intent: z.custom<Campaigns.TransactionIntent>().check(z.describe('Typed signer intent.')),
+  intentId: z.custom<Hex.Hex>().check(z.describe('Deterministic typed intent id.')),
+  nonce: z.nullable(z.string()).check(z.describe('Signer nonce, or null before signing.')),
+  receipt: z
+    .nullable(z.custom<Campaigns.TransactionReceipt>())
+    .check(z.describe('Canonical receipt, or null.')),
+  replacementOf: z.nullable(z.string()).check(z.describe('Replaced attempt id, or null.')),
+  runId: z
+    .nullable(z.string())
+    .check(z.describe('Owning reward run id, or null for provisioning.')),
+  signedBytes: z
+    .nullable(z.custom<Hex.Hex>())
+    .check(z.describe('Exact signed transaction bytes, or null.')),
+  signer: z.custom<Address>().check(z.describe('Signing account (lowercase).')),
+  state: z
+    .enum(['created', 'signed', 'broadcast', 'confirmed', 'expired', 'ineffective', 'reverted'])
+    .check(z.describe('Attempt lifecycle state.')),
+  transactionHash: z.nullable(z.custom<Hex.Hex>()).check(z.describe('Transaction hash, or null.')),
+  updatedAt: z.string().check(z.describe('When attempt state last changed (ISO 8601).')),
+  vaultAddress: z.custom<Address>().check(z.describe('Bound EarnVault address (lowercase).')),
+})
+
+/** Columns of the `reward_transaction_attempts` table. */
+export type RewardTransactionAttempt = z.output<typeof RewardTransactionAttempt>
+
+/** One wallet and Earn vault association eligible for rewards. */
+export const RewardEligibilityAssociation = z
+  .object({
+    chainId: z.number().check(z.int(), z.positive(), z.describe('Chain containing the vault.')),
+    firstRegisteredAt: z
+      .string()
+      .check(z.describe('When the association was first registered (ISO 8601).')),
+    latestRegisteredAt: z
+      .string()
+      .check(z.describe('When the association was most recently registered (ISO 8601).')),
+    registrationOrder: z
+      .string()
+      .check(z.regex(/^\d+$/), z.describe('Monotonic registration order.')),
+    transactionHash: z.optional(
+      z.custom<Hex.Hex>().check(z.describe('Latest registration transaction hash.')),
+    ),
+    vaultAddress: z.custom<Address>().check(z.describe('Earn vault address (lowercase).')),
+    walletAddress: z.custom<Address>().check(z.describe('Eligible wallet address (lowercase).')),
+  })
+  .check(z.describe('One persisted reward eligibility association.'))
+
+/** Columns of the `reward_eligibility_associations` table. */
+export type RewardEligibilityAssociation = z.output<typeof RewardEligibilityAssociation>
+
 /** A transaction sponsored by the managed fee payer — the billable unit of fee payer spend. */
 export const SponsoredTransaction = z.object({
   apiKeyId: z.string().check(z.describe('API key id (`key_…`) that requested sponsorship.')),
+  sponsorshipAttributionId: z
+    .nullable(z.string())
+    .check(z.describe('Canonical sponsorship attribution id snapshotted at sponsorship, or null.')),
   billable: z
     .boolean()
     .check(z.describe('Whether the sponsorship accrues billable spend; false for sandbox.')),
@@ -287,6 +682,9 @@ export const SponsoredTransaction = z.object({
   feeToken: z
     .nullable(z.string())
     .check(z.describe('Fee token address, or null when the chain default applied.')),
+  finalizationAttemptedAt: z
+    .nullable(z.string())
+    .check(z.describe('When finalization last claimed this pending row (ISO 8601), or null.')),
   finalizedAt: z
     .nullable(z.string())
     .check(z.describe('When the sponsorship reached a terminal status (ISO 8601), or null.')),
@@ -320,54 +718,51 @@ export const SponsoredTransaction = z.object({
 /** Columns of the `sponsored_transactions` table. */
 export type SponsoredTransaction = z.output<typeof SponsoredTransaction>
 
-/** A per-hour request-count watermark: the running total already reported to the meter. */
-export const RequestUsageBucket = z.object({
-  bucketStart: z.string().check(z.describe('UTC hour start this bucket covers (ISO 8601).')),
-  environment: z
-    .enum(['production', 'sandbox'])
-    .check(z.describe('Environment the requests were served under; `production` or `sandbox`.')),
-  orgId: z.string().check(z.describe('Organization id (`org_…`) the requests attribute to.')),
-  reportedCount: z
+/** Durable position for failed sponsorship reconciliation. */
+export const SponsorshipReconciliationCursor = z.object({
+  blockNumber: z.string().check(z.regex(/^\d+$/), z.describe('Last scanned block number.')),
+  chainId: z.number().check(z.int(), z.describe('Chain whose fee-payer transactions are scanned.')),
+  complete: z
+    .boolean()
+    .check(z.describe('Whether the next scan starts from the newest candidate.')),
+  feePayer: z.custom<Address>().check(z.describe('Lowercase managed fee-payer address.')),
+  retryCount: z
     .number()
-    .check(z.describe('Cumulative request count already reported to the meter for this bucket.')),
-  updatedAt: z.string().check(z.describe('When the watermark last advanced (ISO 8601).')),
+    .check(z.int(), z.nonnegative(), z.describe('Failed attempts for the blocked candidate.')),
+  retryKey: z
+    .nullable(z.string())
+    .check(z.describe('Blocked candidate block number and transaction index.')),
+  revision: z.string().check(z.describe('Revision fencing overlapping reconciliation passes.')),
+  transactionIndex: z.number().check(z.int(), z.nonnegative(), z.describe('Last scanned transaction index.')), // prettier-ignore
+  updatedAt: z.string().check(z.describe('When reconciliation saved this position (ISO 8601).')),
 })
 
-/** Columns of the `request_usage_buckets` table. */
-export type RequestUsageBucket = z.output<typeof RequestUsageBucket>
+/** Columns of the `sponsorship_reconciliation_cursors` table. */
+export type SponsorshipReconciliationCursor = z.output<typeof SponsorshipReconciliationCursor>
 
-/** One request-count meter event: a frozen additive delta with its exactly-once state. */
-export const RequestUsageMeterEvent = z.object({
-  bucketStart: z.string().check(z.describe('UTC hour start this event bills for (ISO 8601).')),
-  deltaCount: z
-    .number()
-    .check(z.describe('Frozen request count this event bills; a positive additive delta.')),
-  environment: z
-    .enum(['production', 'sandbox'])
-    .check(z.describe('Environment the requests were served under; `production` or `sandbox`.')),
-  error: z.nullable(z.string()).check(z.describe('Last failure detail while `pending`, or null.')),
-  firstAttemptedAt: z.string().check(z.describe('When this event was first claimed (ISO 8601).')),
-  identifier: z
-    .string()
-    .check(z.describe('Deterministic id; also the Stripe meter-event identifier and idempotency key.')), // prettier-ignore
-  orgId: z.string().check(z.describe('Organization id (`org_…`) the requests attribute to.')),
-  reason: z
+/** A canonical sponsorship attribution resolved from an external id or Tempo Project. */
+export const SponsorshipAttribution = z.object({
+  createdAt: z.string().check(z.describe('When the attribution was created (ISO 8601).')),
+  endsAt: z
     .nullable(z.string())
-    .check(z.describe('Skip reason when `state` is `skipped` (`no_customer` | `customer_canceled`), or null.')), // prettier-ignore
-  reportedAt: z
+    .check(z.describe('When promotional sponsorship ends (ISO 8601), or null before activation.')),
+  externalId: z.nullable(z.string()).check(z.describe('External partner attribution id, or null.')),
+  id: z.string().check(z.describe('Sponsorship attribution id (`sat_…`).')),
+  orgId: z.string().check(z.describe('Owning Tempo organization id (`org_…`).')),
+  projectId: z.nullable(z.string()).check(z.describe('Tempo Project id (`prj_…`), or null.')),
+  spendLimit: z
     .nullable(z.string())
-    .check(z.describe('When Stripe acknowledged the event (ISO 8601), or null.')),
-  sequence: z
-    .number()
-    .check(z.describe('Reported-count watermark observed when this delta was claimed.')),
-  state: z
-    .enum(['pending', 'reported', 'skipped'])
-    .check(z.describe('Exactly-once state: `pending` retries, `reported` is done, `skipped` is audited.')), // prettier-ignore
-  stripeCustomerId: z.string().check(z.describe('Stripe customer id the event bills against.')),
+    .check(z.describe('Promotional spend cap in fee-token base units, or null.')),
+  startsAt: z
+    .nullable(z.string())
+    .check(
+      z.describe('When promotional sponsorship started (ISO 8601), or null before activation.'),
+    ),
+  updatedAt: z.string().check(z.describe('When the attribution was last updated (ISO 8601).')),
 })
 
-/** Columns of the `request_usage_meter_events` table. */
-export type RequestUsageMeterEvent = z.output<typeof RequestUsageMeterEvent>
+/** Columns of the `sponsorship_attributions` table. */
+export type SponsorshipAttribution = z.output<typeof SponsorshipAttribution>
 
 /** An organization's Stripe billing source: the customer link and derived status. */
 export const StripeCustomer = z.object({
@@ -400,106 +795,111 @@ export const User = z.object({
   createdAt: z.string().check(z.describe('When the user was created (ISO 8601).')),
   email: z
     .nullable(z.string())
-    .check(z.describe('Verified email from the wallet identity token, or null.')),
+    .check(z.describe('Normalized verified email, or null for a wallet-only identity.')),
+  emailVerified: z.boolean().check(z.describe('Whether the email was verified.')),
   id: z
     .string()
     .check(
       z.describe('Opaque user id (`usr_…`).'),
       z.meta({ examples: ['usr_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
     ),
+  image: z.nullable(z.string()).check(z.describe('Profile image URL, or null.')),
+  name: z.string().check(z.describe('Display name.')),
   updatedAt: z.string().check(z.describe('When the user was last updated (ISO 8601).')),
 })
 
 /** Columns of the `users` table. */
 export type User = z.output<typeof User>
 
-/** Metadata for the current funding catalog snapshot. */
-export const FundingCatalog = z.object({
-  id: z.string().check(z.describe('Singleton funding catalog id.')),
-  updatedAt: z.string().check(z.describe('When the funding catalog was last published.')),
-  version: z.string().check(z.describe('Opaque funding catalog version.')),
+/** Metadata for the current route catalog snapshot. */
+export const RoutesCatalog = z.object({
+  id: z.string().check(z.describe('Singleton route catalog id.')),
+  updatedAt: z.string().check(z.describe('When the route catalog was last published.')),
+  version: z.string().check(z.describe('Opaque route catalog version.')),
 })
 
-/** Columns of the `funding_catalogs` table. */
-export type FundingCatalog = z.output<typeof FundingCatalog>
+/** Columns of the `routes_catalogs` table. */
+export type RoutesCatalog = z.output<typeof RoutesCatalog>
 
-/** One chain available to the funding catalog. */
-export const FundingChain = z.object({
+/** One chain available to the route catalog. */
+export const RoutesChain = z.object({
   aliases: z
     .readonly(z.array(z.string()))
-    .check(z.describe('Caller-facing aliases accepted for the funding chain.')),
-  id: z.string().check(z.describe('CAIP-2 funding chain identifier.')),
-  name: z.string().check(z.describe('Human-readable funding chain name.')),
+    .check(z.describe('Caller-facing aliases accepted for the route chain.')),
+  id: z.string().check(z.describe('CAIP-2 route chain identifier.')),
+  name: z.string().check(z.describe('Human-readable route chain name.')),
   parentChainId: z
     .nullable(z.string())
-    .check(z.describe('Parent funding chain identifier for a Zone, or null.')),
+    .check(z.describe('Parent route chain identifier for a Zone, or null.')),
   rpcUrls: z
     ._default(z.readonly(z.array(z.url())), [])
-    .check(z.describe('Public RPC endpoints used for funding-chain evidence.')),
-  slug: z.string().check(z.describe('Stable funding chain slug.')),
+    .check(z.describe('Public RPC endpoints used for routes-chain evidence.')),
+  slug: z.string().check(z.describe('Stable route chain slug.')),
 })
 
-/** Columns of the `funding_chains` table. */
-export type FundingChain = z.output<typeof FundingChain>
+/** Columns of the `routes_chains` table. */
+export type RoutesChain = z.output<typeof RoutesChain>
 
-/** One token available to the funding catalog. */
-export const FundingToken = z.object({
+/** One token available to the route catalog. */
+export const RoutesToken = z.object({
   currency: z.string().check(z.describe('Monetary denomination represented by the token.')),
-  id: z.string().check(z.describe('Stable funding token identifier.')),
-  name: z.string().check(z.describe('Human-readable funding token name.')),
-  symbol: z.string().check(z.describe('Funding token ticker symbol.')),
+  id: z.string().check(z.describe('Stable route token identifier.')),
+  name: z.string().check(z.describe('Human-readable route token name.')),
+  symbol: z.string().check(z.describe('Route token ticker symbol.')),
 })
 
-/** Columns of the `funding_tokens` table. */
-export type FundingToken = z.output<typeof FundingToken>
+/** Columns of the `routes_tokens` table. */
+export type RoutesToken = z.output<typeof RoutesToken>
 
-/** Chain-specific metadata for one funding token. */
-export const FundingChainToken = z.object({
-  address: z.string().check(z.describe('Token address on the funding chain.')),
-  chainId: z.string().check(z.describe('CAIP-2 identifier of the funding chain.')),
+/** Chain-specific metadata for one route token. */
+export const RoutesChainToken = z.object({
+  address: z.string().check(z.describe('Token address on the route chain.')),
+  chainId: z.string().check(z.describe('CAIP-2 identifier of the route chain.')),
   decimals: z.number().check(z.int(), z.nonnegative(), z.describe('Token decimal precision.')),
   name: z.nullable(z.string()).check(z.describe('Chain-specific token name override, or null.')),
-  standard: z.string().check(z.describe('Token standard on the funding chain.')),
-  tokenId: z.string().check(z.describe('Stable funding token identifier.')),
+  standard: z.string().check(z.describe('Token standard on the route chain.')),
+  tokenId: z.string().check(z.describe('Stable route token identifier.')),
 })
 
-/** Columns of the `funding_chain_tokens` table. */
-export type FundingChainToken = z.output<typeof FundingChainToken>
+/** Columns of the `routes_chain_tokens` table. */
+export type RoutesChainToken = z.output<typeof RoutesChainToken>
 
-/** One source-to-destination route supported by a funding provider. */
-export const FundingRoute = z.object({
+/** One source-to-destination route supported by a route provider. */
+export const RoutesRoute = z.object({
   capabilities: z
-    .nullable(z.custom<funding_Catalog.Capabilities>())
+    .nullable(z.custom<routes_Catalog.Capabilities>())
     .check(z.describe('Executable capability (`jsonb`), or null for indicative-only routes.')),
   configuration: z
-    .nullable(z.custom<funding_Catalog.Configuration>())
+    .nullable(z.custom<routes_Catalog.Configuration>())
     .check(z.describe('Provider-specific route configuration (`jsonb`), or null.')),
-  destinationChainId: z.string().check(z.describe('Destination funding chain identifier.')),
-  destinationTokenId: z.string().check(z.describe('Destination funding token identifier.')),
-  providerId: z.string().check(z.describe('Funding provider identifier.')),
-  sourceChainId: z.string().check(z.describe('Source funding chain identifier.')),
-  sourceTokenId: z.string().check(z.describe('Source funding token identifier.')),
+  destinationChainId: z.string().check(z.describe('Destination route chain identifier.')),
+  destinationTokenId: z.string().check(z.describe('Destination route token identifier.')),
+  providerId: z.string().check(z.describe('Route provider identifier.')),
+  sourceChainId: z.string().check(z.describe('Source route chain identifier.')),
+  sourceTokenId: z.string().check(z.describe('Source route token identifier.')),
 })
 
-/** Columns of the `funding_routes` table. */
-export type FundingRoute = z.output<typeof FundingRoute>
+/** Columns of the `routes_routes` table. */
+export type RoutesRoute = z.output<typeof RoutesRoute>
 
 /**
- * A reusable funding deposit address. Public route fields live in `snapshot`;
+ * A reusable route deposit address. Public route fields live in `snapshot`;
  * provider routing and correlation remain private.
  */
-export const FundingDepositAddress = z.object({
+export const RoutesDepositAddress = z.object({
   address: z.string().check(z.describe('Reusable source-chain deposit address.')),
-  apiKeyId: z.string().check(z.describe('API key id (`key_…`) that provisioned the address.')),
   createdAt: z.string().check(z.describe('When the address was created (ISO 8601).')),
+  creatorUserId: z
+    .nullable(z.string())
+    .check(z.describe('Canonical creator user retained after organization deletion, or null.')),
   deliveryStrategy: z
-    .custom<funding_DepositAddress.DeliveryStrategy>()
+    .custom<routes_DepositAddress.DeliveryStrategy>()
     .check(z.describe('Whether the provider or Tempo delivers the requested destination token.')),
   destinationTokenKey: z.string().check(z.describe('Customer destination token key.')),
   environment: z
     .enum(['production', 'sandbox'])
     .check(z.describe('Key environment the address belongs to.')),
-  id: z.string().check(z.describe('Funding deposit address id (`fda_…`).')),
+  id: z.string().check(z.describe('Route deposit address id (`rda_…`).')),
   lastPolledAt: z
     .nullable(z.string())
     .check(z.describe('When provider reconciliation last completed successfully, or null.')),
@@ -514,34 +914,37 @@ export const FundingDepositAddress = z.object({
     .check(z.int(), z.describe('Fencing token for reconciliation leases.')),
   projectId: z.nullable(z.string()).check(z.describe('Attributed project id (`prj_…`), or null.')),
   providerOutputToken: z
-    .custom<funding_Provider.TokenRef>()
+    .custom<routes_Provider.TokenRef>()
     .check(z.describe('Token that the provider outputs on Tempo (`jsonb`).')),
-  providerId: z.string().check(z.describe('Selected funding provider id.')),
+  providerId: z.string().check(z.describe('Selected route provider id.')),
   providerRequestIds: z
     .readonly(z.array(z.string()))
     .check(z.describe('Private provider request identifiers (`jsonb`).')),
   providerState: z
-    .nullable(z.custom<funding_DepositAddress.ProviderState>())
+    .nullable(z.custom<routes_DepositAddress.ProviderState>())
     .check(z.describe('Bounded private provider state (`jsonb`), or null.')),
   recipient: z.string().check(z.describe('Tempo account that receives completed deposits.')),
   refundAddress: z.string().check(z.describe('Source-chain refund address.')),
   snapshot: z
-    .custom<funding_DepositAddress.Snapshot>()
+    .custom<routes_DepositAddress.Snapshot>()
     .check(z.describe('Public address fields (`jsonb`).')),
   sourceChainId: z.string().check(z.describe('Source chain CAIP-2 id.')),
   sourceTokenKey: z.string().check(z.describe('Source token key.')),
-  status: z.custom<funding_DepositAddress.Status>().check(z.describe('Lifecycle status.')),
+  status: z.custom<routes_DepositAddress.Status>().check(z.describe('Lifecycle status.')),
+  statusUpdatedAt: z
+    .nullable(z.string())
+    .check(z.describe('When the address entered its current status, or null for legacy rows.')),
   subsidize: z.boolean().check(z.describe('Whether Tempo guarantees normalized 1:1 delivery.')),
   updatedAt: z.string().check(z.describe('When the address last materially changed (ISO 8601).')),
   version: z.number().check(z.int(), z.describe('Material version used to guard updates.')),
 })
 
-/** Columns of the `funding_deposit_addresses` table. */
-export type FundingDepositAddress = z.output<typeof FundingDepositAddress>
+/** Columns of the `routes_deposit_addresses` table. */
+export type RoutesDepositAddress = z.output<typeof RoutesDepositAddress>
 
 /** First Tempo observations of one provider request through polling and webhooks. */
-export const FundingDepositRequestObservation = z.object({
-  depositAddressId: z.string().check(z.describe('Funding deposit address id (`fda_…`).')),
+export const RoutesDepositRequestObservation = z.object({
+  depositAddressId: z.string().check(z.describe('Route deposit address id (`rda_…`).')),
   pollObservedAt: z
     .nullable(z.string())
     .check(z.describe('When polling first observed the provider request, or null.')),
@@ -551,33 +954,36 @@ export const FundingDepositRequestObservation = z.object({
     .check(z.describe('When Tempo first received an authenticated webhook, or null.')),
 })
 
-/** Columns of the `funding_deposit_request_observations` table. */
-export type FundingDepositRequestObservation = z.output<typeof FundingDepositRequestObservation>
+/** Columns of the `routes_deposit_request_observations` table. */
+export type RoutesDepositRequestObservation = z.output<typeof RoutesDepositRequestObservation>
 
 /**
  * One provider-observed deposit. Public route and evidence live in `snapshot`;
  * reconciliation and settlement state is private.
  */
-export const FundingDeposit = z.object({
+export const RoutesDeposit = z.object({
   createdAt: z.string().check(z.describe('When the deposit was detected (ISO 8601).')),
-  depositAddressId: z.string().check(z.describe('Funding deposit address id (`fda_…`).')),
+  depositAddressId: z.string().check(z.describe('Route deposit address id (`rda_…`).')),
   detectionTrigger: z
-    .nullable(z.custom<funding_Deposit.DetectionTrigger>())
+    .nullable(z.custom<routes_Deposit.DetectionTrigger>())
     .check(z.describe('Mechanism that first detected the deposit, or null for legacy rows.')),
   environment: z
     .enum(['production', 'sandbox'])
     .check(z.describe('Key environment inherited from the deposit address.')),
-  id: z.string().check(z.describe('Funding deposit id (`fdp_…`).')),
+  id: z.string().check(z.describe('Route deposit id (`rdp_…`).')),
   orgId: z.string().check(z.describe('Owning organization id (`org_…`).')),
   pollObservedAt: z
     .nullable(z.string())
     .check(z.describe('When polling first observed the provider request, or null.')),
   projectId: z.nullable(z.string()).check(z.describe('Attributed project id (`prj_…`), or null.')),
+  providerDeliveredAt: z
+    .nullable(z.string())
+    .check(z.describe('When provider delivery was first verified, or null.')),
   providerOutputAmount: z
     .nullable(z.custom<z.output<typeof internal_Schema.TokenAmount>>())
     .check(z.describe('Provider output amount verified on Tempo (`jsonb`), or null.')),
   providerOutputToken: z
-    .custom<funding_Provider.TokenRef>()
+    .custom<routes_Provider.TokenRef>()
     .check(z.describe('Token output by the provider on Tempo (`jsonb`).')),
   providerRequestId: z
     .nullable(z.string())
@@ -586,8 +992,11 @@ export const FundingDeposit = z.object({
     .readonly(z.array(z.string()))
     .check(z.describe('Private provider request identifiers (`jsonb`).')),
   providerState: z
-    .nullable(z.custom<funding_Deposit.PrivateState>())
+    .nullable(z.custom<routes_Deposit.PrivateState>())
     .check(z.describe('Bounded private provider state (`jsonb`), or null.')),
+  providerSubsidy: z
+    .nullable(z.custom<routes_Provider.Subsidy>())
+    .check(z.describe('Provider-paid subsidy amount and token (`jsonb`), or null.')),
   providerTransactionHashes: z
     .readonly(z.array(z.string()))
     .check(z.describe('Private provider-leg transaction references (`jsonb`).')),
@@ -595,7 +1004,7 @@ export const FundingDeposit = z.object({
     .number()
     .check(z.int(), z.nonnegative(), z.describe('Deposit position within the provider request.')),
   retryState: z
-    .nullable(z.custom<funding_Deposit.PrivateState>())
+    .nullable(z.custom<routes_Deposit.PrivateState>())
     .check(z.describe('Bounded private retry state (`jsonb`), or null.')),
   settlementTransaction: z
     .nullable(z.string())
@@ -604,7 +1013,7 @@ export const FundingDeposit = z.object({
     .nullable(z.string())
     .check(z.describe('Persisted settlement transaction hash, or null.')),
   snapshot: z
-    .custom<funding_Deposit.Snapshot>()
+    .custom<routes_Deposit.Snapshot>()
     .check(z.describe('Public deposit fields (`jsonb`).')),
   sourceChainId: z.string().check(z.describe('Source chain CAIP-2 id.')),
   sourceTransactionHash: z
@@ -613,13 +1022,19 @@ export const FundingDeposit = z.object({
   sourceTransferIndex: z
     .nullable(z.number().check(z.int()))
     .check(z.describe('Verified transfer position in the source transaction, or null.')),
-  status: z.custom<funding_Deposit.Status>().check(z.describe('Lifecycle status.')),
+  status: z.custom<routes_Deposit.Status>().check(z.describe('Lifecycle status.')),
   statusReason: z
-    .nullable(z.custom<funding_Deposit.StatusReason>())
+    .nullable(z.custom<routes_Deposit.StatusReason>())
     .check(z.describe('Customer-safe status reason (`jsonb`), or null.')),
+  statusUpdatedAt: z
+    .nullable(z.string())
+    .check(z.describe('When the deposit entered its current status, or null for legacy rows.')),
   subsidyAmount: z
     .nullable(z.custom<z.output<typeof internal_Schema.TokenAmount>>())
     .check(z.describe('Destination token amount supplied by Tempo (`jsonb`), or null.')),
+  subsidyMeterReportedAt: z
+    .nullable(z.string())
+    .check(z.describe('Effective Stripe meter-event time, or null before acknowledgement.')),
   tempoGasPaid: z.nullable(z.string()).check(z.describe('Tempo gas paid for settlement, or null.')),
   updatedAt: z.string().check(z.describe('When the deposit last materially changed (ISO 8601).')),
   version: z.number().check(z.int(), z.describe('Material version used to guard updates.')),
@@ -628,93 +1043,179 @@ export const FundingDeposit = z.object({
     .check(z.describe('When Tempo first received an authenticated provider webhook, or null.')),
 })
 
-/** Columns of the `funding_deposits` table. */
-export type FundingDeposit = z.output<typeof FundingDeposit>
+/** Columns of the `routes_deposits` table. */
+export type RoutesDeposit = z.output<typeof RoutesDeposit>
 
 /**
- * A durable funding transfer. Lifecycle state lives in typed columns; the
+ * A durable route transfer. Lifecycle state lives in typed columns; the
  * public quote terms and reconciled fields live in the `snapshot` jsonb and
  * merge in at serialization (`Transfer.toPublic`).
  */
-export const FundingTransfer = z.object({
+export const RoutesTransfer = z.object({
   apiKeyId: z.string().check(z.describe('API key id (`key_…`) that created the transfer.')),
   createdAt: z.string().check(z.describe('When the transfer was created (ISO 8601).')),
   environment: z
     .enum(['production', 'sandbox'])
     .check(z.describe('Key environment the transfer belongs to.')),
-  id: z.string().check(z.describe('Transfer id (`ftr_…`, lexically time-ordered).')),
+  id: z.string().check(z.describe('Transfer id (`rtr_…`, lexically time-ordered).')),
   method: z
-    .custom<funding_Transfer.Snapshot['method']>()
-    .check(z.describe('Funding method selected at creation.')),
+    .custom<routes_Transfer.Snapshot['method']>()
+    .check(z.describe('Route method selected at creation.')),
   mode: z
-    .custom<funding_Transfer.Snapshot['mode']>()
+    .custom<routes_Transfer.Snapshot['mode']>()
     .check(z.describe('Amount mode selected at creation.')),
   orgId: z.string().check(z.describe('Owning organization id (`org_…`).')),
   projectId: z
     .nullable(z.string())
     .check(z.describe('Attributed project id (`prj_…`), or null for organization-attributed keys.')), // prettier-ignore
-  providerId: z.string().check(z.describe('Selected funding provider id.')),
+  providerDeliveredAt: z
+    .nullable(z.string())
+    .check(z.describe('When destination provider delivery was first verified, or null.')),
+  providerId: z.string().check(z.describe('Selected route provider id.')),
   providerState: z
-    .nullable(z.custom<funding_Transfer.ProviderState>())
+    .nullable(z.custom<routes_Transfer.ProviderState>())
     .check(z.describe('Private provider state (`jsonb`), or null. Never serialized publicly.')), // prettier-ignore
   quoteExpiresAt: z
     .string()
     .check(z.describe('When the quoted terms stop being executable (ISO 8601).')),
   snapshot: z
-    .custom<funding_Transfer.Snapshot>()
+    .custom<routes_Transfer.Snapshot>()
     .check(z.describe('Public quote terms and reconciled fields (`jsonb`).')),
-  status: z.custom<funding_Transfer.Status>().check(z.describe('Lifecycle status.')),
+  status: z.custom<routes_Transfer.Status>().check(z.describe('Lifecycle status.')),
   statusReason: z
-    .nullable(z.custom<funding_Transfer.StatusReason>())
+    .nullable(z.custom<routes_Transfer.StatusReason>())
     .check(z.describe('Customer-safe status reason (`jsonb`), or null.')),
+  statusUpdatedAt: z
+    .nullable(z.string())
+    .check(z.describe('When the transfer entered its current status, or null for legacy rows.')),
+  subsidyAccount: z
+    .nullable(z.string())
+    .check(z.describe('Destination subsidy signer address, or null before reservation.')),
+  subsidyAmount: z
+    .nullable(z.custom<z.output<typeof internal_Schema.TokenAmount>>())
+    .check(z.describe('Destination token amount supplied by Tempo (`jsonb`), or null.')),
+  subsidyChainId: z
+    .nullable(z.string())
+    .check(z.describe('Destination subsidy chain id, or null before reservation.')),
+  subsidyCommitmentAmount: z
+    .nullable(z.custom<z.output<typeof internal_Schema.TokenAmount>>())
+    .check(z.describe('Maximum destination subsidy authorized at action creation, or null.')),
+  subsidyMeterReportedAt: z
+    .nullable(z.string())
+    .check(z.describe('Effective Stripe meter-event time, or null before acknowledgement.')),
+  subsidyNativeAmount: z
+    .nullable(z.string())
+    .check(z.describe('Native gas amount reserved by the signed transaction, or null.')),
+  subsidyTokenAddress: z
+    .nullable(z.string())
+    .check(z.describe('Destination subsidy token address, or null before reservation.')),
+  subsidyTransactionHash: z
+    .nullable(z.string())
+    .check(z.describe('Persisted destination subsidy transaction hash, or null.')),
   updatedAt: z.string().check(z.describe('When the transfer last materially changed (ISO 8601).')),
   version: z
     .number()
     .check(z.int(), z.describe('Increments on every material change; guards transitions.')),
 })
 
-/** Columns of the `funding_transfers` table. */
-export type FundingTransfer = z.output<typeof FundingTransfer>
+/** Columns of the `routes_transfers` table. */
+export type RoutesTransfer = z.output<typeof RoutesTransfer>
 
-/** One immutable public snapshot of a funding transfer at a material version. */
-export const FundingTransferEvent = z.object({
+/** One immutable public snapshot of a route transfer at a material version. */
+export const RoutesTransferEvent = z.object({
   createdAt: z.string().check(z.describe('When the version was committed (ISO 8601).')),
   snapshot: z
-    .custom<funding_Transfer.Public>()
+    .custom<routes_Transfer.Public>()
     .check(z.describe('The complete public transfer at this version (`jsonb`).')),
-  status: z.custom<funding_Transfer.Status>().check(z.describe('Status at this version.')),
-  transferId: z.string().check(z.describe('Transfer id (`ftr_…`) the event belongs to.')),
+  status: z.custom<routes_Transfer.Status>().check(z.describe('Status at this version.')),
+  transferId: z.string().check(z.describe('Transfer id (`rtr_…`) the event belongs to.')),
   version: z.number().check(z.int(), z.describe('Material version the event records.')),
 })
 
-/** Columns of the `funding_transfer_events` table. */
-export type FundingTransferEvent = z.output<typeof FundingTransferEvent>
+/** Columns of the `routes_transfer_events` table. */
+export type RoutesTransferEvent = z.output<typeof RoutesTransferEvent>
 
-/** One verified transaction reference associated with a funding transfer. */
-export const FundingTransferTransaction = z.object({
+/** One verified transaction reference associated with a route transfer. */
+export const RoutesTransferTransaction = z.object({
   chainId: z.string().check(z.describe('CAIP-2 chain the transaction executed on.')),
   createdAt: z.string().check(z.describe('When the reference was accepted (ISO 8601).')),
+  environment: z.string().check(z.describe('Environment derived from the owning transfer.')),
+  orgId: z.string().check(z.describe('Organization derived from the owning transfer.')),
+  projectId: z.nullable(z.string()).check(z.describe('Project derived from the owning transfer.')),
   role: z
-    .custom<funding_Transfer.TransactionRole>()
+    .custom<routes_Transfer.TransactionRole>()
     .check(z.describe('What the transaction evidences: `source`, `destination`, or `refund`.')),
   transactionRef: z
     .string()
     .check(z.describe('EVM transaction hash or case-sensitive Solana signature.')),
-  transferId: z.string().check(z.describe('Transfer id (`ftr_…`) the reference belongs to.')),
+  transferId: z.string().check(z.describe('Transfer id (`rtr_…`) the reference belongs to.')),
 })
 
-/** Columns of the `funding_transfer_transactions` table. */
-export type FundingTransferTransaction = z.output<typeof FundingTransferTransaction>
+/** Columns of the `routes_transfer_transactions` table. */
+export type RoutesTransferTransaction = z.output<typeof RoutesTransferTransaction>
+
+/** One globally deduplicated destination subsidy for a verified source transaction. */
+export const RoutesTransferSubsidy = z.object({
+  createdAt: z.string().check(z.describe('When the signed subsidy was persisted (ISO 8601).')),
+  destinationChainId: z
+    .string()
+    .check(z.describe('Destination CAIP-2 chain receiving the subsidy.')),
+  recipient: z.string().check(z.describe('Lowercase destination recipient address.')),
+  sourceChainId: z
+    .string()
+    .check(z.describe('Source CAIP-2 chain containing the verified payment.')),
+  tokenAddress: z.string().check(z.describe('Lowercase destination token address.')),
+  transaction: z
+    .custom<routes_TransferSubsidy.Transaction>()
+    .check(z.describe('Signed subsidy retained for replay, including after transfer deletion.')),
+  transactionRef: z.string().check(z.describe('Canonical source execution transaction reference.')),
+  transferId: z
+    .string()
+    .check(z.describe('Transfer responsible for this subsidy and its billing.')),
+})
+
+/** Columns of the `routes_transfer_subsidies` table. */
+export type RoutesTransferSubsidy = z.output<typeof RoutesTransferSubsidy>
+
+/** One durable next nonce for a destination subsidy signer on an EVM chain. */
+export const RoutesTransferSubsidyNonce = z.object({
+  account: z.string().check(z.describe('Lowercase destination subsidy signer address.')),
+  blockedAt: z
+    .nullable(z.string())
+    .check(z.describe('When this signer lane became blocked, or null.')),
+  blockedReason: z
+    .nullable(z.literal('broadcast_rejected'))
+    .check(z.describe('Bounded reason this signer lane is blocked, or null.')),
+  blockedTransferId: z
+    .nullable(z.string())
+    .check(z.describe('Transfer holding the blocked signer nonce, or null.')),
+  chainId: z.string().check(z.describe('Destination EVM chain CAIP-2 id.')),
+  nextNonce: z.string().check(z.regex(/^\d+$/), z.describe('Next unreserved EOA nonce.')),
+  updatedAt: z.string().check(z.describe('When the nonce was last reserved (ISO 8601).')),
+})
+
+/** Columns of the `routes_transfer_subsidy_nonces` table. */
+export type RoutesTransferSubsidyNonce = z.output<typeof RoutesTransferSubsidyNonce>
 
 /**
- * An API-key-scoped idempotency claim for funding resource creation. The row
+ * An API-key-scoped idempotency claim for route resource creation. The row
  * retains recovery checkpoints and completed responses until `expiresAt`.
  */
-export const FundingIdempotencyRequest = z.object({
+export const RoutesIdempotencyRequest = z.object({
   apiKeyId: z.string().check(z.describe('API key id (`key_…`) the claim is scoped to.')),
   createdAt: z.string().check(z.describe('When the claim was taken (ISO 8601).')),
-  expiresAt: z.string().check(z.describe('When the claim stops replaying (ISO 8601).')),
+  expiresAt: z.string().check(z.describe('Scheduled claim replay expiry (ISO 8601).')),
+  irrevocable: z.boolean().check(z.describe('Whether provider success creates durable liability.')),
   keyHash: z.string().check(z.describe('SHA-256 of the caller Idempotency-Key.')),
+  matchHash: z
+    .nullable(z.string())
+    .check(z.describe('Canonical reusable deposit-address identity, or null before selection.')),
+  operation: z
+    .nullable(z.union([z.literal('deposit_address'), z.literal('transfer')]))
+    .check(z.describe('Route creation operation owning the claim, or null for legacy rows.')),
+  orgId: z
+    .nullable(z.string())
+    .check(z.describe('Organization reserving deposit-address capacity, or null.')),
   requestHash: z.string().check(z.describe('SHA-256 fingerprint of the canonical request.')),
   response: z
     .nullable(z.string())
@@ -724,11 +1225,11 @@ export const FundingIdempotencyRequest = z.object({
     .check(z.describe('Claim state for execution, recovery, or replay.')),
   transferId: z
     .nullable(z.string())
-    .check(z.describe('Transfer id (`ftr_…`) the completed claim created, or null.')),
+    .check(z.describe('Transfer id (`rtr_…`) the completed claim created, or null.')),
 })
 
-/** Columns of the `funding_idempotency_requests` table. */
-export type FundingIdempotencyRequest = z.output<typeof FundingIdempotencyRequest>
+/** Columns of the `routes_idempotency_requests` table. */
+export type RoutesIdempotencyRequest = z.output<typeof RoutesIdempotencyRequest>
 
 /**
  * A verified token: one row per curated token, ordered by `position` (list
@@ -800,64 +1301,6 @@ export const VerifiedTokenRequest = z.object({
 /** Columns of the `verified_token_requests` table. */
 export type VerifiedTokenRequest = z.output<typeof VerifiedTokenRequest>
 
-/**
- * A webhook subscription. The `Webhooks.Owner` union maps to (`ownerType`,
- * `ownerId`); jsonb object columns round-trip as parsed values. `pollerCursor`
- * replaces the old per-subscription cursor key.
- */
-export const WebhookSubscription = z.object({
-  chainId: z.number().check(z.int(), z.describe('Chain the subscription listens on.')),
-  context: z
-    .nullable(z.custom<Webhooks.Context>())
-    .check(z.describe('Human context (`jsonb`), or null.')),
-  createdAt: z.string().check(z.describe('ISO timestamp of creation.')),
-  destination: z
-    .custom<Webhooks.Destination>()
-    .check(z.describe('Delivery destination (`jsonb`).')),
-  environment: z
-    .nullable(z.enum(['production', 'sandbox']))
-    .check(z.describe('API-key environment for private resource events, or null.')),
-  eventType: z
-    .custom<Webhooks.EventType>()
-    .check(z.describe('Event type the subscription listens to.')),
-  expiresAt: z
-    .nullable(z.string())
-    .check(z.describe('ISO expiry timestamp (MPP-owned subscriptions), or null.')),
-  failureCount: z
-    .number()
-    .check(z.int(), z.describe('Consecutive delivery failures; drives auto-disable.')),
-  filters: z
-    .custom<Webhooks.Subscription['filters']>()
-    .check(z.describe('Event-type-specific filter predicates (`jsonb`).')),
-  id: z
-    .string()
-    .check(
-      z.describe('Subscription id (`wh_…`, lexically time-ordered).'),
-      z.meta({ examples: ['wh_001718668800000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
-    ),
-  lastDeliveryAt: z
-    .nullable(z.string())
-    .check(z.describe('ISO timestamp of the last successful delivery, or null.')),
-  ownerId: z
-    .string()
-    .check(z.describe('Owner identifier: `orgId` for `api_key` owners, `payer` for `mpp`.')),
-  ownerType: z.custom<Webhooks.Owner['type']>().check(z.describe('Owner kind.')),
-  pollerCursor: z
-    .nullable(z.string())
-    .check(z.describe('Poller keyset cursor, or null before the first tick.')),
-  projectId: z
-    .nullable(z.string())
-    .check(z.describe('API-key project attribution for private resource events, or null.')),
-  secret: z.string().check(z.describe('HMAC signing secret.')),
-  status: z.custom<Webhooks.Status>().check(z.describe('Lifecycle status.')),
-  updatedAt: z
-    .string()
-    .check(z.describe('ISO timestamp of the last mutation (`pollerCursor` writes excluded).')),
-})
-
-/** Columns of the `webhook_subscriptions` table. */
-export type WebhookSubscription = z.output<typeof WebhookSubscription>
-
 /**
  * A webhook delivery attempt. Rows are invisible past `expiresAt` (the
  * retention deadline that replaces the old store TTL) and pruned by the
@@ -962,3 +1405,61 @@ export const WebhookQueueEvent = z.object({
 
 /** Columns of the `webhook_queue_events` table. */
 export type WebhookQueueEvent = z.output<typeof WebhookQueueEvent>
+
+/**
+ * A webhook subscription. The `Webhooks.Owner` union maps to (`ownerType`,
+ * `ownerId`); jsonb object columns round-trip as parsed values. `pollerCursor`
+ * replaces the old per-subscription cursor key.
+ */
+export const WebhookSubscription = z.object({
+  chainId: z.number().check(z.int(), z.describe('Chain the subscription listens on.')),
+  context: z
+    .nullable(z.custom<Webhooks.Context>())
+    .check(z.describe('Human context (`jsonb`), or null.')),
+  createdAt: z.string().check(z.describe('ISO timestamp of creation.')),
+  destination: z
+    .custom<Webhooks.Destination>()
+    .check(z.describe('Delivery destination (`jsonb`).')),
+  environment: z
+    .nullable(z.enum(['production', 'sandbox']))
+    .check(z.describe('API-key environment for private resource events, or null.')),
+  eventType: z
+    .custom<Webhooks.EventType>()
+    .check(z.describe('Event type the subscription listens to.')),
+  expiresAt: z
+    .nullable(z.string())
+    .check(z.describe('ISO expiry timestamp (MPP-owned subscriptions), or null.')),
+  failureCount: z
+    .number()
+    .check(z.int(), z.describe('Consecutive delivery failures; drives auto-disable.')),
+  filters: z
+    .custom<Webhooks.Subscription['filters']>()
+    .check(z.describe('Event-type-specific filter predicates (`jsonb`).')),
+  id: z
+    .string()
+    .check(
+      z.describe('Subscription id (`wh_…`, lexically time-ordered).'),
+      z.meta({ examples: ['wh_001718668800000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
+    ),
+  lastDeliveryAt: z
+    .nullable(z.string())
+    .check(z.describe('ISO timestamp of the last successful delivery, or null.')),
+  ownerId: z
+    .string()
+    .check(z.describe('Owner identifier: `orgId` for `api_key` owners, `payer` for `mpp`.')),
+  ownerType: z.custom<Webhooks.Owner['type']>().check(z.describe('Owner kind.')),
+  pollerCursor: z
+    .nullable(z.string())
+    .check(z.describe('Poller keyset cursor, or null before the first tick.')),
+  projectId: z
+    .nullable(z.string())
+    .check(z.describe('API-key project attribution for private resource events, or null.')),
+  secret: z.string().check(z.describe('HMAC signing secret.')),
+  status: z.custom<Webhooks.Status>().check(z.describe('Lifecycle status.')),
+  updatedAt: z
+    .string()
+    .check(z.describe('ISO timestamp of the last mutation (`pollerCursor` writes excluded).')),
+})
+
+/** Columns of the `webhook_subscriptions` table. */
+export type WebhookSubscription = z.output<typeof WebhookSubscription>