@volter/twin-stripe 2.0.38 → 3.0.1

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

@@ -1,82 +1,585 @@
-import type { SemanticsContext } from '@volter/world-core';
-import { type StripeResponse } from '../stripe-twin.js';
-export type Row = Record<string, unknown>;
-export declare const send: (ctx: SemanticsContext, r: StripeResponse) => Response;
+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, declineFor, type StripeResponse } from '../engine/stripe.js';
+import { type EnteredCard } from '../engine/checkout.js';
+import { type Find, type Row } from '../engine/common.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;
+/** 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;
+/** What a subscription's invoices charge: its own default payment method, else its customer's. */
+export declare function payerOf(ctx: HandlerContext, sub: Row): string | undefined;
+/** The customer's default for invoices, charged when the subscription names none of its own. */
+export declare function customerDefault(ctx: HandlerContext, sub: Row): string | undefined;
+/** A subscription whose invoice has just been finalized: the `once` coupon that invoice took is spent, and a once coupon
+ *  it did not take (added after it was drafted) stays for the next (unspentDiscounts). */
+export declare function spendOnceCoupon(ctx: HandlerContext, invoice: Row): Promise<void>;
+/** A draft invoice for one period of a subscription, its lines the subscription's items and any one-time lines `once`
+ *  gives it (a Checkout session's one-time prices, "on the initial invoice only", docs.stripe.com/api/checkout/sessions/
+ *  create#create_checkout_session-line_items), under the subscription's discount. Answers the invoice id. */
+export declare function draftSubscriptionInvoice(ctx: HandlerContext, sub: Row, o: {
+    start: number;
+    end: number;
+    reason: 'subscription_create' | 'subscription_cycle' | 'subscription_update';
+    trial?: boolean;
+    once?: Row[];
+    id?: string;
+}): Promise<string>;
+/** Finalize a subscription's draft invoice at `at` and charge what its subscription pays with. The move is time's (a
+ *  renewal), the customer's (the Checkout page they paid on) or the API's (an update that ends a trial, which names the
+ *  payer, may ask for no attempt, and moves the subscription itself: semantics/subscriptions.ts applyTrialEnd). Answers
+ *  whether it was paid. */
+export declare function collectSubscriptionInvoice(ctx: HandlerContext, invoiceId: string, at: number, actor: 'time' | 'external' | 'api', opts?: {
+    payer?: string;
+    attempt?: boolean;
+}): Promise<boolean>;
+/** Pay a subscription's open invoice with `paymentMethod` (the customer on the portal, `external`): the charge on the
+ *  invoice's PaymentIntent, the invoice paid, a past_due subscription active. Answers the decline, if the card is refused. */
+export declare function payOpenInvoice(ctx: HandlerContext, invoiceId: string, paymentMethod: string): Promise<{
+    code: string;
+    message: string;
+} | undefined>;
+/** Time's moves on subscriptions, caught up to each customer's clock in the order they fell due, each made at the
+ *  moment it was due: a period that ended renews (a trial's end among them) or, set to cancel, cancels; a renewal
+ *  drafted an hour or more ago is finalized and charged. */
+export declare function advanceBilling(ctx: HandlerContext, only?: (sub: Row) => boolean): Promise<void>;
+/** 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;
+/** 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
+ *  (the clock's move, as asOf reads it), written as `payout.paid`, the event Stripe sends for it. Answers their ids. */
+export declare function payDuePayouts(ctx: HandlerContext, acct?: string | undefined): Promise<string[]>;
+/** Where a connected account's payout goes: "ID of the bank account or card the payout is sent to" (served spec,
+ *  payout.destination), its default external account for the currency, "When multiple accounts are available for a given
+ *  currency, Stripe uses the one set as `default_for_currency`" (docs.stripe.com/connect/payouts-bank-accounts), the
+ *  newest such. Where the documentation stops and the twin decides: the platform's own bank account is not modelled, so
+ *  its payouts name none. */
+export declare function payoutBank(ctx: HandlerContext, account: string, currency: string): string | null;
+export declare const payoutDefaults: (ctx: HandlerContext) => Row;
+/** A payout as the clock reads it: paid once its arrival date has come, the clock's move, asked of the
+ *  machine as a write asks it. */
+export declare function asOf(ctx: HandlerContext, p: Row): Row;
+/** A connected account's payout in a currency none of its bank accounts takes. */
+export declare function noExternalAccount(ctx: HandlerContext, currency: string): Response;
+/** Time's payouts, caught up to the World's clock: each account on an automatic schedule is paid out, on each of its
+ *  scheduled days that has come, what became available by then. */
+export declare function advancePayouts(ctx: HandlerContext): Promise<void>;
+/** What Stripe does after a card succeeds: from a raw number, a test name (pm_card_* or tok_*), or a stored
+ *  PaymentMethod that recorded it when it was made. */
+export declare function afterSuccessOf(ctx: HandlerContext, ref: unknown): Outcome | undefined;
+/** Stripe's acts on a charge that just succeeded: a dispute or a review its card brings, and the platform's fee. */
+export declare function afterCharge(ctx: HandlerContext, chargeId: string, charge: {
+    amount: number;
+    currency: string;
+    payment_intent?: string | undefined;
+    application_fee_amount?: unknown;
+    destination?: unknown;
+}, ref: unknown): Promise<void>;
+/** Radar places an elevated-risk card's charge in review (docs.stripe.com/radar/reviews). */
+export declare function openReview(ctx: HandlerContext, chargeId: string, pi: {
+    payment_intent: string | null;
+}): Promise<void>;
+export declare const customerMissing: (ctx: HandlerContext, id: string) => 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;
+/** 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"). */
+export declare function platformKeyRefused(ctx: HandlerContext, request: Request): Response | undefined;
+export declare function withMetadata(ctx: HandlerContext, request: Request): Request;
+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;
+/** 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. */
+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>;
+/** 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;
+/** 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 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
+ *  (docs.stripe.com/api/checkout/sessions/create#create_checkout_session-discounts, docs.stripe.com/error-codes#coupon-expired).
+ *  Where the documentation stops and the twin decides: the refusals' wording. */
+export declare function discountOf(ctx: HandlerContext, params: Row, now: number): {
+    coupon: Row;
+    promotion?: string;
+} | Response | undefined;
+/** A payment or subscription session with nothing to sell (docs.stripe.com/api/checkout/sessions/create#create_checkout_session-line_items). */
+export declare function noLineItems(ctx: HandlerContext): Response;
+/** A destination charge to an account the platform does not have (docs.stripe.com/connect/destination-charges). */
+export declare function checkoutNoDestination(ctx: HandlerContext, destination: unknown): Response;
+/** A session's trial Stripe refuses: `subscription_data.trial_end` "Has to be at least 48 hours in the future", and
+ *  `subscription_data.trial_period_days` "Has to be at least 1" (docs.stripe.com/api/checkout/sessions/create). Where the
+ *  documentation stops and the twin decides: the refusals' wording. */
+export declare function sessionTrialRefused(ctx: HandlerContext, data: unknown, now: number): Response | undefined;
+export declare function sessionTrialRefusal(ctx: HandlerContext, param: 'trial_end' | 'trial_period_days'): Response;
+/** What completing a session makes, by its mode, as the fields that link it: a payment is a PaymentIntent paid with
+ *  the entered card, its charge in the ledger as any payment's is. */
+export declare function complete(ctx: HandlerContext, id: string, existing: Row, card?: EnteredCard): Promise<Row>;
+/** A subscription session's lines at completion, each inline `price_data` made the Price it generates ("Data used to
+ *  generate a new Price object inline", the same page), under the product it names or one made from its product_data,
+ *  so the subscription's items bill it. Where the documentation stops and the twin decides: such a Price is archived
+ *  (active=false), as a subscription item's price_data makes one (docs.stripe.com/products-prices/manage-prices). */
+export declare function sessionPrices(ctx: HandlerContext, lines: Row[], inline: Array<Row | null>): Promise<Row[]>;
+/** A setup session saves the card through a succeeded SetupIntent (docs.stripe.com/payments/save-and-reuse?platform=checkout). */
+export declare function completeSetup(ctx: HandlerContext, customer: string | undefined, pm: Row | undefined): Promise<unknown>;
+/** The discount a completed subscription session gives its subscription. */
+export declare function sessionDiscount(ctx: HandlerContext, id: string, customer: string, now: number): Row[];
+/** The customer paying on the hosted page (src/screens/checkout.tsx): the external actor's move on the
+ *  session's machine, then what the payment made, linked, and the session stored complete. */
+export declare function completeSession(ctx: HandlerContext, id: string, existing: Row, details?: Row, card?: EnteredCard): Promise<Row | Response>;
+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: SemanticsContext, 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: SemanticsContext, param: string, allowed: readonly string[]): Response | undefined;
+export declare const fail: (ctx: HandlerContext, message: string, status?: number, code?: string) => Response;
 /** The request's path, as the list envelope's `url` carries it. */
-export declare const path: (ctx: SemanticsContext) => string;
+export declare const path: (ctx: HandlerContext) => string;
 /** A path parameter, by the name the spec gives it. */
-export declare const at: (ctx: SemanticsContext, 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: SemanticsContext, resource: string, id: string, fields: Row): Row;
-/** The tree's type for a resource: what its rows are stored under. */
-export declare const stored: (resource: string) => string;
+export declare const at: (ctx: HandlerContext, name: string) => string;
 /** 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: SemanticsContext, resource: string, row: Row, key: string) => unknown;
-/** A removed discount as Stripe answers it: the discount, marked deleted (docs.stripe.com/api/discounts/delete). */
-export declare function deletedDiscount(d: Row, now: unknown): Row;
+export declare const kept: (ctx: HandlerContext, resource: string, row: Row, key: string) => unknown;
 /** A create's parameter that describes a confirmation, sent without confirm=true: the served spec gives each "This
  *  parameter can only be used with `confirm=true`" (off_session: "can only be used when confirm=true"); the message's
  *  wording is the twin's. Answers the refusal, or undefined. */
-export declare function confirmOnly(ctx: SemanticsContext, names: string[], confirm: boolean): Response | undefined;
+export declare function confirmOnly(ctx: HandlerContext, names: string[], confirm: boolean): Response | undefined;
 /** A coupon applied (and the promotion code it came by): its times_redeemed, "Number of times this coupon has been
  *  applied to a customer" (the served spec's coupon), counts it, as the code's "Number of times this promotion code
  *  has been used" (its promotion_code). Where the documentation stops and the twin decides: reaching max_redemptions
  *  does not yet lapse the coupon. */
-export declare function redeemCoupon(ctx: SemanticsContext, couponId: unknown, promotionCode?: unknown): Promise<void>;
-export declare function newest(ctx: SemanticsContext, resource: string, timeField?: string): Row[];
-/** Keep the rows whose field equals the request's parameter of the same name, for each name given. */
-/** A list's range filter on a unix time (`created[gte]=…&created[lt]=…`, or one exact time). */
-export declare function inRange(t: unknown, v: unknown): boolean;
+export declare function redeemCoupon(ctx: HandlerContext, couponId: unknown, promotionCode?: unknown): Promise<void>;
+export declare function newest(ctx: HandlerContext, resource: string, timeField?: string): Row[];
 /** A context at the moment Stripe would have made a move time makes (a renewal, a payout on its schedule), so what
  *  the move writes carries that moment (its events' occurredAt, `created`, a charge's funds' available_on), not the
  *  moment a later request caught it up. */
-export declare function at_(ctx: SemanticsContext): (t: number) => Promise<SemanticsContext>;
-export declare function where(ctx: SemanticsContext, items: Row[], spec: Record<string, (item: Row, value: unknown) => boolean>): Row[];
+export declare function at_(ctx: HandlerContext): (t: number) => Promise<HandlerContext>;
+export declare function where(ctx: HandlerContext, items: Row[], spec: Record<string, (item: Row, value: unknown) => boolean>): Row[];
+export declare function expandPaths(ctx: HandlerContext): string[][];
 /** A balance transaction as the clock reads it: available once its available_on has passed, the clock's move,
- *  asked of the machine as a write asks it (semantics/ledger.ts). */
-export declare function asOf(ctx: SemanticsContext, t: Row): Row;
-/** Stripe's expand walk: each dotted path replaces an id with the resource the manifest says it
- *  holds, one segment at a time; an id the tree lacks stays an id. A balance transaction reads as the clock has it
- *  (asOf), as its own retrieve does. */
-export declare function expandRow(ctx: SemanticsContext, resource: string, body: Row, paths: string[][]): Row;
+ *  asked of the machine as a write asks it (./ledger.ts). */
+export declare function commonAsOf(ctx: HandlerContext, t: Row): Row;
+/** Stripe's expand walk (the kernel's, over the manifest's `embeds`): each dotted path replaces an id with the resource
+ *  it holds, one segment at a time; an id the tree lacks stays an id. An embedded balance transaction reads as the clock
+ *  has it (asOf), as its own retrieve does. */
+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: SemanticsContext, resource: string, body: Row) => Row;
+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: SemanticsContext, resource: string, items: Row[]): Response;
+export declare function list(ctx: HandlerContext, resource: string, items: Row[]): Response;
 /** Stripe's search over a resource's rows (`query` in its search language). */
-export declare const search: (ctx: SemanticsContext, resource: string, timeField?: string) => Response;
+export declare const search: (ctx: HandlerContext, resource: string, timeField?: string) => Response;
 /** A create as Stripe stamps it: the caller's id when it gave one (seeding uses real ids), else a
  *  minted one; `object`, the creation time, the defaults, then the request's own fields. An object
  *  Stripe gives no creation time keeps the twin's as `_created`, for ordering. (A request parameter the
  *  object has no field for stays on the row, where the rules read it; the wire answer leaves it out,
- *  stripe-version.ts.) */
-export declare function created(ctx: SemanticsContext, resource: string, params: Row, defaults: Row, opts?: {
+ *  ./version.ts.) */
+export declare function created(ctx: HandlerContext, resource: string, params: Row, defaults: Row, opts?: {
     timeField?: string;
     operation?: string;
 }): Promise<Row>;
-/** A stored subject of any stored type, tombstones included, in the pack's view: what the pack's
- *  shared helpers look a price, a payment method or a card up by, read from the context's tree. */
-export type Find = (storedType: string, id: string) => Row | undefined;
-export declare const finder: (ctx: SemanticsContext) => Find;
-/** A refund's destination_details for a card charge: "If this is a `card` refund, this hash contains the transaction
- *  specific details" and its `type` "can be `refund`, `reversal`, or `pending`" — a reversal, where "The original charge
- *  will drop off the bank statement altogether", for an authorization released uncaptured, else a refund, "a credit entry
- *  on the bank statement" (docs.stripe.com/api/refunds/object). The network's reference number the twin never has. A
- *  charge not paid by card answers none. */
-export declare function refundDestination(charge: Row, type: 'refund' | 'reversal'): Row;
-/** An account's external_accounts, "External accounts (bank accounts and debit cards) currently attached to this
- *  account" (docs.stripe.com/api/accounts/object), as the list its example answers. */
-export declare const externalList: (account: string, data: Row[]) => Row;
+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: SemanticsContext, account: string): Promise<void>;
+export declare function syncExternals(ctx: HandlerContext, account: string): Promise<void>;
+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
+ *  documented test name (pm_card_* or tok_*, the same cards), or a raw card; undefined for anything else. */
+export declare function paymentMethodDetails(ctx: HandlerContext, ref: unknown): Row | undefined;
+/** Whether a payment method can be attached: a stored one, or a documented test name that attaching mints. */
+export declare const attachable: (ctx: HandlerContext, id: string) => boolean;
+export declare function attachPaymentMethod(ctx: HandlerContext, id: string, customer: string): Promise<Row>;
+/** A documented test name (pm_card_visa, pm_card_visa_chargeDeclined, …) made a real PaymentMethod, as Stripe
+ *  does when one is used: the brand and number it stands for (docs.stripe.com/testing#cards) and its outcome. */
+export declare function materializeTestMethod(ctx: HandlerContext, id: string, customer: string | null): Promise<Row>;
+/** A PaymentMethod made from a confirm's `payment_method_data` ("If provided, this hash will be used to create a
+ *  PaymentMethod", docs.stripe.com/api/setup_intents/confirm, docs.stripe.com/api/payment_intents/confirm), or none. */
+export declare function methodFromData(ctx: HandlerContext, data: unknown): Promise<string | undefined>;
+/** Whether an intent sets up or pays with a bank account by micro-deposits because it asks for them:
+ *  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;
+/** 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>;
+/** Whether the intent's caller named its methods: on create (TYPES_GIVEN), or by an update that set its
+ *  payment_method_types ("Alternatively, update the allowed payment_method_types for this PaymentIntent",
+ *  methodNotAllowed below), which the generic update writes as given, so the intent's history holds it. */
+export declare const typesGiven: (ctx: HandlerContext, id: string) => boolean;
+export declare const paymentIntentsSend: (ctx: HandlerContext, r: StripeResponse) => Response;
+export declare function mintCharge(ctx: HandlerContext, piId: string, pi: Row, amount: number): Promise<string>;
+/** A manual-capture intent's authorization: "Separate payment authorization and capture to create a charge now, but
+ *  capture funds later", and on capture "A partial capture automatically releases the remaining amount"
+ *  (docs.stripe.com/payments/place-a-hold-on-a-payment-method). The charge succeeded and is not captured, holding the
+ *  amount until capture_before, with nothing on the balance yet. Written as
+ *  charge.succeeded, as a charge made with capture=false is (charges.ts); its capture writes charge.captured
+ *  (captureAuthorization). Where the documentation stops and the twin decides: the events page names no event for an
+ *  authorization of its own, so the authorized charge sends charge.succeeded, its status being succeeded. */
+export declare function authorizeCharge(ctx: HandlerContext, piId: string, pi: Row, amount: number): Promise<string>;
+/**
+ * An intent an invoice collects through succeeded (the default_incomplete subscription flow: create
+ * now, confirm client-side): its invoice is paid and, when it is a subscription's first, the
+ * subscription leaves incomplete for active. Both are moves the invoice and subscription machines
+ * declare under the confirming operation. No-op when the intent names no invoice, or the invoice is
+ * 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>;
+/** 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;
+/** A confirm with a payment method of a type the intent's caller did not allow, refused as Stripe refuses it: "The
+ *  PaymentMethod provided (card_present) is not allowed for this PaymentIntent. Please attach a PaymentMethod of one of
+ *  the following types: card. Alternatively, update the allowed payment_method_types for this PaymentIntent to include
+ *  "card_present"" (a real answer quoted in github.com/stripe/stripe-terminal-react-native/issues/745, an intent made
+ *  with payment_method_types ['card']). Only a list the caller gave restricts: without one Stripe offers the methods
+ *  the account enables, which the twin does not model. Where the evidence stops: that answer's code is not quoted; the
+ *  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>;
+/** 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;
+/** Whether a bank debit stays processing: the page's pm_usBankAccount_processing, or its account 000000000009. */
+export declare function staysProcessing(ctx: HandlerContext, method: unknown): boolean;
+/** A bank debit submitted: the intent processes, nothing received yet, sent as payment_intent.processing; it is due to
+ *  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 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
+ *  waiting for a transfer: "If the customer balance isn’t high enough to cover the request amount, the PaymentIntent
+ *  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_*). */
+export declare function bypassesPending(ctx: HandlerContext, card: string | undefined): boolean;
+/** The connected account a request acts for, or undefined for the platform. */
+export declare const actingAccount: (ctx: HandlerContext) => string | undefined;
+/** A ledger entry on an account's balance: the acting account's unless one is named (null names the platform). */
+export declare function write(ctx: HandlerContext, fields: Row, account?: string | null | undefined): Promise<string>;
+/** A captured charge's credit: its amount less the fee, pending two days unless the card bypasses the pending
+ *  balance (bypassesPending), when it is due at once. The
+ *  caller mints the charge's id first and stores the returned id as the charge's balance_transaction. */
+export declare function settleCharge(ctx: HandlerContext, chargeId: string, amount: number, currency: string, card?: string): Promise<string>;
+/** A refund's debit, at once, on the acting account's balance unless one is named (null names the platform). */
+export declare function settleRefund(ctx: HandlerContext, refundId: string, amount: number, currency: string, account?: string | null | undefined): Promise<string>;
+/** What an account had available in a currency at a moment: every entry of its payments balance whose funds had come
+ *  due by then. */
+export declare function availableAt(ctx: HandlerContext, account: string | undefined, currency: string, at: number): number;
+/** The moments after `from` and up to `until` when funds of an account came due, in order: when a held refund can
+ *  next be covered. */
+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>;
+/** 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[];
+/** An automatic payout's debit at `at`, and the entries it pays out marked with it, so the ledger lists them under
+ *  the payout (docs.stripe.com/api/balance_transactions/list#balance_transaction_list-payout). */
+export declare function settleAutomaticPayout(ctx: HandlerContext, payoutId: string, amount: number, currency: string, account: string | undefined, at: number, entries: Row[]): Promise<string>;
+/** A payout's debit (negative) or a cancellation's or reversal's credit (positive), at once, on the payout's account. */
+export declare function settlePayout(ctx: HandlerContext, payoutId: string, amount: number, currency: string, account?: string | null | undefined): Promise<string>;
+/** A transfer's two entries: out of the platform's balance at once, into the destination's when `fromCharge` (its
+ *  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 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>;
+/** 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).
+ *  Funds that were available at once and not yet sent are taken too, and marked sent. Answers the entries taken. */
+export declare function settleDueEntries(ctx: HandlerContext, account?: string | undefined): Promise<Row[]>;
+/** An account's balance, by currency: what the clock has made available, what is still pending, and Issuing's own. */
+export declare function balanceOf(ctx: HandlerContext, account?: string | undefined): {
+    available: Map<string, number>;
+    pending: Map<string, number>;
+    issuing: Map<string, number>;
+};
+/** balance_insufficient when a payout or transfer would take more than the account has available in its currency. */
+export declare function refusePayout(ctx: HandlerContext, amount: number, currency: string, account?: string | undefined): Response | undefined;
+/** The ids of the ledger entries on the acting account's balance. */
+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;
+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;
+/** A `trial_end` Stripe refuses: the parameter is `"now" | timestamp` (docs.stripe.com/api/subscriptions/update), and a
+ *  timestamp that is not in the future answers "Invalid timestamp: must be an integer Unix timestamp in the future."
+ *  (Stripe's own message, as its SDKs' users report it: github.com/stripe/stripe-dotnet/issues/805,
+ *  github.com/stripe/stripe-ruby/issues/682). Where the documentation stops and the twin decides: a value that is no
+ *  number at all, and one more than two years on, answer that same message. */
+export declare function trialEndRefused(ctx: HandlerContext, value: unknown, now: number): Response | undefined;
+export declare function invalidTrialEnd(ctx: HandlerContext): Response;
+/** An update's `trial_end` on the subscription, into `fields`.
+ *
+ *  `now` on a trialing subscription ends its trial at once: "The special value `now` can be provided to end the customer's
+ *  trial immediately" (docs.stripe.com/api/subscriptions/update#update_subscription-trial_end; the trials guide's "To end a
+ *  trial early … setting the `trial_end` value to … **now** to end immediately", docs.stripe.com/billing/subscriptions/
+ *  trials/free-trials). The update resets the billing date and charges at once: "Switching prices does not normally change
+ *  the billing date or generate an immediate charge unless … A trial starts or ends. In these cases, we … immediately
+ *  charge the customer using the new price, and reset the billing date" (docs.stripe.com/api/subscriptions/update), and
+ *  "Stripe immediately attempts payment when a subscription's billing cycle anchor is reset … When billing is performed
+ *  immediately, but the required payment fails, the subscription change request succeeds and the subscription transitions
+ *  to `past_due`" (docs.stripe.com/billing/subscriptions/upgrade-downgrade#immediate-payment). So a new period starts now,
+ *  its invoice is made (`invoice.created`) and charged to the subscription's default payment method, else the
+ *  customer's (paid: `invoice.paid`, the subscription `active`; declined or none: the invoice open, `past_due`), and the
+ *  subscription's own write sends `customer.subscription.updated`. `payment_behavior` (the same page): `error_if_incomplete`
+ *  answers 402 and leaves the subscription as it was, `default_incomplete` leaves the invoice open without an attempt.
+ *
+ *  A future timestamp moves the trial's end, and the period and billing anchor with it: "The `billing_cycle_anchor` will be
+ *  updated to the `trial_end` value" (the same parameter); on a subscription out of its trial it starts a new one ("You can
+ *  add a new trial on a non-trialing subscription by updating the subscription while specifying trial_end", and for
+ *  classic billing mode "the `trial_start` field remains set to the start of the first trial", docs.stripe.com/billing/
+ *  subscriptions/trials/free-trials).
+ *
+ *  Where the documentation stops and the twin decides: the invoice's billing_reason is `subscription_update` ("A
+ *  subscription was updated", docs.stripe.com/api/invoices/object#invoice_object-billing_reason); `now` on a subscription
+ *  that is not trialing has no trial to end and changes nothing; the credit Stripe prorates for the unused time when a new
+ *  trial starts mid-period is not made (as `proration_behavior=none` would have it); `pending_if_incomplete` answers as
+ *  `allow_incomplete` (no pending update is modelled). Answers a refusal, or the invoice to collect once the subscription is written. */
+export declare function applyTrialEnd(ctx: HandlerContext, sub: Row, fields: Row, now: number): Promise<{
+    invoice: string;
+    payer?: string;
+    attempt: boolean;
+} | undefined>;
+/** What ending the trial charges: the update's own default payment method, else the subscription's, else its customer's. */
+export declare function trialPayer(ctx: HandlerContext, sub: Row): string | undefined;
+/** What an update's `trial_end` refuses before anything is written: a new trial the machine does not allow from the
+ *  subscription's status, or, under `error_if_incomplete`, ending a trial that cannot be paid at once ("If payment fails,
+ *  return an HTTP `402` status code and don't update the subscription", docs.stripe.com/api/subscriptions/update). */
+export declare function trialEndBlocked(ctx: HandlerContext, sub: Row, discounts: Row[] | undefined): Response | undefined;
+/** A price named by id, or given as an object. */
+export declare function priceRow(ctx: HandlerContext, price: unknown): Row | undefined;
+/** One period of the subscription's items as an update's `items` would leave them, before any discount: an entry naming
+ *  an item changes its price and quantity (a new price resets the quantity to 1 unless one is given) or deletes it, and
+ *  one naming none adds an item (applyItemChanges). */
+export declare function dueAfter(ctx: HandlerContext, sub: Row, entries: Row[]): number;
+/** One entry of an update's `items` on the lines it would leave (dueAfter). */
+export declare function entryAfter(ctx: HandlerContext, lines: Map<string, {
+    price: Row | undefined;
+    quantity: number;
+}>, e: Row, i: number): void;
+/** A new trial on a subscription whose status the machine does not let start one. */
+export declare function newTrialRefused(ctx: HandlerContext, sub: Row): Response | undefined;
+/** What ending the trial charges, judged before anything is written: the period of the items as this update leaves them
+ *  (dueAfter) under the discount it leaves, and whether the payer pays it (an attempt made, a payer, no decline). */
+export declare function trialEndCharge(ctx: HandlerContext, sub: Row, discounts: Row[] | undefined): {
+    due: number;
+    pays: boolean;
+    declined?: ReturnType<typeof declineFor>;
+};
+/** A new item named with neither `price` nor `price_data`: "One of `price` or `price_data` is required"
+ *  (docs.stripe.com/api/subscriptions/update). */
+export declare function noItemPrice(ctx: HandlerContext): Response;
+/** A subscription asked to fail when its first invoice cannot be paid at once (payment_behavior=error_if_incomplete):
+ *  the card's decline, or no payment method to charge (docs.stripe.com/api/subscriptions/create#create_subscription-payment_behavior). */
+export declare function firstPaymentRefused(ctx: HandlerContext, declined: Parameters<typeof cardError>[0] | null | undefined): Response;
+/** An update's `items`: "A list of up to 20 subscription items, each with an attached price"
+ *  (docs.stripe.com/api/subscriptions/update): an entry naming an item's `id` changes that item (its price, quantity,
+ *  metadata) or, with `deleted` ("A flag that, if set to `true`, will delete the specified item"), removes it; "If you
+ *  omit `id`, the API adds a new subscription item rather than updating the existing one". Each takes `price` or
+ *  `price_data`, "Data used to generate a new Price object inline. One of `price` or `price_data` is required", and
+ *  "When changing a subscription item's price, `quantity` is set to 1 unless a `quantity` parameter is provided". An
+ *  inline price is made as the manage-prices guide says: "By default, prices created with `price_data` are effectively
+ *  archived (they're marked as `active=false`)" (docs.stripe.com/products-prices/manage-prices).
+ *  Where the documentation stops and the twin decides: the update is all or nothing, every entry checked before any is
+ *  written (Stripe answers one error for the request); the refusals are worded by the twin. */
+export declare function applyItemChanges(ctx: HandlerContext, subId: string, entries: Row[]): Promise<Response | undefined>;
+/** The refusal of an update's `items`, checked entry by entry before any is written (applyItemChanges). */
+export declare function itemChangesRefused(ctx: HandlerContext, subId: string, entries: Row[]): Response | undefined;
+/** An update's checked `items`, written. */
+export declare function writeItemChanges(ctx: HandlerContext, subId: string, entries: Row[]): Promise<undefined>;
+/** A subscription item's `price_data` Stripe would refuse: its required `currency`, `product` (an existing one) and
+ *  `recurring[interval]`, and "Only one of `unit_amount` and `unit_amount_decimal` can be set". */
+export declare function refuseInlinePrice(ctx: HandlerContext, d: Row): Response | undefined;
+/** The inline Price a `price_data` generates: recurring, archived (active=false). Answers its id. */
+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>;
+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>;
+/** 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;
+/** A capture: an Issuing transaction (negative: it debits) and the issuing balance's debit. */
+export declare function capture(ctx: HandlerContext, authId: string, auth: Row, amountCents: number): Promise<{
+    txnId: string;
+    btId: string;
+}>;
+/** Issuing refusals of a request no story sends: an unknown card status or authorization method, and a capture of an
+ *  authorization that is not approved and pending. */
+export declare function issuingRefusal(ctx: HandlerContext, what: 'card_status' | 'authorization_method' | 'not_capturable', auth?: Row): Response;
+/** A partial approval's refusal: "You can specify the amount you want to approve by setting the amount in the webhook
+ *  response body or the approve call" only "When an authorization is partially authorized, the is_amount_controllable
+ *  field on the authorization request is set to true" (docs.stripe.com/issuing/purchases/authorizations), and never a
+ *  credit. Answers the refusal, or undefined when the amount may be approved. */
+export declare function partialApprovalRefused(ctx: HandlerContext, auth: Row): Response | undefined;
+export declare function issuingDecide(approved: boolean): Handler;
+/** Time's decision on a real-time request no one answered, caught up to the World's clock: once its window has ended,
+ *  a pending authorization whose issuing_authorization.request went unanswered, and that no approve or decline decided,
+ *  is decided automatically, its request_history reason webhook_timeout ("webhook_timeout for all other failure modes",
+ *  the same page, beside webhook_error for a response Stripe cannot process).
+ *  Where the documentation stops and the twin decides: the timeout setting is the Dashboard's, which the API does not
+ *  answer, and the twin's is to decline; the window is measured in World time from the authorization's created. */
+export declare function lapseRealtimeRequests(ctx: HandlerContext): Promise<void>;
+/** An approval's hold: "If you approve the authorization, we deduct the `amount` from your Issuing balance and hold it
+ *  in reserve until the authorization is either captured, voided, or expired without capture"
+ *  (docs.stripe.com/issuing/purchases/authorizations). */
+export declare function holdFor(ctx: HandlerContext, authId: string, amount: number, currency: string): Promise<Row>;
+/** An authorization approved as it is presented, its amount held: approved and pending until the merchant captures. */
+export declare function approvedAtOnce(ctx: HandlerContext, subject: Row, fields: Row, held: number, entry: Row): Promise<Response>;
+/** An authorization as the platform's real-time answer makes it: approved (in part, only when the request was
+ *  amount-controllable), declined, or declined for an answer Stripe cannot read (docs.stripe.com/issuing/controls/
+ *  real-time-authorizations: the response's `approved` and `amount`; webhook_error "if we can't process your response"). */
+export declare function answeredByEndpoint(ctx: HandlerContext, outcome: {
+    kind: 'approved';
+    amount?: number;
+} | {
+    kind: 'declined';
+} | {
+    kind: 'error';
+    message: string;
+}, o: {
+    subject: Row;
+    fields: Row;
+    amount: number;
+    controllable: boolean;
+    entry: (e: {
+        amount: number;
+        approved: boolean;
+        reason: string;
+        reasonMessage: string | null;
+    }) => Row;
+    decline: (reason: string, message: string | null) => Promise<Response>;
+}): 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>;
+/** 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;
+/** Stripe's review of a Custom account once the platform gives it something: with nothing left due, its requested
+ *  capabilities become active and it can take charges and receive payouts; with something due again (its bank account
+ *  removed), they stop. Where the documentation stops and the twin decides: test-mode verification is immediate, and
+ *  it owes what customRequirements lists. An Express or Standard account is onboarded on Stripe's own pages. */
+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>;
+/** 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 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;
+/** payment_method_types refused where the caller's version removed it. */
+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;
+/** 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[];