@volter/twin-stripe 3.0.0 → 3.0.1

package/dist/src/semantics/shared.d.ts

@@ -1,26 +1,15 @@
 import type { EventsDecl, Handler, HandlerContext } from '@volter/world-core';
 import { type StripeAuthRequestOutcome } from '../engine/webhooks.js';
 import { type Outcome } from '../engine/after-payment.js';
-import { cardError, type CheckoutItem, declineFor, type StripeResponse } from '../engine/stripe.js';
+import { cardError, declineFor, type StripeResponse } from '../engine/stripe.js';
 import { type EnteredCard } from '../engine/checkout.js';
 import { type Find, type Row } from '../engine/common.js';
-import { type ConnectOAuthSettings } from '../engine/connect-settings.js';
 /** Stripe's events: `Stripe-Signature: t=…,v1=…` over `${t}.${body}` keyed by the endpoint's secret
  *  (docs.stripe.com/webhooks#verify-manually); the Event object (docs.stripe.com/api/events/object) kept as the account's
  *  own (`GET /v1/events`), whether or not an endpoint takes it; an endpoint live while `enabled`, taking the types its
  *  `enabled_events` names (`*` all, `<family>.*` a family), and a Connect endpoint (`connect: true`) its connected
  *  accounts' events ("Connected accounts" scope, docs.stripe.com/connect/webhooks), any other the account's own. */
 export declare const STRIPE_EVENTS: EventsDecl;
-export type Reads = Pick<HandlerContext, 'rowsRaw'>;
-/** Whether a connected account's OAuth connection to the platform was revoked (deauthorized, or its code reused). */
-export declare function connectionRevoked(ctx: Reads, account: string): boolean;
-/** The connected account an OAuth key acts as — the connection's current access_token (sk_test_oauth_…) or its
- *  stripe_publishable_key (pk_test_oauth_…) — with the scope it was issued; undefined for any other key, and null for an
- *  OAuth-shaped key no live connection holds (revoked, replaced by a refresh, or never issued). */
-export declare function oauthKeyAccount(ctx: Reads, key: string): {
-    account: string;
-    scope: string;
-} | null | undefined;
 /** A customer's now: its test clock's frozen time when it is on one (docs.stripe.com/billing/testing/test-clocks), the
  *  World's otherwise. */
 export declare function clockNow(ctx: HandlerContext, customer: unknown): number;
@@ -63,7 +52,6 @@ export declare function advanceBilling(ctx: HandlerContext, only?: (sub: Row) =>
 /** The earliest move that has come due, made at its moment; false when none has. */
 export declare function billingStep(ctx: HandlerContext, at: (t: number) => Promise<HandlerContext>, only?: (sub: Row) => boolean): Promise<boolean>;
 export declare const account: (ctx: HandlerContext) => string | undefined;
-export declare const payoutMissing: (ctx: HandlerContext, id: string) => Response;
 /** The acting account's Balance object (docs.stripe.com/api/balance/balance_object). */
 export declare function balanceBody(ctx: HandlerContext, acct?: string | undefined): Row;
 /** Time's arrivals, written: each of the acting account's payouts whose arrival date has come moves pending → paid
@@ -99,104 +87,20 @@ export declare function afterCharge(ctx: HandlerContext, chargeId: string, charg
 export declare function openReview(ctx: HandlerContext, chargeId: string, pi: {
     payment_intent: string | null;
 }): Promise<void>;
-/** The mandate a verified bank account carries for a payment (single use) or a setup (multi use). */
-export declare function mintMandate(ctx: HandlerContext, paymentMethod: unknown, use: 'single_use' | 'multi_use', amount?: number, currency?: string): Promise<string>;
 export declare const customerMissing: (ctx: HandlerContext, id: string) => Response;
-/** The discount a customer's `coupon` makes, a parameter of API versions before the served one. */
-export declare function customerDiscount(ctx: HandlerContext, couponId: string): Row | Response;
-/** A tax ID for its owner: the account itself, or one of its customers. */
-export declare function makeTaxId(ctx: HandlerContext, customer: string | undefined): Promise<Response>;
-/** The owner a top-level tax-ID call names: the account itself unless `owner[type]=customer` names a customer
- *  (docs.stripe.com/api/tax_ids/list: owner defaults to self). */
-export declare function ownerOf(ctx: HandlerContext): {
-    customer?: string;
-} | Response;
-export declare function cashBalance(ctx: HandlerContext, customer: string): Row;
-/** Automatic reconciliation (docs.stripe.com/payments/customer-balance/reconciliation): funds that arrive pay the
- *  customer's open invoices that take bank transfers (payment_method_types customer_balance), the one whose number
- *  the transfer's reference names first, then the oldest. Where the documentation stops and the twin decides: an
- *  invoice is paid only when the balance covers all of what remains; a smaller balance waits for more funds. */
-export declare function reconcile(ctx: HandlerContext, customer: string, currency: string, reference: string | null): Promise<void>;
-/** The customer's source the path names, or undefined. */
-export declare const customerSource: (ctx: HandlerContext) => Row | undefined;
-export declare const sourceMissing: (ctx: HandlerContext) => Response;
-/** The intent the path names, and the machine's refusal when this operation may not move it. */
-export declare function load(ctx: HandlerContext, operationId: string): {
-    si: Row;
-} | {
-    answer: Response;
-};
 /** The request event asked of the endpoint, signed with its secret and rendered in the event's API version, and its
  *  answer read as the decision. */
 export declare function askForAuthorization(ctx: HandlerContext, url: string, event: Record<string, unknown>, secret: string): Promise<StripeAuthRequestOutcome>;
 /** Stripe's refusal of a call a publishable key may not make, or undefined when the key may make it. */
 export declare function publishableKeyRefused(ctx: HandlerContext): Response | undefined;
-export declare function revokedAccountRefused(ctx: HandlerContext): Response | undefined;
 /** The platform's own keys, as the dashboard's API keys page makes them (the `appCredentials` door): a secret key and a
  *  publishable key, held by their SHA-256. A request with no key is refused, as is a platform key Stripe never issued
- *  ("Invalid API Key provided"); a connected account's OAuth key is checked where it is read (actingAsOAuthKey). */
+ *  ("Invalid API Key provided"). */
 export declare function platformKeyRefused(ctx: HandlerContext, request: Request): Response | undefined;
-export declare function actingAsOAuthKey(ctx: HandlerContext, request: Request): Promise<Request | Response>;
 export declare function withMetadata(ctx: HandlerContext, request: Request): Request;
-/** `disabled` switches delivery off or back on (docs.stripe.com/api/webhook_endpoints/update#update_webhook_endpoint-disabled). */
-export declare function switchDelivery(ctx: HandlerContext, id: string, we: Row, fields: Row, off: boolean): Promise<Response>;
-/** Whether a stored event is the acting account's (no `account`: the platform's). */
-export declare const ownEvent: (ctx: HandlerContext, e: Row) => boolean;
-export declare const faMissing: (ctx: HandlerContext, id: string, status?: number) => Response;
-export declare const metadataOf: (ctx: HandlerContext) => unknown;
-/** The account's bank address once financial_addresses.aba is active: "The FinancialAccount gains a FinancialAddress
- *  when the `financial_addresses.aba` feature is active", and "A FinancialAddress is not added until the
- *  financial_addresses.aba feature has been activated" (docs.stripe.com/treasury/account-management/financial-accounts),
- *  whose test example answers "bank_name": "Stripe Test Bank", "routing_number": "000000001" and the networks "ach",
- *  "us_domestic_wire", "rtp"; "The full account_number is only returned if the request expands it" (the same page).
- *  Where the documentation stops and the twin decides: the account number is ten digits drawn from the account's id,
- *  answered by its last four (the full number is null: expanding it is not modelled), and the holder's name is the
- *  platform account's business name, its dashboard name or, with neither, its id. */
-export declare function abaAddress(ctx: HandlerContext, faId: string): Row;
-export declare const addressesOf: (ctx: HandlerContext, faId: string, active: string[]) => Row[];
-/** Post a flow's double entry: a ledger transaction with its net balance impact, and its one entry. */
-export declare function post(ctx: HandlerContext, o: {
-    financial_account: string;
-    amount: number;
-    currency: string;
-    flow: string;
-    flow_type: string;
-    status: 'open' | 'posted';
-    balance_impact: Row;
-    description: string;
-    flowDetailKey?: string;
-}): Promise<string>;
-/** The request's funding account, or the refusal. */
-export declare function fundingAccount(ctx: HandlerContext): string | Response;
-/** Where an outbound flow sends its money, as the served spec's payment method details give it: the bank account's
- *  holder type, last four digits and routing number from what the request sent (a saved method's, or the test bank's
- *  when none is given), and its billing details (required): the name and email sent, the address lines null where not
- *  given. Where the documentation stops and the twin decides: a saved method's details are the test bank's. */
-export declare function destinationDetails(ctx: HandlerContext, dest: string | null): Row;
-/** An outbound payment that names no destination: "You must provide either destination_payment_method or
- *  destination_payment_method_data" (the served spec's outbound payment create). */
-export declare function noDestination(ctx: HandlerContext): Response;
-/** The bank account an inbound transfer may pull from: "You must first set up the account-attached payment method for
- *  inbound flows and verify the bank account using a SetupIntent", and invalid ones ("of unsupported types, containing
- *  an unverified bank account, or not set up for inbound flows") "throw the same errors as in live mode"
- *  (docs.stripe.com/treasury/moving-money/financial-accounts/into/inbound-transfers). A payment method is set up for
- *  inbound flows by a SetupIntent whose flow_directions holds `inbound`, and verified when that SetupIntent succeeded
- *  ("The bank account has been instantly verified or verification isn't necessary", its `succeeded` status,
- *  docs.stripe.com/treasury/connect/legacy/v1/moving-money/working-with-bankaccount-objects).
- *  Where the documentation stops and the twin decides: the page quotes no error, so the twin answers the documented code
- *  for the class, payment_method_unexpected_state ("The provided payment method's state was incompatible with the
- *  operation you were trying to perform", docs.stripe.com/error-codes), in its own words; an existing verified
- *  BankAccount (`ba_`), which the page also allows, is not checked. Answers the payment method, or the refusal. */
-export declare function inboundOrigin(ctx: HandlerContext, origin: string): Row | Response | undefined;
-export declare function received(kind: 'received_credit' | 'received_debit'): Handler;
-/** Cancel a flow still processing; an outbound one must also still be cancelable. */
-export declare function cancel(resource: string, param: string, name: string, operationId: string, op: string, checkCancelable: boolean): Handler;
-export declare function ledger(resource: string, spec: Record<string, (r: Row, v: unknown) => boolean>): Handler;
 export declare function scopeKeyOf(ctx: HandlerContext): string;
 export declare const named: (ctx: HandlerContext, name: string) => Row | undefined;
 export declare const invoiceMissing: (ctx: HandlerContext, id: string) => Response;
-/** Write a draft's line list and the totals derived from it. */
-export declare function writeLines(ctx: HandlerContext, invoiceId: string, next: Row[]): Promise<Row>;
 /** Paying an invoice with nothing to pay it: "If not set, defaults to the subscription's default payment method, if any,
  *  or to the default payment method in the customer's invoice settings" (docs.stripe.com/api/invoices/object,
  *  default_payment_method), and none of them is set. */
@@ -204,62 +108,24 @@ export declare function nothingToPayWith(ctx: HandlerContext): Response;
 /** A subscription waiting on the invoice paid through the invoice's own pay (incomplete on its first, past_due on a
  *  failed renewal) is active again. */
 export declare function activatedByPayment(ctx: HandlerContext, subId: string): Promise<void>;
-/** Re-derive a draft's lines from the items still on it: an item that changed or was deleted moves the invoice with it. */
-export declare function resyncDraftLines(ctx: HandlerContext, invoiceId: string): Promise<void>;
-/** An item priced by a Price: its unit amount times the quantity, in its currency (docs.stripe.com/api/invoiceitems/create#create_invoiceitem-pricing). */
-export declare function pricedItem(ctx: HandlerContext, priceRef: string, qty: number): {
-    amount: number;
-    currency: string | undefined;
-} | Response;
-export declare const itemMissing: (ctx: HandlerContext, id: string) => Response;
-/** A draft invoice another object makes (an accepted quote): its customer's, with an invoice item per line the
- *  object gives, and the object named as its parent. Answers the invoice's id. */
-export declare function draftInvoiceFor(ctx: HandlerContext, customer: string, currency: string, parent: Row, lines: Array<{
-    price: unknown;
-    quantity: number;
-    amount: number;
-    description: unknown;
-}>): Promise<string>;
-/** A customer's pending invoice item, made before the invoice, pulled onto it (docs.stripe.com/api/invoices/create#create_invoice-pending_invoice_items_behavior). */
-export declare function pullPendingItem(ctx: HandlerContext, invoiceId: string, inv: Row, item: Row, now: number): Promise<void>;
 /** The invoice the path names, and the machine's refusal when this operation may not move it. */
 export declare function invoicesLoad(ctx: HandlerContext, operationId: string): {
     inv: Row;
 } | {
     answer: Response;
 };
+/** A draft finalized on its way to being paid: numbered, open, its PaymentIntent opened (PostInvoicesInvoiceFinalize). */
+export declare function finalizeForPayment(ctx: HandlerContext, inv: Row, id: string): Promise<Row>;
 /** The PaymentIntent a charge_automatically invoice with a balance gets when it is finalized; it
  *  waits for confirmation when the invoice already names a default payment method. */
 export declare function openPaymentIntent(ctx: HandlerContext, piId: string, inv: Row, invoiceId: string): Promise<void>;
 export declare function finalizedFields(ctx: HandlerContext, inv: Row, now: number): Row;
-export declare function editLines(kind: 'add' | 'update' | 'remove'): Handler;
-export declare const noteMissing: (ctx: HandlerContext, id: string) => Response;
-/** The credit note the request describes (the `amount` form: one custom line), or Stripe's refusal. */
-export declare function build(ctx: HandlerContext, id: string): Row | Response;
-/** The invoice's credit-note sums, from its issued credit notes; a pre-payment credit lowers what is owed. */
-export declare function syncInvoice(ctx: HandlerContext, invoiceId: string): Promise<void>;
-/** What a post-payment credit pays back: "Refunds: create a new refund (using refund_amount)"; "Customer balance credit:
- *  credit the customer's balance (using credit_amount) which will be automatically applied to their next invoice when
- *  it's finalized" (docs.stripe.com/api/credit_notes/create). The refund is made on the invoice's charge as a refund
- *  call makes it (refunds.ts); the credit is a customer balance transaction of type credit_note. Where the documentation
- *  stops and the twin decides: the refund carries no reason of its own. */
-export declare function payBack(ctx: HandlerContext, id: string, cn: Row): Promise<Row | Response>;
 /** A coupon for a fixed amount off, in its currency (docs.stripe.com/api/coupons/create#create_coupon-amount_off). */
 export declare function amountOffOf(ctx: HandlerContext, params: Record<string, unknown>): number | Response;
 /** Time's lapsing of coupons, caught up to the World's clock: a valid coupon whose redeem_by has passed is no longer
  *  valid from that moment (manifest.ts). Where the documentation stops and the twin decides: the lapse sends no event
  *  (the events page names none for it). */
 export declare function lapseCoupons(ctx: HandlerContext): Promise<void>;
-export declare const planMissing: (ctx: HandlerContext, id: string) => Response;
-/** A recurring price the Plans API still answers: one whose plan was deleted is not a plan any more. */
-export declare const recurring: (ctx: HandlerContext, p: Row | undefined) => p is Row;
-/** The request's line items resolved against their prices, or the refusal for a missing price. */
-export declare function resolved(ctx: HandlerContext): CheckoutItem[] | Response;
-/** A page of the line items a stored object carries. */
-export declare function linePage(ctx: HandlerContext, holder: Row): Response;
-export declare const linkMissing: (ctx: HandlerContext, id: string) => Response;
-export declare const quoteMissing: (ctx: HandlerContext, id: string) => Response;
-export declare function move(action: 'finalize' | 'accept' | 'cancel', operationId: string): Handler;
 export declare const sessionMissing: (ctx: HandlerContext, id: string) => Response;
 /** The discount a session is created with (discounts[0][promotion_code] or [coupon]), or Stripe's refusal: an unknown
  *  code or coupon, and one that has expired or been deactivated, are refused at create
@@ -296,20 +162,10 @@ export declare function completeSession(ctx: HandlerContext, id: string, existin
 export declare const send: (ctx: HandlerContext, r: StripeResponse) => Response;
 /** Stripe's error body: an invalid_request_error with the message, and the code when there is one. */
 export declare const fail: (ctx: HandlerContext, message: string, status?: number, code?: string) => Response;
-/** A file parameter whose description requires a purpose refuses a file of another one. The served spec requires it
- *  on every such parameter ("Must have a `purpose` value of `issuing_logo`", personalization designs' card_logo;
- *  "The file's `purpose` must be one of the following: …", file links' file). Where the documentation stops and the
- *  twin decides: Stripe documents no error for it (docs.stripe.com/error-codes names none), so the twin answers the
- *  400 invalid_request_error it answers for an unknown file, naming the parameter and the purposes allowed. */
-export declare function filePurposeRefused(ctx: HandlerContext, param: string, allowed: readonly string[]): Response | undefined;
 /** The request's path, as the list envelope's `url` carries it. */
 export declare const path: (ctx: HandlerContext) => string;
 /** A path parameter, by the name the spec gives it. */
 export declare const at: (ctx: HandlerContext, name: string) => string;
-/** An update's fields laid over what is stored, as the derived core does: a nested hash is merged into the stored one,
- *  not put in its place (Stripe updates only the keys a request names; docs.stripe.com/api/metadata and each update
- *  reference), and an empty string unsets a key. */
-export declare function mergeUpdate(ctx: HandlerContext, resource: string, id: string, fields: Row): Row;
 /** A resource's rows in Stripe's list order: newest first by `timeField`, ties by mint order (as the derived core breaks them). */
 /** A subject's bookkeeping field (`_…`): kept on the stored row, never in the wire view ctx.get and ctx.rows answer. */
 export declare const kept: (ctx: HandlerContext, resource: string, row: Row, key: string) => unknown;
@@ -338,6 +194,7 @@ export declare function commonAsOf(ctx: HandlerContext, t: Row): Row;
 export declare function expandRow(ctx: HandlerContext, resource: string, body: Row, paths: string[][]): Row;
 /** One resource with the request's `expand[]` applied. */
 export declare const expanded: (ctx: HandlerContext, resource: string, body: Row) => Row;
+export declare const resourceView: (ctx: HandlerContext, resource: string, id: string) => Row | undefined;
 /** Stripe's list envelope over rows already in list order: a page, `has_more`, and `expand[]=data.*`. */
 export declare function list(ctx: HandlerContext, resource: string, items: Row[]): Response;
 /** Stripe's search over a resource's rows (`query` in its search language). */
@@ -354,29 +211,6 @@ export declare function created(ctx: HandlerContext, resource: string, params: R
 export declare const finder: (ctx: Pick<HandlerContext, "rowsRaw">) => Find;
 /** The account's external_accounts list, rewritten from its external accounts after one is added or removed. */
 export declare function syncExternals(ctx: HandlerContext, account: string): Promise<void>;
-/** A decision over the rows and the write it makes, taken together: the read and the write follow one another with
- *  nothing between them (a code spent once, a connection revoked once). */
-export declare function decide<T>(ctx: HandlerContext, decision: (rows: (resource: string) => Row[]) => {
-    value: T;
-    write?: {
-        resource: string;
-        id: string;
-        fields: Row;
-        operation: string;
-    };
-}): Promise<T>;
-export declare const catalog: (ctx: HandlerContext, data: Row[]) => Response;
-export declare const orderMissing: (ctx: HandlerContext, id: string) => Response;
-/** Each pending report run completes, caught up before anything is answered: "When the run completes, Stripe updates
- *  the object, and it has a status of succeeded. It also has a nested result object, containing a URL that you can use
- *  to access the file", the guide's example a File of purpose report_run and type csv (docs.stripe.com/reports/api).
- *  "Most runs complete within a few minutes" (the same page). Where the documentation stops and the twin decides: a run
- *  completes one minute after it was created (the guide's example: created 1580832900, succeeded_at 1580832960), and
- *  its CSV holds the report type's header row alone (its size that row's bytes). */
-export declare function finishReportRuns(ctx: HandlerContext): Promise<void>;
-/** A feature whose lookup_key an unarchived feature already has: "A unique key you provide as your own system identifier"
- *  (docs.stripe.com/api/entitlements/feature/create). */
-export declare function lookupKeyTaken(ctx: HandlerContext, lookupKey: string): Response;
 export declare const pmMissing: (ctx: HandlerContext, id: string) => Response;
 /** The card a charge was paid with, as its payment_method_details reports it
  *  (docs.stripe.com/api/charges/object#charge_object-payment_method_details): a stored PaymentMethod's card, a
@@ -395,26 +229,6 @@ export declare function methodFromData(ctx: HandlerContext, data: unknown): Prom
  *  payment_method_options[us_bank_account][verification_method]=microdeposits with a us_bank_account method
  *  ("Microdeposit only verification", docs.stripe.com/payments/ach-direct-debit/set-up-payment). */
 export declare function microdepositsAsked(ctx: HandlerContext, params: Row, intent: Row, pm: string | undefined): boolean;
-export declare const scheduleMissing: (ctx: HandlerContext, id: string) => Response;
-/** A schedule's phases as Stripe answers them (the served spec's subscription_schedule_phase_configuration): each
- *  starts where the last ended (the first at the schedule's start_date, "now" or a timestamp), and ends at its
- *  end_date or after its duration ("duration: interval, interval_count", the served spec's phases[] parameter) on the
- *  calendar; its currency is its first price's, each item carries its price, quantity and (empty) discounts. Where the
- *  documentation stops and the twin decides: a phase with neither lasts one interval of its first price. */
-export declare function phasesOf(ctx: HandlerContext, given: Row[], start: number): Row[];
-export declare function end(kind: 'cancel' | 'release'): Handler;
-/** A token asked for none of what a token holds. */
-export declare function noTokenSource(ctx: HandlerContext): Response;
-/** A bank account token's account, as the legacy BankAccount object holds it. */
-export declare function bankAccountOf(ctx: HandlerContext, ba: Row): Row;
-export declare const productMissing: (ctx: HandlerContext, id: string) => Response;
-/** A product deleted while it has prices: "Deleting a product is only possible if it has no prices associated with it"
- *  (docs.stripe.com/api/products/delete). */
-export declare function pricedProductRefused(ctx: HandlerContext): Response;
-/** A feature attached to a product that already has it. */
-export declare function alreadyAttached(ctx: HandlerContext): Response;
-export declare const productFeature: (ctx: HandlerContext) => Row | undefined;
-export declare const featureMissing: (ctx: HandlerContext) => Response;
 /** A tiered price: tiers_mode and tiers, each tier with up_to and a unit or flat amount; no single unit_amount, and
  *  the last tier's up_to null (∞) (docs.stripe.com/products-prices/pricing-models#tiered-pricing). */
 export declare function tieredPrice(ctx: HandlerContext, params: Row): Promise<Response>;
@@ -440,12 +254,8 @@ export declare function authorizeCharge(ctx: HandlerContext, piId: string, pi: R
  * already paid (a duplicate confirm) or void (voiding ends what it collects).
  */
 export declare function payInvoiceOf(ctx: HandlerContext, pi: Row, operationId: string, actor?: 'vendor'): Promise<void>;
-/** The intent the path names, and the machine's refusal when this operation may not move it. */
-export declare function paymentIntentsLoad(ctx: HandlerContext, operationId: string): {
-    pi: Record<string, unknown>;
-} | {
-    answer: Response;
-};
+/** An invoice-linked intent read back from a live account; the served create API cannot set invoice. */
+export declare function finishInvoiceIntent(ctx: HandlerContext, invoice: Row, invoiceId: string, operationId: string, actor?: 'vendor'): Promise<void>;
 /** The type of the payment method an intent is paid with: its PaymentMethod's, or a documented test name's (pm_card_*,
  *  tok_* a card; pm_usBankAccount_* a US bank account), else unknown. */
 export declare function methodType(ctx: HandlerContext, method: unknown): string | undefined;
@@ -458,10 +268,9 @@ export declare function methodType(ctx: HandlerContext, method: unknown): string
  *  twin answers payment_intent_invalid_parameter ("One or more provided parameters wasn't allowed for the given
  *  operation on the PaymentIntent", docs.stripe.com/error-codes), param payment_method. */
 export declare function methodNotAllowed(ctx: HandlerContext, existing: Row, params: Row): Response | undefined;
+export declare function intentFields(params: Record<string, unknown>): Record<string, unknown>;
 /** Confirm an intent the confirm machine allows to move: the confirm action, and a create with `confirm=true`. */
 export declare function confirmIntent(ctx: HandlerContext, existing: Record<string, unknown>, params: Record<string, unknown>): Promise<Response>;
-/** An increment that does not raise the authorization. */
-export declare function incrementTooSmall(ctx: HandlerContext): Response;
 /** Whether the method an intent is confirmed with is a bank debit: a us_bank_account PaymentMethod, or one of Stripe's
  *  test bank accounts named as one (pm_usBankAccount_*, pm_us_bank_account). */
 export declare function isBankDebit(ctx: HandlerContext, method: unknown): boolean;
@@ -471,7 +280,7 @@ export declare function staysProcessing(ctx: HandlerContext, method: unknown): b
  *  settle at this instant, unless its test account stays processing. */
 export declare function beginBankDebit(ctx: HandlerContext, id: string, fields: Row): Promise<Row>;
 /** Time's settling of bank debits, caught up to the World's clock: each processing debit whose moment has come succeeds
- *  then, its Charge made (naming the mandate it ran under) and the invoice it collects for paid. */
+ *  then, its Charge made and the invoice it collects for paid. */
 export declare function settleBankDebits(ctx: HandlerContext): Promise<void>;
 /** A customer_balance intent funded from the customer's cash balance: paid when the balance covers it ("If the customer
  *  already has a balance high enough to cover the payment amount, the PaymentIntent immediately succeeds"), else
@@ -479,6 +288,14 @@ export declare function settleBankDebits(ctx: HandlerContext): Promise<void>;
  *  shows a requires_action status ... next_action ... display_bank_transfer_instructions" with the amount_remaining
  *  (docs.stripe.com/payments/bank-transfers/accept-a-payment). Answers the intent as written. */
 export declare function fundFromCashBalance(ctx: HandlerContext, pi: Row, fields?: Row): Promise<Row>;
+/** A customer_balance intent the customer's funded cash balance pays: its ledger records what was applied, and the intent
+ *  succeeds with its charge. */
+export declare function payFromCashBalance(ctx: HandlerContext, pi: Row, fields: Row, o: {
+    customer: string;
+    currency: string;
+    available: number;
+    amount: number;
+}): Promise<Row>;
 /** Whether a charge's funds go straight to the available balance: a bypass card as a raw number, a test name (pm_card_*
  *  or tok_*), or a stored PaymentMethod made from one (which records it as what follows its success, after-payment.ts);
  *  or a US bank account, stored or one of Stripe's test bank accounts named as one (pm_usBankAccount_*). */
@@ -501,9 +318,6 @@ export declare function availableAt(ctx: HandlerContext, account: string | undef
 export declare function fundsDueBetween(ctx: HandlerContext, account: string | undefined, currency: string, from: number, until: number): number[];
 /** A dispute's debit, at once: the disputed amount and the dispute fee (the twin's 1500 cents, Stripe's US $15). */
 export declare function settleDispute(ctx: HandlerContext, disputeId: string, amount: number, currency: string): Promise<string>;
-/** A won dispute's credit, at once: the disputed amount returned (docs.stripe.com/disputes/how-disputes-work). Where the
- *  documentation stops and the twin decides: the dispute fee is not returned. */
-export declare function settleDisputeWon(ctx: HandlerContext, disputeId: string, amount: number, currency: string): Promise<string>;
 /** An account's ledger entries an automatic payout has not yet paid out: every entry on its payments balance that no
  *  automatic payout took (the automatic payouts' own debits excluded), as stored. */
 export declare function unpaidEntries(ctx: HandlerContext, account: string | undefined): Row[];
@@ -516,14 +330,8 @@ export declare function settlePayout(ctx: HandlerContext, payoutId: string, amou
  *  charge's funds' availability) comes (a plain transfer, with no `fromCharge`, moves funds available already).
  *  Answers the platform's entry. */
 export declare function settleTransfer(ctx: HandlerContext, transferId: string, amount: number, currency: string, destination: string, fromCharge?: number, fromPending?: boolean): Promise<string>;
-/** A transfer reversal's two entries: back into the platform's balance, out of the destination's. */
-export declare function settleTransferReversal(ctx: HandlerContext, reversalId: string, amount: number, currency: string, destination: string): Promise<string>;
 /** A direct charge's application fee: out of the connected account's balance, into the platform's. */
 export declare function settleApplicationFee(ctx: HandlerContext, feeId: string, amount: number, currency: string, account: string): Promise<string>;
-/** A top-up's credit, to the payments balance or, with `destination_balance=issuing`, to Issuing's
- *  (docs.stripe.com/issuing/funding/balance). Where the documentation stops and the twin decides: a test-mode top-up
- *  is available at once. */
-export declare function settleTopup(ctx: HandlerContext, topupId: string, amount: number, currency: string, destination: string): Promise<string>;
 /** Time's settlements, written: each entry on the acting account's balance whose funds came due by the World's clock
  *  moves pending → available (the clock's move the machine allows), so a settlement is recorded once. A read already
  *  sees it (asOf); the record is what lets Stripe's balance.available be sent once (./front.ts, the drain).
@@ -542,40 +350,6 @@ export declare const mine: (ctx: HandlerContext) => Set<unknown>;
 export declare const chargeMissing: (ctx: HandlerContext, id: string) => Response;
 /** Every egress of a charge carries its refunds, derived from the refund rows in list order. */
 export declare function chargeBody(ctx: HandlerContext, c: Row): Row;
-/** A Charges-API charge a declining test card refuses: a 402 card_error naming the failed charge Stripe records for the
- *  attempt (docs.stripe.com/declines). */
-export declare function declinedCharge(ctx: HandlerContext, decline: {
-    code: string;
-    decline_code?: string;
-    message: string;
-}): Promise<Response>;
-/** A charge's fraud report: "user_report … Assessments reported by you. If set, possible values of are `safe` and
- *  `fraudulent`" (docs.stripe.com/api/charges/object, fraud_details). */
-export declare function fraudReport(ctx: HandlerContext, existing: Row, fd: Row): Row | Response;
-/** A capture=false charge refunded while uncaptured: its authorization is released by the refund, as it would be
- *  "automatically refunded if uncaptured" (spec/openapi.json.gz, `capture_before`). The charge stays uncaptured and
- *  becomes refunded in full, a Refund records the release, and no money moves: none was ever received. Written as
- *  charge.refunded. Where the documentation stops and the twin decides: Stripe's basil change ("Partially capturing or
- *  canceling payments no longer creates a Refund", docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-partial-
- *  capture-and-payment-cancellation-flow) names partial capture and cancellation, not a refund asked for, so a refund
- *  still makes one; its reason is null and it has no balance transaction. Answers the Refund. */
-export declare function releaseAuthorization(ctx: HandlerContext, ch: Row, operationId: string, given?: Row): Promise<Row>;
-/** A PaymentIntent's authorization released by its cancel: "For PaymentIntents with a `status` of `requires_capture`, the
- *  remaining `amount_capturable` is automatically refunded" (docs.stripe.com/api/payment_intents/cancel), and since basil
- *  a cancellation makes no Refund: "`amount_captured` will be 0 instead of `nil` in payment cancellation flows",
- *  "`amount_refunded` will no longer be updated by these actions", "`refunded` will no longer be `true` for payment
- *  cancellation flows", and no charge.refunded is sent (docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-
- *  partial-capture-and-payment-cancellation-flow). The charge stays uncaptured; nothing is written as an event. */
-export declare function cancelAuthorization(ctx: HandlerContext, ch: Row): Promise<Row>;
-/** An authorized charge captured, by the charge's capture or its PaymentIntent's: what is captured credits the balance.
- *  Written as charge.captured, "Occurs whenever a previously uncaptured charge is captured" (docs.stripe.com/api/events/types).
- *  A partial capture releases the rest with no Refund and leaves amount_refunded and refunded as they were: "The following
- *  flows no longer result in a `Refund` object created and linked to the payment: Partial capture", "`amount_refunded`
- *  will no longer be updated by these actions", and "There will only be a single balance transaction for partial captures"
- *  (docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-partial-capture-and-payment-cancellation-flow).
- *  The caller has asked the machine whether it may capture. */
-export declare function captureAuthorization(ctx: HandlerContext, ch: Row, toCapture: number, _operationId: string): Promise<Row>;
-export declare const chargeRefund: (ctx: HandlerContext) => Row | Response;
 export declare const subMissing: (ctx: HandlerContext, id: string) => Response;
 /** A coupon that replaces the subscription's discount, or an empty one that clears it (docs.stripe.com/api/subscriptions/update#update_subscription-discounts). */
 export declare function replacedDiscounts(ctx: HandlerContext, couponId: string, sub: Row): Row[] | Response;
@@ -673,16 +447,10 @@ export declare function inlinePrice(ctx: HandlerContext, d: Row): Promise<string
 /** A new subscription's items, each its own subscription_item as Stripe keeps it (/v1/subscription_items/{id}). */
 export declare function storeItems(ctx: HandlerContext, subId: string, items: Row[]): Promise<void>;
 export declare function syncItems(ctx: HandlerContext, subId: string): Promise<void>;
-/** A subscription item with its billing period: its subscription's (basil moved the period onto the items). */
-export declare const withPeriod: (ctx: HandlerContext, si: Row) => Row;
-export declare const subscriptionsItemMissing: (ctx: HandlerContext, id: string) => Response;
 export declare const listMissing: (ctx: HandlerContext, id: string, status?: number) => Response;
 /** A value list's list_items, "List of items contained within this value list" (the served spec), kept in step with
  *  its items, at the address the fixture names (/v1/radar/value_list_items?value_list=…). */
 export declare function radarSyncItems(ctx: HandlerContext, listId: string): Promise<void>;
-/** A requested move of a state field the machine declares, legal or refused; a value the machine
- *  does not name is written as given, as the hand-written route did. */
-export declare function requestedMove(ctx: HandlerContext, resource: string, operationId: string, current: unknown, values: string[]): Response | undefined;
 /** An authorization as every egress carries it: its card embedded in full. */
 export declare function withCard(ctx: HandlerContext, a: Row): Row;
 export declare const authMissing: (ctx: HandlerContext, id: string) => Response;
@@ -737,36 +505,13 @@ export declare function answeredByEndpoint(ctx: HandlerContext, outcome: {
     }) => Row;
     decline: (reason: string, message: string | null) => Promise<Response>;
 }): Promise<Response>;
-export declare const disputeMissing: (ctx: HandlerContext, id: string) => Response;
-export declare const designMissing: (ctx: HandlerContext, id: string) => Response;
-export declare function review(action: 'activate' | 'deactivate' | 'reject', operationId: string): Handler;
-/**
- * Create a refund and land it on its charge. An omitted amount is the whole remaining balance. The
- * charge's write records `charge.refunded`, the event Stripe sends carrying the charge's new totals;
- * `refunded` is true only at the full amount.
- */
-/** A reason Stripe does not take (docs.stripe.com/api/refunds/create#create_refund-reason). */
-export declare function badReason(ctx: HandlerContext): Response;
-/** A bank-transfer payment refunded with origin=customer_balance goes back to the cash balance
- *  (docs.stripe.com/payments/customer-balance/refunding). */
-export declare function backToCashBalance(ctx: HandlerContext, customer: string, currency: string, amount: number, refundId: string): Promise<void>;
-/** A capture=false charge's refund, which releases its whole authorization (see the header). */
-export declare function refundUncaptured(ctx: HandlerContext, charge: Row, amount: number, remaining: number, params: Row): Promise<Response>;
-export declare function refundCharge(ctx: HandlerContext, charge: Row, params: Row): Promise<Response>;
 /** Time's settling of held refunds, caught up to the World's clock: each refund held for want of balance, oldest first,
  *  is made at the first moment the account's available balance covers it (the funds that come due then), its debit
  *  written then, as `refund.updated`. Where the documentation stops and the twin decides: a held refund is made the
  *  moment the balance covers it. */
 export declare function settleHeldRefunds(ctx: HandlerContext): Promise<void>;
-/** The charge a refund aims at: named directly, or reached through its PaymentIntent. */
-export declare function target(ctx: HandlerContext): Row | Response;
-export declare const refundMissing: (ctx: HandlerContext, id: string) => Response;
-/** Each advancing clock whose advance has taken its time reaches its target, caught up before anything is answered:
- *  its frozen_time moves, it is ready, and its customers' trials and periods that ended by then end
- *  (./renewals.ts advanceBilling). The advance's own write is when it began (the kernel's updatedAt). */
-export declare function finishClockAdvances(ctx: HandlerContext): Promise<void>;
-/** What the platform saved, or the settings a new platform starts with (OAuth off, no redirect URI). */
-export declare function connectOAuthSettings(ctx: Pick<HandlerContext, 'rowsRaw'>): ConnectOAuthSettings;
+/** A pending refund can enter this surface only through the vendor-backed refund refresh. */
+export declare function settleOneHeldRefund(ctx: HandlerContext, r: Row, now: number): Promise<void>;
 export declare const accountMissing: (ctx: HandlerContext, id: string, status?: number) => Response;
 /** The account, tombstones included where the hand-written routes looked past a deletion. */
 export declare const accountRow: (ctx: HandlerContext, id: string) => Row | undefined;
@@ -777,67 +522,12 @@ export declare const accountRow: (ctx: HandlerContext, id: string) => Row | unde
 export declare function connectReview(ctx: HandlerContext, id: string): Promise<void>;
 /** The review of a Custom account (see review). */
 export declare function reviewCustom(ctx: HandlerContext, id: string, account: Row): Promise<void>;
-export declare const personMissing: (ctx: HandlerContext) => Response;
-export declare const accountPerson: (ctx: HandlerContext) => Row | undefined;
-export declare const externalMissing: (ctx: HandlerContext) => Response;
-export declare const accountExternal: (ctx: HandlerContext) => Row | undefined;
-/** Whether the platform may create, update or delete an account's external accounts: "A platform can create, update, or
- *  delete external accounts only for connected accounts without access to either the full Stripe or Express Dashboard
- *  and where the platform is responsible for negative balances" (docs.stripe.com/connect/payouts-bank-accounts); it can
- *  still view an Express account's ("A platform can view the external accounts of connected accounts that don’t have
- *  access to the full Stripe Dashboard"). Where the documentation stops and the twin decides: the refusal. Stripe's
- *  pages give no error code for it; the twin answers 403, which the errors page gives as "The API key doesn’t have
- *  permissions to perform the request" (docs.stripe.com/api/errors), with the twin's own wording. The create page says
- *  it too: "You can only specify connected accounts where account.controller.requirement_collection is `application`"
- *  (docs.stripe.com/api/external_account_bank_accounts/create). */
-export declare function refuseExternalWrite(ctx: HandlerContext, account: string): Response | undefined;
-/** Update and delete by id, finding tombstones as the hand-written routes did, with Stripe's own operation names. */
-export declare function patch(resource: string, param: string, missing: string, op: string): Handler;
-export declare function patchRow(ctx: HandlerContext, resource: string, param: string, missing: string, op: string): Promise<Response>;
-export declare const updateReader: Handler;
-export declare function remove(resource: string, param: string, missing: string, op: string, object: string): Handler;
-export declare const readerMissing: (ctx: HandlerContext, id: string) => Response;
-/** A card presented to a reader with no payment in progress. */
-export declare function nothingToPresent(ctx: HandlerContext): Response;
-/** Under manual capture the presented card only holds the amount (docs.stripe.com/terminal/payments/collect-card-payment#capture-payment):
- *  the hold is an uncaptured charge, as an online authorization's is (authorizeCharge), which the intent's capture takes. */
-export declare function holdForCapture(ctx: HandlerContext, piId: string, pi: Record<string, unknown>, pm: string, amount: number): Promise<void>;
-/** Time's settling of top-ups, caught up to the World's clock: a pending top-up succeeds on its expected_availability_date,
- *  its funds entered then in the balance it names. */
-export declare function settleTopups(ctx: HandlerContext): Promise<void>;
-export declare const disputesDisputeMissing: (ctx: HandlerContext, id: string) => Response;
-/** Evidence staged without submitting it (submit=false), or on a dispute already under review or decided. */
-export declare function keepEvidence(ctx: HandlerContext, id: string, fields: Row): Promise<Response>;
-export declare const meterMissing: (ctx: HandlerContext, id: string) => Response;
-export declare function activation(kind: 'deactivate' | 'reactivate'): Handler;
-export declare const grantMissing: (ctx: HandlerContext, id: string) => Response;
-export declare function endGrant(kind: 'expire' | 'void'): Handler;
-export declare function alertMove(kind: 'activate' | 'deactivate' | 'archive', operationId: string): Handler;
-export declare const transferMissing: (ctx: HandlerContext, id: string) => Response;
 /** A transfer to an account whose transfers capability is not active. */
 export declare function transfersInactive(ctx: HandlerContext): Response;
 /** A transfer from a charge whose funds have settled: "With a source_transaction, the transfer request returns success
  *  regardless of your available balance if the related charge hasn't settled yet" (docs.stripe.com/connect/separate-
  *  charges-and-transfers), so a settled one comes out of the available balance. */
 export declare function settledSourceRefused(ctx: HandlerContext, amount: number, currency: string): Response | undefined;
-/** An application fee refunded to its whole through its own refunds endpoint: the fee machine's move, or its refusal. */
-export declare function feeFullyRefunded(ctx: HandlerContext, resource: string, flag: string, id: string): Response | undefined;
-/** Take `amount` (the remainder by default) back out of a parent's total, as a child row appended to its list. */
-export declare function giveBack(ctx: HandlerContext, o: {
-    parent: Row;
-    parentResource: string;
-    child: string;
-    childFields: (amount: number) => Row;
-    childDefaults: Row;
-    doneField: string;
-    flag: string;
-    listUrl: string;
-    op: string;
-    tooLarge: (remaining: number) => string;
-    /** what the money movement itself writes, once the child exists */
-    settle?: (child: Row, amount: number) => Promise<void>;
-}): Promise<Response>;
-export declare const feeMissing: (ctx: HandlerContext, id: string) => Response;
 /** An earlier version's payment_method_types refused: the first value that names no payment method type the
  *  operation takes, in the intent's words or (a Checkout Session) the enum's. */
 export declare function unknownMethodType(ctx: HandlerContext, opId: string, given: unknown): Response | undefined;
@@ -845,13 +535,51 @@ export declare function unknownMethodType(ctx: HandlerContext, opId: string, giv
 export declare const noLongerSupported: (ctx: HandlerContext, version: string) => Response;
 /** Stripe's refusal of a request whose top-level parameters the operation does not take, or undefined. */
 export declare function refuseParameters(ctx: HandlerContext): Response | undefined;
-/** A file's links, kept in step with the links made to it, at the address Stripe lists them
- *  (/v1/file_links?file=…, the File object's example). */
-export declare function syncLinks(ctx: HandlerContext, fileId: string): Promise<void>;
-export declare const calcMissing: (ctx: HandlerContext, id: string) => Response;
-/** A page of the line items a stored object carries. */
-export declare function taxLinePage(ctx: HandlerContext, holder: Row): Response;
-export declare const txMissing: (ctx: HandlerContext, id: string, status?: number) => Response;
 /** An answer in the shape of the API version the caller is served (./version.ts), a webhook endpoint's `secret` shown
  *  only at its creation ("Only returned at creation", docs.stripe.com/api/webhook_endpoints/object). */
 export declare function rendered(request: Request, res: Response): Promise<Response>;
+/** Write a draft's line list and the totals derived from it. */
+export declare function writeLines(ctx: HandlerContext, invoiceId: string, next: Row[]): Promise<Row>;
+/** A customer's pending invoice item, made before the invoice, pulled onto it (docs.stripe.com/api/invoices/create#create_invoice-pending_invoice_items_behavior). */
+export declare function pullPendingItem(ctx: HandlerContext, invoiceId: string, inv: Row, item: Row, now: number): Promise<void>;
+/** The intent the path names, and the machine's refusal when this operation may not move it. */
+export declare function paymentIntentsLoad(ctx: HandlerContext, operationId: string): {
+    pi: Record<string, unknown>;
+} | {
+    answer: Response;
+};
+/** A transfer reversal's two entries: back into the platform's balance, out of the destination's. */
+export declare function settleTransferReversal(ctx: HandlerContext, reversalId: string, amount: number, currency: string, destination: string): Promise<string>;
+/** A capture=false charge refunded while uncaptured: its authorization is released by the refund, as it would be
+ *  "automatically refunded if uncaptured" (spec/openapi.json.gz, `capture_before`). The charge stays uncaptured and
+ *  becomes refunded in full, a Refund records the release, and no money moves: none was ever received. Written as
+ *  charge.refunded. Where the documentation stops and the twin decides: Stripe's basil change ("Partially capturing or
+ *  canceling payments no longer creates a Refund", docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-partial-
+ *  capture-and-payment-cancellation-flow) names partial capture and cancellation, not a refund asked for, so a refund
+ *  still makes one; its reason is null and it has no balance transaction. Answers the Refund. */
+export declare function releaseAuthorization(ctx: HandlerContext, ch: Row, operationId: string, given?: Row): Promise<Row>;
+/** A PaymentIntent's authorization released by its cancel: "For PaymentIntents with a `status` of `requires_capture`, the
+ *  remaining `amount_capturable` is automatically refunded" (docs.stripe.com/api/payment_intents/cancel), and since basil
+ *  a cancellation makes no Refund: "`amount_captured` will be 0 instead of `nil` in payment cancellation flows",
+ *  "`amount_refunded` will no longer be updated by these actions", "`refunded` will no longer be `true` for payment
+ *  cancellation flows", and no charge.refunded is sent (docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-
+ *  partial-capture-and-payment-cancellation-flow). The charge stays uncaptured; nothing is written as an event. */
+export declare function cancelAuthorization(ctx: HandlerContext, ch: Row): Promise<Row>;
+/**
+ * Create a refund and land it on its charge. An omitted amount is the whole remaining balance. The
+ * charge's write records `charge.refunded`, the event Stripe sends carrying the charge's new totals;
+ * `refunded` is true only at the full amount.
+ */
+/** A reason Stripe does not take (docs.stripe.com/api/refunds/create#create_refund-reason). */
+export declare function badReason(ctx: HandlerContext): Response;
+/** A bank-transfer payment refunded with origin=customer_balance goes back to the cash balance
+ *  (docs.stripe.com/payments/customer-balance/refunding). */
+export declare function backToCashBalance(ctx: HandlerContext, customer: string, currency: string, amount: number, refundId: string): Promise<void>;
+/** A capture=false charge's refund, which releases its whole authorization (see the header). */
+export declare function refundUncaptured(ctx: HandlerContext, charge: Row, amount: number, remaining: number, params: Row): Promise<Response>;
+export declare function refundCharge(ctx: HandlerContext, charge: Row, params: Row): Promise<Response>;
+/** The charge a refund aims at: named directly, or reached through its PaymentIntent. */
+export declare function target(ctx: HandlerContext): Row | Response;
+/** A pending invoice item contributes to a preview only on its customer's next invoice. */
+export declare function pendingPreviewItem(ii: Row, customer: string, currency: string, now: number): Row | undefined;
+export declare function pendingPreviewLines(ctx: HandlerContext, customer: string, currency: string, now: number): Row[];