@agent-cards/checkout 0.18.0 → 0.21.0

package/dist/client.d.ts

@@ -1,618 +0,0 @@
-import { type CheckoutMode, type Recognizer } from './registry.js';
-import type { Substitutions } from './substitute.js';
-import { type PreparationMode, type PreparationProcessor } from './prepared-processor.js';
-export interface PausedRequest {
-    url: string;
-    method: string;
-    headers: Record<string, string>;
-    body: string;
-    /** Captured native Checkout Pro initialization, validated before use. */
-    mercado_checkout?: unknown;
-}
-/**
- * The modes this SDK can finish. Asked for on syncRegistry (the API serves
- * only recognizers in these modes, so a request this build cannot complete
- * is never paused) and sent on every create.
- */
-export declare const SUPPORTED_MODES: readonly CheckoutMode[];
-/**
- * Registry features this SDK honours, asked for on syncRegistry next to the
- * modes. `card_fields`: it reads a recognizer's cardFields and claims only a
- * request whose body carries the card, so the API may serve it recognizers
- * whose endpoints also run without a card. `checkout_sessions`: it lets a
- * request the recognizer marks as routine without a card (passWithoutCard)
- * through ahead of its holds, so the API may serve Stripe's Checkout Session
- * confirm, which hosted Checkout sends after an approval.
- */
-export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
-/**
- * What the amount on an authorization IS: held to a Stripe PaymentIntent
- * (read back at create and before the replay), the parked form's own sum
- * (hosted_form: the bytes the device submits name the amount), or a display
- * fact on a template that carries no amount.
- */
-/**
- * Who named the amount an authorization carries: `processor` (the paused
- * request's own bytes, or the Stripe intent it names, read back by Agentcard),
- * `agent` (the `amount` you passed), `page` (the total read off the checkout
- * page), or `none` (nobody yet; the processor is read right before the card
- * is sent).
- */
-export type AmountAuthority = 'processor' | 'agent' | 'page' | 'none';
-/** An integer in the smallest unit, or a decimal string in normal units with a point; nothing else. */
-export declare function validAmountInput(amount: unknown): amount is number | string;
-/** How an existing authorization is being handled; omitted by older APIs. */
-export interface ExecutionMetadata {
-    executionMode?: 'user_approval' | 'autopilot';
-    grantId?: string;
-}
-/**
- * The token flow: the cardholder's device called the processor itself, and
- * this is the processor's answer to replay into the paused request.
- */
-export interface TokenReplay extends ExecutionMetadata {
-    /** Authenticated selected-card metadata; the processor response body stays unchanged. */
-    processorContext?: unknown;
-    /** Present only after validating the native TEST Checkout completion. */
-    checkoutSessionId?: string;
-    /** Present only after validating the explicit owned-shop purchase receipt. */
-    shopOrderId?: string;
-    /** Absent on older API versions; always 'token' here. */
-    mode?: 'token';
-    /** The approved authorization (`cauth_…`). */
-    authorizationId: string;
-    status: number;
-    headers: Record<string, string>;
-    /** Body to hand back to the browser, verbatim. */
-    body: string;
-    /**
-     * Post-replay reconciliation, when the API has it: whether the amount the
-     * processor reported charging equals the amount the user approved (null
-     * when there was nothing to compare, e.g. a tokenization request), and the
-     * charged pair itself. A `false` here means the approval stood (money had
-     * moved) and Agentcard also sent your server checkout_authorization.amount_mismatch.
-     */
-    amountVerified?: boolean | null;
-    /** What the processor collected, an integer in the currency's smallest unit (Stripe's `amount`). */
-    chargedAmount?: number | null;
-    chargedCurrency?: string | null;
-    /**
-     * What `chargedAmount` is: 'captured' (the intent succeeded; this is
-     * amount_received), 'authorized' (requires_capture; amount_capturable, the
-     * merchant captures later), 'none' (a PaymentIntent was reported but
-     * nothing is collected yet: processing, requires_action), or null when no
-     * PaymentIntent was reported at all (a tokenization request).
-     */
-    chargedKind?: 'captured' | 'authorized' | 'none' | null;
-    /** Who named the amount the person approved. */
-    amountAuthority?: AmountAuthority;
-}
-/**
- * The cse flow (Adyen): the cardholder's device encrypted the card under the
- * processor's public key and reported the ciphertext. Nothing was sent to the
- * processor yet: write `substitutions` into the paused body
- * (substituteEncryptedFields) and let the request CONTINUE from the browser
- * that paused it, so its session data, risk data and cookies stay its own.
- * The processor's answer then reaches the page as it normally would; the
- * merchant's order state is where the outcome shows up.
- */
-export interface CseReplay extends ExecutionMetadata {
-    mode: 'cse';
-    authorizationId: string;
-    substitutions: Substitutions;
-    amountAuthority?: AmountAuthority;
-}
-/**
- * The hosted_form flow (Tranzila): the cardholder's device rebuilt the
- * processor's own form with the real card and submitted it itself, top-level,
- * at `submittedAt`. The processor answered THE DEVICE, not the browser that
- * paused the navigation, so there is no response to replay and no outcome
- * here: resolve the paused navigation with hostedFormSubmittedPage() (the
- * adapters do), never resubmit the form, and confirm the order with the
- * merchant, which learns the outcome from the processor.
- *
- * THIS IS NOT AN APPROVED PAYMENT. `kind` and `outcome` say so in words so
- * no caller mistakes it for one: the API finishes such an authorization as
- * `submitted_on_device` (never `approved`) and sends your server
- * `checkout_authorization.submitted` (never `.approved`). The stamp is the
- * cardholder's device attesting that the form left it; Agentcard holds no
- * processor evidence on this mode and cannot obtain any. Treat it as "the
- * person paid, or tried to, on their own device" and confirm with the merchant.
- */
-export interface HostedFormReplay extends ExecutionMetadata {
-    mode: 'hosted_form';
-    /** What this resolution is: a device-attested submission, not a processor answer. */
-    kind: 'submitted_on_device';
-    /** Always 'unverified': no processor evidence exists for a hosted form. */
-    outcome: 'unverified';
-    authorizationId: string;
-    /** When the device reported the form left it (ISO 8601). */
-    submittedAt: string;
-    amountAuthority?: AmountAuthority;
-}
-/** What authorize() resolves with; branch on `mode` (absent means token). */
-export type ReplayResponse = TokenReplay | CseReplay | HostedFormReplay;
-export interface PrepareCheckoutOptions {
-    psp: PreparationProcessor;
-    /** The processor environment, independent of your Agentcard client's mode. */
-    environment: 'production' | 'sandbox' | 'shared';
-    signal?: AbortSignal;
-}
-export interface PrepareCheckoutInput extends PrepareCheckoutOptions {
-    user: string;
-    merchant: string;
-    /** An integer in the currency's smallest unit (2306 for $23.06), or a decimal string in normal units ("23.06"). */
-    amount: number | string;
-    currency: string;
-    cardId?: string;
-    merchantOrigin: string;
-    checkoutKey: string;
-    timeoutMs?: number;
-    onPreparationCreated?: (id: string) => void;
-    onApprovalUrl?: (url: string) => void;
-}
-/** Real user consent and an unlocked device; no processor request or payment yet. */
-export interface PreparedCheckout {
-    readonly id: string;
-    readonly status: 'ready';
-    readonly psp: PreparationProcessor;
-    readonly environment: 'production' | 'sandbox' | 'shared';
-    /** How the approved card reaches the processor: ciphertext the device produces (Adyen, `cse`) or the device's own request (`token`). */
-    readonly mode: PreparationMode;
-    readonly expiresAt: string;
-    readonly cardId: string;
-    readonly user: string;
-    readonly merchant: string;
-    /** The approved amount, an integer in the currency's smallest unit, as the API confirmed it. */
-    readonly amount: number;
-    readonly amountDisplay: string | null;
-    readonly currency: string;
-    readonly merchantOrigin: string;
-    readonly checkoutKey: string;
-    readonly paymentStatus: 'not_started';
-    readonly amountAuthority: 'agent';
-}
-export declare class CheckoutPreparationError extends Error {
-    preparationId: string | null;
-    reason: string;
-    constructor(preparationId: string | null, reason: string);
-}
-export interface AuthorizeInput extends ExecutionMetadata {
-    /** Native Checkout defaults to TEST; LIVE requires this explicit opt-in. */
-    stripeCheckoutEnvironment?: 'test' | 'production';
-    /** Observed top-level HTTPS merchant origin; a routing hint, never payment authority. */
-    merchantOrigin?: string;
-    /** Your identifier for the person whose card should pay. */
-    user: string;
-    /** Shown to the user on the approval screen. Judged by nothing: the merchant comes from the checkout page. */
-    merchant: string;
-    /**
-     * Your hint at the amount: an integer in the currency's smallest unit (2306
-     * for $23.06), or a decimal string in normal units ("23.06"), with its ISO
-     * 4217 code ("usd"). Optional: the processor's own amount is the higher
-     * authority, read from the paused request or from the Stripe intent it
-     * names right before the cardholder's device replays, and the company's
-     * caps are judged on it. A hint lets a bad purchase be refused the moment
-     * you open it, and a hint that disagrees with the processor beyond one
-     * smallest unit is refused with nothing charged (an AmountMismatchError;
-     * `stage` says which check). Agentcard derives the display string; you
-     * never send one. Both or neither: one without the other is refused.
-     */
-    amount?: number | string;
-    currency?: string;
-    /**
-     * The total read off the checkout page, the lowest authority: used only
-     * when neither the processor's request nor your hint names an amount. The
-     * adapters fill it from `[data-agentcard-amount]` when a page carries one.
-     */
-    pageAmount?: {
-        amount: number;
-        currency: string;
-    };
-    /** Milliseconds from the caller's pay click until the SDK caught the card request, measured on one clock. */
-    payToInterceptMs?: number;
-    /**
-     * WHICH stored card should pay — a vault card id from
-     * GET /api/v2/vault_cards. The approval page preselects it (the human can
-     * still override). Omitted: the page defaults to the most recently added
-     * card. An id that isn't in this user's vault fails the create with a 404
-     * `card_not_found`.
-     */
-    cardId?: string;
-    /**
-     * The origin of the checkout page the payment form was on
-     * (https://shop.example.com). The adapters read it from the page; pass it
-     * yourself when you run your own interception. With the processor identity
-     * in the paused request this is what names the merchant for the company's
-     * presets; `merchant` above is shown to the person and judged by nothing.
-     */
-    pageOrigin?: string;
-    request: PausedRequest;
-    /** Abort if the user has not approved within this many ms. Default 15 min. */
-    timeoutMs?: number;
-    /** Stops local polling; it does not revoke a pending approval or undo a payment. */
-    signal?: AbortSignal;
-    /** Adapter-owned merchant request lifetime. A failed request retires a pending approval before replay when possible. */
-    merchantSignal?: AbortSignal;
-    /** Called before onApprovalUrl; lets a runtime reconcile an interrupted authorization. */
-    onAuthorizationCreated?: (authorizationId: string) => void;
-    /** Called once with the URL to surface to the user, if you deliver it yourself. */
-    onApprovalUrl?: (url: string) => void;
-    /** One-use preparation returned by this client. Never resumes an older request. */
-    preparation?: PreparedCheckout;
-}
-export declare class CardEncryptedError extends Error {
-    psp: string;
-    constructor(psp: string);
-}
-/**
- * The registry requests a mode this SDK build cannot finish, before creation.
- * A response in an unexpected mode after creation has an unknown payment
- * outcome instead and raises PaymentOutcomeUnknownError.
- */
-export declare class UnsupportedModeError extends Error {
-    mode: string;
-    constructor(mode: string);
-}
-export declare class ApprovalTimeoutError extends Error {
-    constructor(ms: number);
-}
-export declare class CheckoutCancelledError extends Error {
-    constructor();
-}
-/** The reasons an org runtime may stamp when it retires an authorization; see VaultClient.cancelAuthorization. */
-export type RuntimeCancelReason = 'merchant_request_aborted' | 'merchant_never_retried';
-export declare const RUNTIME_CANCEL_REASONS: readonly RuntimeCancelReason[];
-/** The payment may have reached the processor. Reconcile the merchant order before any new attempt. */
-export declare class PaymentOutcomeUnknownError extends Error {
-    authorizationId: string | null;
-    reason: string;
-    constructor(authorizationId: string | null, reason: string);
-}
-export declare class ApprovalDeclinedError extends Error {
-    constructor(reason: string);
-}
-/**
- * Agentcard refused the payment because the processor's amount did not match
- * the amount the user was (or would have been) asked to approve. Nothing was
- * charged. Two stages:
- *   - 'create': the intent already disagreed when the request was parked. No
- *     authorization exists (`authorizationId` is null). Per request, not per
- *     page: the merchant can still update the intent before confirmation, so
- *     the adapters keep intercepting and the next attempt is judged afresh.
- *   - 'pre_replay': the intent moved between create and the moment the
- *     cardholder's device would have sent the card. The authorization is
- *     `declined` with reason `amount_mismatch`.
- *
- * A decline in every structural sense (the adapters abort the paused request
- * and quiet the page's retry exactly as for a person's "no"), so it extends
- * ApprovalDeclinedError: code that already handles declines keeps working,
- * and code that wants the numbers reads them here or branches on `code`.
- */
-export declare class AmountMismatchError extends ApprovalDeclinedError {
-    /** The declined authorization, or null for a create-time refusal (no row exists). */
-    authorizationId: string | null;
-    /** What the user was asked to approve, smallest currency unit. */
-    expectedCents: number;
-    /** What the processor reported at the last check. */
-    actualCents: number;
-    /** ISO 4217 of the approved amount. */
-    currency: string;
-    /** ISO 4217 the processor reported (differs only on a currency change). */
-    actualCurrency: string;
-    /** Which check refused it. */
-    stage: 'create' | 'pre_replay';
-    readonly code: "amount_mismatch";
-    constructor(
-    /** The declined authorization, or null for a create-time refusal (no row exists). */
-    authorizationId: string | null, 
-    /** What the user was asked to approve, smallest currency unit. */
-    expectedCents: number, 
-    /** What the processor reported at the last check. */
-    actualCents: number, 
-    /** ISO 4217 of the approved amount. */
-    currency: string, 
-    /** ISO 4217 the processor reported (differs only on a currency change). */
-    actualCurrency?: string, 
-    /** Which check refused it. */
-    stage?: 'create' | 'pre_replay');
-}
-/**
- * The PaymentIntent behind this checkout can no longer be confirmed: it was
- * already charged (succeeded), is being charged (processing), is authorized
- * and on hold for the merchant to capture (requires_capture), or was
- * canceled. Agentcard refused rather than replay a confirm at it; the
- * authorization is `declined` with reason `intent_not_confirmable`.
- * Deliberately NOT "nothing was charged": for three of those four, money has
- * moved or is moving. Check the intent at Stripe before retrying.
- */
-export declare class IntentNotConfirmableError extends ApprovalDeclinedError {
-    authorizationId: string;
-    readonly code: "intent_not_confirmable";
-    constructor(authorizationId: string);
-}
-/** Bounded processor identifiers, never a raw response or free-form description. */
-export interface RazorpayProcessorError {
-    reason?: string;
-    source?: string;
-    step?: string;
-    payment_id?: string;
-    order_id?: string;
-}
-/**
- * The device reported a processor request rejection. A generic processor
- * code does not establish an issuer decline or prove no money moved. Read
- * the bounded processor evidence and reconcile the merchant before retrying.
- * The authorization remains `declined` with reason `processor_refused` for
- * compatibility; no successful processor response is handed to the merchant.
- */
-export declare class ProcessorRefusedError extends ApprovalDeclinedError {
-    authorizationId: string;
-    pspErrorCode: string | null;
-    readonly code: "processor_refused";
-    readonly processorError: RazorpayProcessorError | null;
-    constructor(authorizationId: string, pspErrorCode: string | null, processorError?: RazorpayProcessorError | null);
-}
-/**
- * A non-2xx from the Agentcard API, carrying the status so callers can tell a
- * misconfiguration from a blip. The adapters use this to decide whether
- * retrying is worth anything: a 404 `connection_not_found` will answer the same
- * way forever, while a 429 or a 502 will not.
- */
-/**
- * The company's preset refused the purchase. The company that runs this
- * integration put rules on its users' Vault purchases (a merchant list, a
- * currency, a spend cap, a time window); this purchase is outside them.
- * Nothing was charged. Two stages:
- *   - 'create': refused before any authorization existed (`authorizationId`
- *     is null); nobody was asked to approve. Per purchase, not per page: the
- *     next request on the same page is judged afresh.
- *   - 'pre_replay': refused right before the cardholder's device would have
- *     sent the card; the authorization is `declined` with `code` as reason.
- * `code` is the rule's reason (merchant_denied, currency_denied,
- * spend_rate_exceeded, time_window_denied, ...), `message` the rule's own
- * statement with the company's next step, `preset` the version that judged
- * it. When several presets refused the same purchase, `code`, `preset`,
- * `rule` and `attachment` are the first, and `refusals` names every one. A
- * decline in every structural sense (the adapters quiet the page's retry as
- * for a person's "no"), so it extends ApprovalDeclinedError.
- */
-export declare class PresetRefusedError extends ApprovalDeclinedError {
-    readonly authorizationId: string | null;
-    readonly code: string;
-    readonly detail: string | null;
-    readonly preset: {
-        id: string;
-        version: number;
-        name: string;
-    } | null;
-    readonly rule: string | null;
-    readonly stage: 'create' | 'pre_replay';
-    /** The stored card the preset that refused is attached to, with its last four digits. */
-    readonly attachment: PresetAttachment | null;
-    /** The preset's name. */
-    readonly presetName: string | null;
-    /** Every preset that refused, each with its attachment, rule, code and statement; one entry when one refused. */
-    readonly refusals: readonly PresetRefusal[];
-    constructor(authorizationId: string | null, code: string, detail: string | null, preset: {
-        id: string;
-        version: number;
-        name: string;
-    } | null, rule: string | null, stage: 'create' | 'pre_replay', 
-    /** The stored card the preset that refused is attached to, with its last four digits. */
-    attachment?: PresetAttachment | null, refusals?: readonly PresetRefusal[]);
-}
-/** The stored card a preset is attached to, with its last four digits. */
-export interface PresetAttachment {
-    kind: 'card';
-    targetId: string | null;
-    last4: string | null;
-}
-/** One preset's refusal of a purchase. */
-export interface PresetRefusal {
-    preset: {
-        id: string;
-        version: number;
-        name: string;
-    };
-    attachment: PresetAttachment | null;
-    rule: string | null;
-    code: string;
-    detail: string | null;
-}
-/** A decline reason only the company presets stamp (see PresetRefusedError). */
-export declare const PRESET_REFUSAL_REASONS: ReadonlySet<string>;
-export declare class CheckoutApiError extends Error {
-    status: number;
-    path: string;
-    bodyText: string;
-    /** The API's stable error code (`{ error: { code } }`), or null when the body carried none. */
-    readonly code: string | null;
-    /**
-     * The rest of the error envelope. A 409 `amount_mismatch` from create
-     * carries `expected_cents`, `actual_cents`, `currency`, `actual_currency`;
-     * an `amount_unverifiable` carries `reason`; an `intent_not_confirmable`
-     * carries `intent_status`.
-     */
-    readonly details: Record<string, unknown>;
-    constructor(status: number, path: string, bodyText: string);
-    /**
-     * True when repeating this exact call cannot succeed: a misconfiguration
-     * (4xx other than 429). NOT a 409 `amount_mismatch`: Stripe lets a merchant
-     * update an intent's amount until it is confirmed, so the next request on
-     * the same page may well agree. That one is a per-request failure, and
-     * authorize() surfaces it as AmountMismatchError before an adapter ever
-     * sees it here. NOT a 409 `duplicate_submission` either: the household
-     * already has, or already answered, the prompt for this submission, and
-     * once that prior authorization is declined or expired the same form is a
-     * new question. The adapters quiet the page's re-post the way they quiet a
-     * decline instead of latching the attachment.
-     */
-    get permanent(): boolean;
-}
-/**
- * A URL as it may appear in an error message: origin + path only. A paused
- * request's URL can carry a client secret in its query string, and error
- * messages travel further than anyone intends (onEvent, logs, crash reports).
- */
-export declare function redactUrl(raw: string): string;
-export interface VaultClientOptions {
-    /**
-     * Your Agentcard OAuth client credentials. The SDK exchanges them for a
-     * short-lived access token and refreshes it when it expires.
-     *
-     * NOT an `sk_` API key: those are retired, and the checkout endpoints reject
-     * them with `client_credentials_required` because an authorization has to be
-     * bound to the confidential client that created it.
-     */
-    clientId: string;
-    clientSecret: string;
-    baseUrl?: string;
-    /** Override the PSP registry (tests, or pinning). Defaults to the hosted list. */
-    registry?: Recognizer[];
-    fetchImpl?: typeof fetch;
-    /** Receives contained reporting failures that do not change checkout behavior. */
-    onEvent?: (event: {
-        type: string;
-        detail?: unknown;
-    }) => void;
-    pollIntervalMs?: number;
-    /**
-     * Waits before retrying a create the API answered 502 `amount_unverifiable`
-     * (Stripe did not answer the amount read-back) or 502 `cse_key_unavailable`
-     * (Adyen did not answer the public-key fetch). One retry per entry, then
-     * the error is thrown. Default [500, 1500]; [] disables retries.
-     */
-    unverifiableRetryDelaysMs?: number[];
-}
-export declare class VaultClient {
-    private readonly opts;
-    private readonly baseUrl;
-    private readonly fetch;
-    private readonly pollIntervalMs;
-    private readonly unverifiableRetryDelaysMs;
-    private registry;
-    private readonly preparations;
-    private readonly usedPreparations;
-    constructor(opts: VaultClientOptions);
-    /** Refresh recognizers from the API so new PSPs work without a redeploy. */
-    syncRegistry(): Promise<void>;
-    /** True when this request is a card tokenization we can take over. */
-    isCardRequest(url: string, method?: string): boolean;
-    /**
-     * What happens to a card request (by URL) whose body carries no card: null
-     * when it carries one, so it is a card request as usual; 'continue' when the
-     * recognizer marks the endpoint as one where such requests are routine and
-     * never ours; 'refuse' otherwise, such as a Stripe confirmation paying with
-     * a method this checkout never approved. The adapters ask only after their
-     * holds, so a request that would reuse an approved token is refused there
-     * first. A body that could not be read is not judged here.
-     */
-    withoutCard(url: string, body: string | null | undefined): 'continue' | 'refuse' | null;
-    /**
-     * How the card would reach the processor on this request (`token`, `cse`
-     * or `hosted_form`; absent on the entry means `token`), or null when the
-     * registry does not recognize it. The adapters read it to decide whether an
-     * approval outlives the page's own request: a hosted form is a navigation
-     * and cannot.
-     */
-    checkoutModeOf(url: string, method?: string): CheckoutMode | null;
-    /**
-     * Glob url patterns covering every host the CURRENT registry can send a card
-     * to — what a raw CDP connection has to hand `Fetch.enable` before any card
-     * request can be paused. attachToCdp calls this for you.
-     *
-     * Call syncRegistry() FIRST: without it these cover only the built-in PSPs,
-     * and a request the API knows about is never paused at all. Deliberately
-     * WIDER than the recognizers themselves (a glob cannot express an anchored
-     * host regex); isCardRequest is the exact check and runs on every request
-     * these patterns pause.
-     */
-    cardUrlPatterns(): string[];
-    /** Wait for real device approval before the caller starts native tokenization. */
-    prepareCheckout(input: PrepareCheckoutInput): Promise<PreparedCheckout>;
-    /** Cancel only an unconsumed preparation; a bound request is reconciled separately. */
-    cancelPreparation(id: string): Promise<void>;
-    observePreparation(id: string, guidance: 'presented_not_filled' | 'not_presented', reason?: string): Promise<void>;
-    reportDuplicateGuard(authorizationId: string): Promise<void>;
-    /**
-     * Hand us a paused tokenization request. We ask the cardholder to approve,
-     * their device supplies the card and calls the merchant, and you get back the
-     * response to replay into the browser. Your process never sees a card.
-     */
-    authorize(input: AuthorizeInput): Promise<ReplayResponse>;
-    /** A lost bind acknowledgement must never resume the request. Recover metadata only for safe cleanup. */
-    private retireUncertainPreparation;
-    /**
-     * Retire an authorization the runtime is done with. A 409 or missing
-     * response remains unknown.
-     *
-     * `merchant_request_aborted` (the default): the merchant request is gone
-     * and the row must still be awaiting the person with no replay started; the
-     * acknowledgement carries `processor_request_started: false`.
-     *
-     * `merchant_never_retried`: the page abandoned its request while the person
-     * decided, the adapter kept the approval for the page's retry, and none
-     * came. The row may already be `approved` (a token or ciphertext minted on
-     * the device that this runtime handed to no request), so
-     * `processor_request_started` says whether the processor was asked; the API
-     * stamps this reason only where no charge can have been made and answers
-     * 409 otherwise. The acknowledgement echoes the reason the row actually
-     * carries: a row retired earlier under the other runtime reason answers
-     * with that one.
-     */
-    cancelAuthorization(authorizationId: string, reason?: RuntimeCancelReason): Promise<{
-        id: string;
-        status: 'declined';
-        reason: RuntimeCancelReason;
-        cancelled: true;
-        processor_request_started: boolean;
-    }>;
-    /**
-     * Ask whether the page may pay with the Stripe card token an approval
-     * produced: a PaymentIntent confirm that carries no card and pays with
-     * exactly the approved payment method, card token, confirmation token or
-     * source. The API reads the payment from Stripe and answers only for the
-     * approved amount and currency on the same Stripe account; any other answer
-     * rejects with a CheckoutApiError whose code says why (for example
-     * `continuation_not_bound`, `amount_mismatch`). Nothing is charged here:
-     * the adapters continue the page's own request once this resolves.
-     */
-    checkStripeContinuation(authorizationId: string, request: {
-        url: string;
-        method: string;
-        headers: Record<string, string>;
-        body: string;
-    }): Promise<{
-        paymentIntentId: string;
-        amount: number;
-        currency: string;
-    }>;
-    /**
-     * POST the create, with two typed twists: a 502 `amount_unverifiable`
-     * (Stripe did not answer the read-back) is retried on a short backoff
-     * instead of being left to the page's own retry loop, and a 409
-     * `amount_mismatch` becomes an AmountMismatchError at stage 'create' so the
-     * adapters treat it as an answered request, not a dead page.
-     */
-    private createAuthorization;
-    private token;
-    private inflight;
-    /**
-     * Exchange client credentials for an access token, reusing the cached one
-     * until it is nearly expired. Concurrent callers share a single in-flight
-     * exchange rather than each minting their own token.
-     */
-    private accessToken;
-    /**
-     * A preparation status read may retry two known connection failures, after
-     * 250ms and 500ms, while keeping its original approval deadline and signal.
-     * Only fetch and a successful response's body read belong to that retry:
-     * OAuth, HTTP errors, invalid JSON and every mutation remain outside it.
-     * The existing one-time 401 refresh carries the remaining read budget.
-     */
-    private call;
-    private post;
-    private get;
-    private readPreparation;
-}