@tuwaio/payments-sdk 0.0.0-stage → 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,2979 @@
+import { C as CheckoutWallet, N as NativeFee, a as PaymentFamily, P as PaymentsAdapter } from './types-Bp6JUt56.d-ByIsb1F7.cjs';
+export { b as PulsarTransactionParams, c as canPayWithQr, d as connectedWallet, f as familyOf, i as isWalletIconUrl, m as methodFamily, e as methodToken, n as networkName, p as payerFor, g as priceAdjustment, w as walletLabel } from './types-Bp6JUt56.d-ByIsb1F7.cjs';
+import * as react from 'react';
+import { ComponentType, ReactNode, ButtonHTMLAttributes, Context } from 'react';
+import { b as RefundPreview, B as Buyer } from './checkout-C05-kSiE.cjs';
+import { RefundPhase, RefundState, CheckoutError, PaymentInstructions, CheckoutStore, CheckoutState, CheckoutView, CheckoutMethod, CheckoutQuote, PayerProofMessage, CheckoutApi, EventSourceConstructor, RefundStore, AutoChargeOffer, CheckoutPhase, CheckoutMerchant } from './checkout.cjs';
+import { NovaPaymentsLabels, CheckoutLocale, NovaPaymentsLabelOverrides } from './i18n.cjs';
+import { Transaction } from '@tuwaio/sdk/pulsar';
+import { StatusTone, StatusEdgeProps } from '@tuwaio/sdk/nova-core';
+import { TxStatusVisualProps, TxProgressIndicatorProps, HashLinkProps } from '@tuwaio/sdk/nova-transactions';
+import { NovaConnectProviderPropsWithCustomization } from '@tuwaio/sdk/nova-connect';
+import { SatelliteConnectProviderProps } from '@tuwaio/sdk/satellite/react';
+export { shortAddress } from '@tuwaio/sdk/orbit';
+import 'zustand/vanilla';
+
+/**
+ * The automatic payments offer of a subscription, after a paid period: the limit the seller may take each period, the
+ * period, the paying wallet and the seller's wallet the charges are paid to, until when, that Quasar sends each charge
+ * for the seller, and how to turn it off. "Allow" takes the wallet through what it needs: to the network of the
+ * permission, from a plain account to its smart account (see `smartAccountStatus`: the offer says so first, and MetaMask
+ * asks only then), then the ERC-7715 permission, which Quasar takes (the paid outcome then says automatic payments are
+ * on); "Not now" keeps paying each invoice. Without a wallet the main button connects one.
+ *
+ * Each press is a try with a number: Cancel closes the window, and an answer the wallet gives later changes nothing on
+ * the page, except that a permission it grants still reaches Quasar. A request still open in the wallet is not asked
+ * again, so the buyer never approves two; what the wallet already granted is not asked again after a refusal of the free
+ * confirmation.
+ *
+ * Side effects: wallet prompts and, for a plain account, a transaction whose fee the buyer pays; `POST permission` of
+ * the checkout; network and wallet reads for the kind of account.
+ *
+ * @returns The automatic payments step.
+ */
+declare function AutoPayScreen(): react.JSX.Element | null;
+
+/**
+ * The buyer details step, shown when the merchant's settings ask for the buyer and the invoice was issued without
+ * them: the email, then a company invoice on request (a card under the email), then the details — the name, the
+ * country, the address, and for a company its tax ID. The fields carry `autocomplete` tokens (WCAG 1.3.5), errors are
+ * tied to their fields and announced, and the invoice document is issued once the details are taken.
+ *
+ * @returns The buyer details step.
+ */
+declare function BuyerScreen(): react.JSX.Element | null;
+
+/**
+ * @file What the checkout shows for the state of a checkout store: the screen, the steps, the payment methods by
+ * token, and when to count down and warn about time.
+ */
+
+/**
+ * A screen of the checkout: the steps of a payment (`buyer`, `method`, `confirmWallet` — the paying wallet confirms the
+ * invoice with a free signature before the price —, `pay` or `qr`, `confirm`, `autoPay`), a payment Quasar could not
+ * confirm (`unconfirmed`: it may still arrive, so the buyer checks the wallet before paying again) or its outcome.
+ */
+type CheckoutScreen = 'loading' | 'error' | 'buyer' | 'method' | 'confirmWallet' | 'pay' | 'qr' | 'confirm' | 'unconfirmed' | 'paid' | 'autoPay' | 'autoPayOff' | 'underpaid' | 'held' | 'refunded' | 'expired' | 'cancelled' | 'replaced' | 'blocked';
+/** Choices of the buyer that the checkout store does not hold. */
+interface CheckoutScreenChoices {
+    /** Pay from a wallet in this browser (default) or scan a QR code with a phone. */
+    payWith?: 'wallet' | 'qr';
+    /** The buyer opened the automatic payments offer after paying the first period of a subscription. */
+    autoPay?: boolean;
+    /** The buyer opened the screen that turns automatic payments off, while they are on. */
+    autoPayOff?: boolean;
+    /**
+     * The buyer continues on a phone: with `payWith` `qr`, the QR code of the payment page shows before any price is
+     * locked (an EVM method, paid from the phone's wallet on that page).
+     */
+    handoff?: boolean;
+    /**
+     * The labels of the invoice's language are loaded (default `true`). Until then the checkout stays on `loading`, so
+     * its first screen never shows in English before the buyer's language arrives.
+     */
+    labelsReady?: boolean;
+    /**
+     * The buyer continued with a wallet that must confirm the invoice before the price (`payerProof` of the checkout
+     * store is `required`): the step that confirms it shows while the store waits for the signature and locks the price
+     * after it.
+     */
+    confirmWallet?: boolean;
+}
+/**
+ * Whether the permission screen can open from this phase: another wallet takes over a permission from the steps before a
+ * payment, not from an outcome that keeps its own screen.
+ *
+ * @param phase - The phase of the checkout store.
+ * @returns Whether "Use this wallet" leads somewhere.
+ */
+declare const takeOverOpens: (phase: string | undefined) => boolean;
+/**
+ * The screen for the state of a checkout store.
+ *
+ * @param state - The `phase`, `checkout` and `quote` of the store.
+ * @param state.phase - Where the payment stands.
+ * @param state.checkout - What the checkout token opens; `null` until loaded.
+ * @param state.quote - The locked price; while the first one is being locked the method screen stays, with its button
+ * busy, so a refused payer or a failed request is shown where the buyer chose (the step that confirms the wallet, when
+ * the price is locked after it).
+ * @param state.payerProof - Whether the connected wallet must confirm the invoice (`payerProof` of the checkout store;
+ * left out by older stores).
+ * @param state.error - The store's last error: a price refused after the signature shows on the method step.
+ * @param choices - What the buyer chose on the page.
+ * @returns The screen: `confirmWallet` once the buyer continued (`choices.confirmWallet`) while the wallet must
+ * confirm the invoice or confirms it, and after it until the price is locked (unless it was refused), also on an
+ * underpaid invoice whose rest another wallet pays, `qr` instead of `pay` when the buyer pays
+ * with a QR code (or the price was locked without a payer), `replaced` for an invoice the seller
+ * corrected, `autoPay` after a paid subscription period while the automatic payments offer is open, `loading` until
+ * the labels of the invoice's language are loaded, `unconfirmed` in the phase of that name of a current
+ * `@tuwaio/quasar-sdk` (Quasar could not confirm the payment, which may still arrive). While the store hands a transaction
+ * over again (`submit_retrying`) it is `confirm`: only Quasar is out of reach, and the payment goes on.
+ */
+declare function checkoutScreen(state: {
+    phase: CheckoutPhase;
+    checkout: CheckoutView | null;
+    quote?: CheckoutQuote | null;
+    readonly payerProof?: string;
+    error?: CheckoutError | null;
+}, choices?: CheckoutScreenChoices): CheckoutScreen;
+/** A step of the stepper in the checkout header. */
+interface CheckoutStep {
+    /** `details` (buyer details), `method`, `pay`, `confirm`, `autoPay` (automatic payments of a subscription). */
+    key: 'details' | 'method' | 'pay' | 'confirm' | 'autoPay';
+    /** Before, at or after the current step. */
+    state: 'done' | 'current' | 'upcoming';
+}
+/**
+ * The steps of the stepper for a screen.
+ *
+ * @param screen - The current screen.
+ * @param options - Steps that apply to this invoice.
+ * @param options.withDetails - The checkout asked for the buyer details first.
+ * @returns The steps, or `null` on an outcome screen, whose header shows its title instead.
+ */
+declare function checkoutSteps(screen: CheckoutScreen, options?: {
+    withDetails?: boolean;
+}): CheckoutStep[] | null;
+/**
+ * The steps of the stepper on the paid screen of a payment page, all done. Elsewhere that screen has no stepper
+ * ({@link checkoutSteps}).
+ *
+ * @param options - Steps that apply to this invoice.
+ * @param options.withDetails - The checkout asked for the buyer details first.
+ * @returns The steps.
+ */
+declare function paidSteps(options?: {
+    withDetails?: boolean;
+}): CheckoutStep[];
+/** The methods of one token, as the method step shows it: the token first, then its network. */
+interface CheckoutTokenGroup {
+    /** Token symbol. */
+    symbol: string;
+    /** Its methods, one per network: the connected wallet's network first, then the Popular ones. */
+    methods: CheckoutMethod[];
+    /** The merchant marks one of its methods Popular. */
+    featured: boolean;
+    /** One of its methods is on the network of the connected wallet. */
+    inWallet: boolean;
+}
+/**
+ * Groups payment methods by token: the token picked first, then its network. Groups with a
+ * method on the connected wallet's network come first, then those the merchant marks Popular; otherwise the
+ * merchant's order stays.
+ *
+ * @param methods - The methods of the checkout, in the merchant's order.
+ * @param walletChainId - CAIP-2 chain of the connected wallet, if any.
+ * @returns The groups.
+ */
+declare function groupMethodsByToken(methods: CheckoutMethod[], walletChainId?: string | null): CheckoutTokenGroup[];
+/**
+ * Where the invoice deadline stands for the checkout: the countdown shows through every step of the payment, also while
+ * the wallet signs, the payment is handed to Quasar and it confirms, and on a payer the wallet check refused
+ * (`blocked`, where the buyer can pay with another wallet); it ends with the paid outcome and with the outcomes in which
+ * a deadline means nothing. A payment sent before the deadline counts: Quasar keeps an `open` or `underpaid` invoice
+ * while a payment it learned of before the deadline confirms (for a limited time), and holds a payment that lands after
+ * the invoice closed for the seller to accept or return.
+ *
+ * @param status - The invoice state (`checkout.invoice.status`).
+ * @param screen - The screen shown.
+ * @param restPayable - Whether the rest of an underpaid invoice can be paid (`invoice.restPayable`).
+ * @returns `paying` while the buyer can still pay (the countdown shows and screen readers hear the minutes left),
+ * `confirming` while the payment is on its way (the countdown shows; at zero the confirm step says that the payment
+ * sent in time is being confirmed) and while Quasar could not confirm it (`unconfirmed`: the buyer checks the wallet
+ * before paying again, so no minutes left to pay are announced), or `null` once the payment succeeded (`paid`,
+ * `autoPay`), on the outcomes in
+ * which a deadline means nothing (`held`, `refunded`, `expired`, `cancelled`, `replaced`) and for an invoice that can
+ * no longer be paid. `closed` while part of an underpaid invoice arrived and its rest cannot be paid: the countdown still
+ * shows, as the time after which the seller can refund, and no minutes left to pay are announced.
+ */
+declare function deadlineState(status: string, screen: CheckoutScreen, restPayable?: boolean): 'paying' | 'confirming' | 'closed' | null;
+/** Minutes before the invoice deadline at which screen readers hear how much time is left. */
+declare const DEADLINE_ANNOUNCEMENTS: readonly [10, 5, 1];
+/**
+ * Whether a tick of the invoice countdown crossed one of the announcement minutes ({@link DEADLINE_ANNOUNCEMENTS} by
+ * default): the checkout announces the time left then (WCAG 2.2.1), not every second.
+ *
+ * @param previousMs - Time left at the previous tick; `null` on the first one.
+ * @param ms - Time left now.
+ * @param announcements - The minutes before the deadline to announce at.
+ * @returns The minutes to announce (the nearest when several were crossed at once), or `null`.
+ */
+declare function deadlineAnnouncement(previousMs: number | null, ms: number, announcements?: readonly number[]): number | null;
+/** How long before a locked price ends the checkout offers to keep it (WCAG 2.2.1: 20 seconds at least). */
+declare const QUOTE_WARNING_MS = 60000;
+/**
+ * What the active wallet changing does to a locked price. A wallet connected to turn automatic payments off pays
+ * nothing, so it changes nothing while that screen is open; back on the payment, what follows applies.
+ *
+ * @param params - What the change happens over.
+ * @param params.autoPayOffOpen - The screen that turns automatic payments off is open.
+ * @param params.phase - The phase of the payment; a price is locked only in `awaitingPayment`.
+ * @param params.quotePayer - The payer the price is locked for.
+ * @param params.payer - The payer the active wallet gives for the method of that price, or `null`.
+ * @returns `keep`: nothing changes; `lock`: lock the price again for `payer`; `release`: release it, back to the methods.
+ */
+declare function lockedPriceOnWallet(params: {
+    autoPayOffOpen: boolean;
+    phase: string;
+    quotePayer: string | null | undefined;
+    payer: string | null;
+}): 'keep' | 'lock' | 'release';
+/**
+ * What the active wallet changing does on the step that confirms the wallet, where no new price is locked yet: the step
+ * asks the wallet connected to sign, never the one the store last held.
+ *
+ * @param params - What the change happens over.
+ * @param params.open - The step shows.
+ * @param params.storePayer - The payer the store holds, which the step would ask to sign for.
+ * @param params.payer - The payer the active wallet gives for the chosen method, or `null`.
+ * @param params.paysRest - That wallet may pay: only the first wallet pays the rest of an underpaid invoice.
+ * @returns `keep`: nothing changes; `follow`: this wallet signs, or goes on to the price if it confirmed already; `leave`:
+ * the step closes, with no wallet to ask.
+ */
+declare function walletOnConfirmStep(params: {
+    open: boolean;
+    storePayer: string | null;
+    payer: string | null;
+    paysRest: boolean;
+}): 'keep' | 'follow' | 'leave';
+/**
+ * Whether a locked price is in its last minute, when the checkout offers to keep it.
+ *
+ * @param ms - Time left of the price lock.
+ * @returns `true` from {@link QUOTE_WARNING_MS} down to the end.
+ */
+declare function isQuoteEnding(ms: number): boolean;
+/**
+ * Whether the merchant checks paying wallets before payment: `amlScreening` of the checkout, `true` when its AML mode
+ * is `block` or `flag`. The pay step says so only then. A checkout of a Quasar version without the field counts as
+ * checking, as the pay step always said before.
+ *
+ * @param checkout - What the checkout token opens.
+ * @returns `false` only when the checkout says that the merchant does not check paying wallets.
+ */
+declare function screensPayingWallets(checkout: CheckoutView): boolean;
+/**
+ * Whether a payment this page handed over is on its way: `paymentOnTheWay` of the checkout store of a current
+ * `@tuwaio/quasar-sdk` (`true` from a successful submit or relay, also a relay answered `sending`, which has no
+ * transaction key, until the payment settles or fails), else, with an older store without the field, whether the page
+ * handed over a transaction (`txKey` or `txHash`).
+ *
+ * @param state - The state of the checkout store.
+ * @param state.paymentOnTheWay - What the store says, when it has the field.
+ * @param state.txKey - The transaction this page submitted.
+ * @param state.txHash - The transaction of the payment, once known.
+ * @param state.error - The store's error, which names a transaction of its own when its nonce is unexplained.
+ * @returns Whether a payment of this page may still arrive.
+ */
+declare function isPaymentOnTheWay(state: Pick<CheckoutState, 'txKey' | 'txHash'> & {
+    readonly paymentOnTheWay?: boolean;
+}): boolean;
+/**
+ * Whether Quasar reports a payment of the invoice on its way, whoever handed it over (another tab, the page before it
+ * was reloaded, a Solana Pay transfer Quasar found): `invoicePaymentOnTheWay` of the checkout store of a current
+ * `@tuwaio/quasar-sdk`, else, with an older store without the field, the `pendingPayments` of the checkout it read.
+ *
+ * @param state - The state of the checkout store.
+ * @param state.invoicePaymentOnTheWay - What the store says, when it has the field.
+ * @param checkout - What the checkout token opens; `null` until loaded.
+ * @returns Whether a payment of the invoice may still arrive.
+ */
+declare function isInvoicePaymentOnTheWay(state: object & {
+    readonly invoicePaymentOnTheWay?: boolean;
+}, checkout: CheckoutView | null): boolean;
+/** What {@link sentBeforeDeadline} decides with. */
+interface SentBeforeDeadlineParams {
+    /**
+     * The state of the checkout store: `paymentCountsUntil`, `paymentSentInTime` and `paymentOnTheWay` of a current
+     * `@tuwaio/quasar-sdk` (`txKey`/`txHash` with an older one).
+     */
+    state: object & {
+        readonly paymentCountsUntil?: string | null;
+        readonly paymentSentInTime?: boolean | null;
+        readonly paymentOnTheWay?: boolean;
+        readonly txKey?: string | null;
+        readonly txHash?: string | null;
+    };
+    /** The checkout: its invoice's `paymentCountsUntil` tells whether Quasar reports it, and is read with an older store. */
+    checkout: CheckoutView;
+    /** When this page handed its payment over, by its clock; `null` when it does not know (a reload, another tab). */
+    handedOverAt: number | null;
+    /** The invoice deadline (`dueAt`) in milliseconds. */
+    dueAt: number;
+}
+/**
+ * Whether the payment on its way counts as sent before the invoice deadline. For a payment this page handed over that
+ * Quasar already reported on, Quasar's word on that payment decides (`paymentSentInTime` of the checkout store: its keys
+ * are among the `onTimeTxKeys` Quasar learned of before `dueAt`), whatever the clock of the page says. Otherwise Quasar
+ * says it for the invoice with `paymentCountsUntil` (it learned of a payment of the invoice before `dueAt` and waits for
+ * it): its word decides, except for a payment this page handed over at or after the deadline by its clock, which Quasar
+ * holds even while it waits for another one. A Quasar that does not report the field leaves the clock of the page: a
+ * payment this page handed over before the deadline.
+ *
+ * @param params - See {@link SentBeforeDeadlineParams}.
+ * @returns `true` to say that the payment was sent in time and is being confirmed.
+ */
+declare function sentBeforeDeadline({ state, checkout, handedOverAt, dueAt }: SentBeforeDeadlineParams): boolean;
+/**
+ * Whether the last error says that the payment can never pay the invoice: `payment_failed` (reverted, cancelled…) or
+ * `payment_mismatch` (it does not pay the invoice: a wrong amount or recipient…), with the reason Quasar gave. A failure
+ * without a reason comes from a Quasar or a `@tuwaio/quasar-sdk` that cannot tell a final failure from a payment that
+ * may still arrive, so it does not count, nor does `settlement_failed` (a payment the network confirmed that Quasar has
+ * not recorded yet, which an older store reports as `payment_mismatch`).
+ *
+ * @param error - The store's error.
+ * @returns `true` when the payment failed for good.
+ */
+declare function isFinalPaymentFailure(error: CheckoutError | null | undefined): boolean;
+/**
+ * Whether the last error says that the transaction succeeded on chain but does not pay the invoice (a wrong amount,
+ * asset or recipient, no Solana Pay reference, sent before the price was locked…): `payment_mismatch` of a current
+ * `@tuwaio/quasar-sdk`, or `payment_failed` with such a reason from an older one. It may have moved money, so the
+ * checkout never says that it did not go through or that nothing was charged: it says that the transaction does not pay
+ * the invoice, and to contact the seller if money left the wallet. A payment the network confirmed that Quasar has not
+ * recorded yet (`settlement_failed`, which an older store reports as `payment_mismatch`) is not one: it pays the
+ * invoice once Quasar records it.
+ *
+ * @param error - The store's error.
+ * @returns `true` for a transaction that does not pay the invoice.
+ */
+declare function isMovedMoneyFailure(error: CheckoutError | null | undefined): boolean;
+/**
+ * Whether the last error says that Quasar credited the transaction to another invoice of the seller, the one the
+ * wallet that sent it confirmed or whose mark it carries (`tx_already_used` of a transaction that does not pay this
+ * invoice): the buyer names it to the seller if it was the payment of this invoice.
+ *
+ * @param error - The store's error.
+ * @returns `true` for a transaction that pays another invoice.
+ */
+declare function isPaidElsewhere(error: CheckoutError | null | undefined): boolean;
+/**
+ * Whether Quasar reports a payment of the invoice that may still arrive, with no time limit (one stuck past the minutes
+ * `pendingPayments` counts, or one whose result Quasar did not see and reads again for 24 hours):
+ * `invoicePaymentUnresolved` of the checkout store of a current `@tuwaio/quasar-sdk`, else the `unresolvedPayments` of
+ * the checkout it read. While it is `true` the checkout never says that nothing was charged.
+ *
+ * @param state - The state of the checkout store.
+ * @param state.invoicePaymentUnresolved - What the store says, when it has the field.
+ * @param checkout - What the checkout token opens; `null` until loaded.
+ * @returns Whether a payment of the invoice may still arrive.
+ */
+declare function isInvoicePaymentUnresolved(state: object & {
+    readonly invoicePaymentUnresolved?: boolean;
+}, checkout: CheckoutView | null): boolean;
+/**
+ * What the checkout tells the buyer about a payment that may have left the wallet and that Quasar did not confirm:
+ * `rechecked` (Quasar still reads it again, for up to 24 hours after it learned of it, and records it for the seller if
+ * it arrives), `retrying` (the checkout store keeps handing over a transaction the wallet sent, which Quasar has not
+ * received yet: keep the page open), `notReceived` (the store gave up handing it over after an hour: Quasar never
+ * received it), `contact` (a reason Quasar never reads again: a relay operation lost, `transaction_failed`, a Quasar
+ * or a store that does not say), `closed` (Quasar saw no result on chain within 24 hours and closed it),
+ * `takenElsewhere` (the page of another invoice handed the transaction over first: Quasar credits it to the invoice
+ * that the wallet that sent it confirmed, and the page shows the result while it follows the payment),
+ * `settlementRetrying` (the network confirmed it, but Quasar has not recorded it yet and settles it again daily, for 30
+ * days after it learned of it: `rechecked`), `settlementFailed` (the same, without Quasar saying that it still
+ * tries) and `invoiceFull` (the invoice takes no more payments: Quasar keeps the hash for the seller and follows nothing). For all but `rechecked` and `retrying` the buyer contacts the seller with the transaction hash; after
+ * `takenElsewhere`, `settlementRetrying` and `settlementFailed` the payment left the wallet, so the checkout offers no
+ * payment.
+ */
+type UnconfirmedFollowUp = 'nonceSpent' | 'unmined' | 'rechecked' | 'retrying' | 'notReceived' | 'contact' | 'closed' | 'takenElsewhere' | 'settlementRetrying' | 'settlementFailed' | 'invoiceFull';
+/**
+ * What to tell the buyer about a payment Quasar did not confirm, from the store's error: `payment_unconfirmed` with
+ * `rechecked` (set by a current `@tuwaio/quasar-sdk` only while Quasar reads the payment again) promises the 24-hour
+ * re-check, its `submit_retrying` and `submit_failed` reasons are the store's hand-over, `tx_already_used` a transaction
+ * another invoice handed over first, any other is for the seller; `payment_failed` with the reason
+ * `unresolved_after_24h` is a payment Quasar closed without a result; the reason `settlement_failed` (`payment_mismatch`
+ * of an older store) a confirmed payment Quasar has not recorded yet, which Quasar settles again daily only while
+ * `rechecked` (for 30 days after it learned of it).
+ *
+ * @param error - The store's error.
+ * @returns See {@link UnconfirmedFollowUp}; `null` for any other error, or none.
+ */
+declare function unconfirmedFollowUp(error: CheckoutError | null | undefined): UnconfirmedFollowUp | null;
+/**
+ * The transaction the buyer names to the seller about a payment Quasar did not confirm: the one this page handed over
+ * (`txHash`, else `txKey` of the checkout store), else, on a reopened page, the newest one Quasar rejected.
+ *
+ * @param state - The state of the checkout store.
+ * @param state.txKey - The transaction this page submitted.
+ * @param state.txHash - The transaction of the payment, once known.
+ * @param checkout - What the checkout token opens; `null` until loaded.
+ * @returns The transaction hash (EVM) or signature (Solana), or `null` when the page does not know it.
+ */
+declare function unconfirmedTxKey(state: Pick<CheckoutState, 'txKey' | 'txHash'> & {
+    error?: object | null;
+}, checkout: CheckoutView | null): string | null;
+
+/**
+ * @file Handing a payment the wallet sent over to the app's Pulsar store when the checkout closes before Quasar
+ * settled it: Pulsar keeps tracking it, and Nova Transactions shows its toast.
+ */
+
+/** A payment the wallet sent, as the checkout remembers it until Quasar settles it. */
+interface SentPayment {
+    /** The transaction hash (EVM) or signature (Solana). */
+    txKey: string;
+    /** What the wallet sent. */
+    instructions: PaymentInstructions;
+    /** The sender. */
+    account: string;
+    /** The connector of the wallet. */
+    connectorType: string;
+}
+/**
+ * The part of the app's Pulsar store (`createPulsarStore` of `@tuwaio/pulsar-core`) the checkout uses: pass
+ * `injectExternalPendingTxs` of the store, as `pulsar` of `NovaPaymentsProvider`.
+ */
+interface PaymentsPulsar {
+    /**
+     * Adds pending transactions to the pool and tracks them.
+     *
+     * @param transactions - The pending transactions.
+     * @returns Resolves when their trackers started.
+     */
+    injectExternalPendingTxs(transactions: Transaction[]): Promise<void>;
+}
+/**
+ * Whether a sent payment still needs tracking when the checkout closes: Quasar has not settled it, and it did not
+ * fail on-chain or turn out not to pay the invoice.
+ *
+ * @param state - The `phase` and `error` of the checkout store.
+ * @param state.phase - Where the payment stands.
+ * @param state.error - The last failure; `payment_failed` means the transaction failed on-chain, `payment_mismatch`
+ * that it succeeded without paying the invoice: Quasar already has the final word on both.
+ * @returns `true` to hand it over.
+ */
+declare function shouldHandOver(state: {
+    phase: CheckoutPhase;
+    error: CheckoutError | null;
+}): boolean;
+/** What {@link handOverPayment} needs. */
+interface HandOverParams {
+    /** The adapter of the payment's chain family. */
+    adapter: PaymentsAdapter | undefined;
+    /** The app's Pulsar store, if any. */
+    pulsar: PaymentsPulsar | undefined;
+    /** The sent payment. */
+    payment: SentPayment;
+    /** The labels of the checkout language. */
+    labels: NovaPaymentsLabels;
+    /** The seller's name. */
+    merchant: string;
+    /** The invoice: its ID and number (`null` before its document is issued). */
+    invoice: {
+        id: string;
+        number: string | null;
+    };
+    /** The amount sent, with its symbol. */
+    amount: string;
+}
+/**
+ * Hands a sent payment over to the app's Pulsar store as a pending transaction: Pulsar tracks it and keeps it in the
+ * history, and Nova Transactions shows its toast. Without a Pulsar store, or an adapter that describes its
+ * transactions, nothing happens.
+ *
+ * Side effects: writes the transaction to the Pulsar store (persisted to `localStorage` by `createPulsarStore`) and
+ * starts its tracker (network reads).
+ *
+ * @param params - See {@link HandOverParams}.
+ * @returns Whether the payment was handed over.
+ */
+declare function handOverPayment({ adapter, pulsar, payment, labels, merchant, invoice, amount, }: HandOverParams): Promise<boolean>;
+
+/** Props of {@link CheckoutHeader}. */
+interface CheckoutHeaderProps {
+    /** The heading of an outcome screen, shown instead of the steps. */
+    title?: ReactNode;
+    /** The checkout asked for the buyer details first: the steps start with them. */
+    withDetails?: boolean;
+}
+/**
+ * The header of the checkout: the steps (or the heading of an outcome), then the language menu and the close button,
+ * which stay in the top right corner on every screen and on a phone. On a phone the steps move under the order and
+ * the header shows the merchant.
+ *
+ * @param props - See {@link CheckoutHeaderProps}.
+ * @returns The header.
+ */
+declare function CheckoutHeader({ title, withDetails }: CheckoutHeaderProps): react.JSX.Element;
+/** The steps on a phone, under the order. @internal */
+declare function MobileSteps({ withDetails }: {
+    withDetails?: boolean;
+}): react.JSX.Element | null;
+
+/** Props of {@link CheckoutStepper}. */
+interface CheckoutStepperProps {
+    /** The steps, from `checkoutSteps`. */
+    steps: CheckoutStep[];
+    /** The labels of the checkout language. */
+    labels: NovaPaymentsLabels;
+    /** Classes added to the list. */
+    className?: string;
+    /**
+     * Classes added to a step (`customization.classNames.step` of `PaymentCheckout`).
+     *
+     * @param step - The step.
+     * @param index - Its position, from 0.
+     * @returns The classes, or nothing.
+     */
+    stepClassName?: (step: CheckoutStep, index: number) => string | undefined;
+}
+/**
+ * The steps of the payment, as an ordered list: done steps show a check, the current one is marked
+ * `aria-current="step"` and named "Step 2 of 3: Pay" to screen readers (WCAG 1.3.1). When the names of all steps do not
+ * fit (a phone, a long language), only the current step shows its name; screen readers still read every name.
+ *
+ * @param props - See {@link CheckoutStepperProps}.
+ * @returns The stepper.
+ */
+declare function CheckoutStepper({ steps, labels, className, stepClassName }: CheckoutStepperProps): react.JSX.Element;
+
+/** The outcomes this screen shows. */
+type OutcomeKind = Extract<CheckoutScreen, 'unconfirmed' | 'underpaid' | 'held' | 'refunded' | 'expired' | 'cancelled' | 'replaced' | 'blocked'>;
+/**
+ * An outcome other than paid: a payment Quasar could not confirm (`unconfirmed`: it may still arrive, so the buyer
+ * checks the wallet before paying again; only while Quasar still reads it again, `error.rechecked` of the checkout
+ * store, the screen says that Quasar checks it for 24 hours and records it for the seller if it arrives; while the
+ * store hands a transaction the wallet sent over again, the buyer keeps the page open; otherwise (a reason Quasar never
+ * reads again, a hand-over the store gave up) the buyer contacts the seller with the transaction hash, which the screen
+ * shows; a transfer that moved money without paying the invoice says so, and one Quasar credited to another invoice
+ * says that it pays that one; a transaction the page of another invoice handed over first, which Quasar credits to the
+ * invoice whose quoted wallet sent it, and a payment the network confirmed that Quasar has not recorded yet are named
+ * with their hash for the seller, and the buyer is asked not to pay again; no payment is offered, only, on a payable
+ * invoice and for a payment that may not have left the wallet, "The payment did not leave my wallet", which goes back
+ * to it with `payAgain` of the checkout store), an
+ * underpaid invoice ("Pay the rest"), a payment the seller reviews (screening,
+ * late, overpaid, after the price lock ran out), a refunded invoice, an expired one (with what arrived before the
+ * deadline, which the seller can refund; never "nothing was charged" while a payment may still arrive: one this page
+ * handed over or saw on its way, or that the wallet sent, also after the checkout stopped following it, which Quasar
+ * records and shows to the seller if it arrives, one Quasar could not confirm or reports as unresolved, to check in the
+ * wallet, one Quasar does not read again or closed after 24 hours without a result, for the seller with its transaction
+ * hash, one that does not pay the invoice and may have moved money, and after a QR code showed, a payment made with it,
+ * as this page does not see it; while this page follows a payment on its way, until when it does, `followingUntil` of
+ * the checkout store), a cancelled one (the same: never "nothing was charged" while a payment may still
+ * arrive, also after a QR code showed, and "recorded if it arrives" only for a payment Quasar records), a corrected one
+ * ("Open <new invoice>" opens it here) and a payer the wallet check refused ("Use another wallet"). Each offers to
+ * contact the seller.
+ *
+ * @param props - The outcome.
+ * @param props.kind - Which outcome.
+ * @returns The outcome step.
+ */
+declare function OutcomeScreen({ kind }: {
+    kind: OutcomeKind;
+}): react.JSX.Element | null;
+
+/** What every class name function of {@link PaymentCheckoutClassNames} receives. */
+interface CheckoutPartState {
+    /** The screen shown. */
+    screen: CheckoutScreen;
+    /** The state of the checkout store: its phase, the chosen method, the locked price, the last error. */
+    checkoutState: CheckoutState;
+    /** The checkout, once loaded. */
+    checkout: CheckoutView | null;
+}
+/**
+ * Class name functions of the parts of {@link PaymentCheckout}. Each returns classes added after the default ones of
+ * its part (or nothing), from the state of the checkout and what the part knows; `className` of a replacement
+ * component (`PaymentCheckoutComponents`) gets them too. A color or size a part already sets is changed with the
+ * `--tuwa-*` theme variables of `@tuwaio/nova-core`, or by replacing the part: which of two classes for the same
+ * property wins depends on the order of the stylesheets.
+ */
+interface PaymentCheckoutClassNames {
+    /**
+     * The checkout block with the order panel, the header and the screen (where `className` of `PaymentCheckout` goes:
+     * inside the dialog, or the bordered block in the page).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    container?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The order panel on the left (from 640 px).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    summary?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The order above the steps on a phone.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    compactSummary?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The header: the steps (or the heading of an outcome), the language menu and the close button.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    header?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The list of steps.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    stepper?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * One step of the list.
+     *
+     * @param params - The state of the checkout and the step.
+     * @param params.step - The step: its key and whether it is done, current or upcoming.
+     * @param params.index - Its position, from 0.
+     * @returns Classes to add.
+     */
+    step?: (params: CheckoutPartState & {
+        step: CheckoutStep;
+        index: number;
+    }) => string | undefined;
+    /**
+     * The area of the screen, under the header. It scrolls in a modal and inline; on a page the window does.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    body?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The content of a step screen (buyer details, method, QR code, automatic payments), with its heading.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    screen?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The bottom of a screen, with its main button.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    footer?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The main button of a screen (Continue, Pay, Sign to pay, Pay the rest…).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    primaryButton?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The second action under the main button (back, close, not now, contact).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    secondaryButton?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * A refusal or error message of a screen.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    error?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * A token card of the method step.
+     *
+     * @param params - The state of the checkout and the token.
+     * @param params.group - The token and its methods.
+     * @param params.selected - Whether it is selected.
+     * @returns Classes to add.
+     */
+    tokenOption?: (params: CheckoutPartState & {
+        group: CheckoutTokenGroup;
+        selected: boolean;
+    }) => string | undefined;
+    /**
+     * A network option of the method step (when the token is on several networks).
+     *
+     * @param params - The state of the checkout and the method.
+     * @param params.method - The method: the token on this network.
+     * @param params.selected - Whether it is selected.
+     * @returns Classes to add.
+     */
+    networkOption?: (params: CheckoutPartState & {
+        method: CheckoutMethod;
+        selected: boolean;
+    }) => string | undefined;
+    /**
+     * A "Pay with" option of the method step.
+     *
+     * @param params - The state of the checkout and the option.
+     * @param params.payWith - `wallet` (a wallet in this browser) or `qr` (a QR code on a phone).
+     * @param params.selected - Whether it is selected.
+     * @returns Classes to add.
+     */
+    payWithOption?: (params: CheckoutPartState & {
+        payWith: 'wallet' | 'qr';
+        selected: boolean;
+    }) => string | undefined;
+    /**
+     * The card of the seller's consent on the method step (`checkout.consent`): the box the buyer ticks and the seller's
+     * words.
+     *
+     * @param params - The state of the checkout and the consent.
+     * @param params.checked - Whether the buyer ticked it.
+     * @param params.required - Whether the buyer cannot continue without ticking it.
+     * @returns Classes to add.
+     */
+    consentOption?: (params: CheckoutPartState & {
+        checked: boolean;
+        required: boolean;
+    }) => string | undefined;
+    /**
+     * A card of grouped facts (the transaction, the rate and fees, the terms of automatic payments).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    detailsCard?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * A row of a card of facts (rate, network fee, recipient…).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    detailRow?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The total of the order panel.
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    total?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * A QR code (Solana Pay, or the payment page for a phone).
+     *
+     * @param params - The state of the checkout.
+     * @returns Classes to add.
+     */
+    qrCode?: (params: CheckoutPartState) => string | undefined;
+    /**
+     * The icon of an outcome other than paid.
+     *
+     * @param params - The state of the checkout and the outcome.
+     * @param params.kind - The outcome.
+     * @returns Classes to add.
+     */
+    statusIcon?: (params: CheckoutPartState & {
+        kind: OutcomeKind;
+    }) => string | undefined;
+    /**
+     * The strip and the wash of the status color along the top of the checkout, on a payment on its way and its outcome.
+     *
+     * @param params - The state of the checkout, and `tone`, the state the strip shows.
+     * @param params.tone - The state the strip shows.
+     * @returns Classes to add.
+     */
+    statusEdge?: (params: CheckoutPartState & {
+        tone: StatusTone;
+    }) => string | undefined;
+}
+/** Props of a replacement token card content (`PaymentCheckoutComponents.TokenOption`). */
+interface CheckoutTokenOptionProps {
+    /** The token and its methods, one per network. */
+    group: CheckoutTokenGroup;
+    /** Whether the token is selected. */
+    selected: boolean;
+}
+/** Props of a replacement network option content (`PaymentCheckoutComponents.NetworkOption`). */
+interface CheckoutNetworkOptionProps {
+    /** The method: the token on this network. */
+    method: CheckoutMethod;
+    /** Whether it is selected. */
+    selected: boolean;
+}
+/** Props of a replacement main button (`PaymentCheckoutComponents.PrimaryButton`): a `<button>`'s props and `busy`. */
+type CheckoutPrimaryButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** The action is running: the default button shows the Quasar loader and is disabled. */
+    busy?: boolean;
+};
+/** Props of a replacement QR code (`PaymentCheckoutComponents.QrCode`). */
+interface CheckoutQrCodeProps {
+    /** The text the code holds (a Solana Pay URL, or the payment page). */
+    value: string;
+    /** The text alternative of the code (WCAG 1.1.1). */
+    label: string;
+    /** The classes of the code: its size, and those of `classNames.qrCode`. */
+    className?: string;
+}
+/** Props of a replacement outcome icon (`PaymentCheckoutComponents.StatusIcon`). */
+interface CheckoutStatusIconProps {
+    /** The outcome. */
+    kind: OutcomeKind;
+    /** The classes of `classNames.statusIcon`. */
+    className?: string;
+}
+/** Props of a replacement screen (`PaymentCheckoutComponents.screens`). */
+interface CheckoutScreenProps {
+    /** The screen it replaces. */
+    screen: CheckoutScreen;
+}
+/**
+ * Components that replace parts of {@link PaymentCheckout}. A replacement reads the checkout with
+ * {@link useCheckoutContext} (the store, its state, the labels of the checkout language, the connected wallet and the
+ * actions of the steps).
+ */
+interface PaymentCheckoutComponents {
+    /** The header: the steps (or the heading of an outcome), the language menu and the close button; on a phone too. */
+    Header?: ComponentType<CheckoutHeaderProps>;
+    /**
+     * The content of the order panel on the left (from 640 px; `classNames.summary` styles the panel around it). On a page
+     * the panel is a flex column as tall as the sheet.
+     */
+    Summary?: ComponentType;
+    /** The order above the steps on a phone; `className` holds the classes of `classNames.compactSummary`. */
+    CompactSummary?: ComponentType<{
+        className?: string;
+    }>;
+    /** The list of steps, in the header and, on a phone, under the order. */
+    Stepper?: ComponentType<CheckoutStepperProps>;
+    /** The content of a token card of the method step (the card itself stays a radio button). */
+    TokenOption?: ComponentType<CheckoutTokenOptionProps>;
+    /** The content of a network option of the method step (the option itself stays a radio button). */
+    NetworkOption?: ComponentType<CheckoutNetworkOptionProps>;
+    /** The main button of every screen. */
+    PrimaryButton?: ComponentType<CheckoutPrimaryButtonProps>;
+    /** A QR code. Keep it dark on light: scanners read inverted codes badly. */
+    QrCode?: ComponentType<CheckoutQrCodeProps>;
+    /** The icon of an outcome other than paid. */
+    StatusIcon?: ComponentType<CheckoutStatusIconProps>;
+    /** The strip and the wash of the status color along the top of the checkout (`StatusEdge` of `@tuwaio/nova-core`). */
+    StatusEdge?: ComponentType<StatusEdgeProps>;
+    /** Whole screens, by the screen they replace (for example `paid` or `loading`). */
+    screens?: Partial<Record<CheckoutScreen, ComponentType<CheckoutScreenProps>>>;
+}
+/**
+ * Handlers of {@link PaymentCheckout}: some wrap an action of the buyer (call `proceed()` or `select()` to run it, or
+ * do something else instead), the others tell the app what happened. `onPaid`, `onClose` and `onContact` are props of
+ * the checkout.
+ */
+interface PaymentCheckoutHandlers {
+    /**
+     * The buyer picked a token or a network. Without the handler the method is chosen.
+     *
+     * @param params - The pick.
+     * @param params.method - The method picked.
+     * @param params.select - Chooses it.
+     */
+    onMethodSelect?: (params: {
+        method: CheckoutMethod;
+        select: () => void;
+    }) => void;
+    /**
+     * The buyer pressed "Continue" on the method step. Without the handler the checkout locks the price for the
+     * connected wallet (or connects one first), or shows the QR code.
+     *
+     * @param params - The step.
+     * @param params.method - The chosen method.
+     * @param params.payWith - `wallet` or `qr`.
+     * @param params.proceed - Goes on as the checkout would.
+     */
+    onQuote?: (params: {
+        method: CheckoutMethod;
+        payWith: 'wallet' | 'qr';
+        proceed: () => Promise<void>;
+    }) => void | Promise<void>;
+    /**
+     * The buyer pressed the pay button ("Pay", "Sign to pay"). Without the handler the wallet prompt opens.
+     *
+     * @param params - The payment.
+     * @param params.quote - The locked price: amount, recipient, network.
+     * @param params.method - The method.
+     * @param params.proceed - Opens the wallet prompt.
+     */
+    onSubmit?: (params: {
+        quote: CheckoutQuote;
+        method: CheckoutMethod;
+        proceed: () => Promise<void>;
+    }) => void | Promise<void>;
+    /**
+     * The buyer picked a language. Without the handler the checkout switches to it and saves it on the invoice.
+     *
+     * @param params - The language.
+     * @param params.locale - The language picked.
+     * @param params.proceed - Switches and saves it.
+     */
+    onLocaleChange?: (params: {
+        locale: CheckoutLocale;
+        proceed: () => Promise<void>;
+    }) => void | Promise<void>;
+    /**
+     * The phase of the checkout or the status of the invoice changed; also called once with the first ones.
+     *
+     * @param params - The state.
+     * @param params.phase - The phase of the checkout store.
+     * @param params.status - The invoice status, `null` before the invoice loads.
+     * @param params.screen - The screen shown.
+     */
+    onStatusChange?: (params: {
+        phase: CheckoutState['phase'];
+        status: CheckoutView['invoice']['status'] | null;
+        screen: CheckoutScreen;
+    }) => void;
+    /**
+     * The checkout got a new error (Quasar refused an action, or did not answer); the screen shows it.
+     *
+     * @param params - The error.
+     * @param params.error - Its code and message.
+     * @param params.screen - The screen shown.
+     */
+    onError?: (params: {
+        error: CheckoutError;
+        screen: CheckoutScreen;
+    }) => void;
+    /**
+     * The locked price ran out (`quote`), or the invoice expired (`invoice`). Either can happen while a payment is on its
+     * way: the invoice can still close while it confirms (Quasar waits for a payment it learned of
+     * before the deadline only for a limited time, and holds a payment that lands later for the seller to accept or
+     * return), so do not offer a new invoice at once when `paymentOnTheWay` is `true`; the checkout keeps following the
+     * invoice and shows a paid or held outcome if it changes.
+     *
+     * @param params - What expired.
+     * @param params.kind - `quote` or `invoice`.
+     * @param params.paymentOnTheWay - A payment is on its way: one this page handed over (`paymentOnTheWay` of the
+     * checkout store, or, with an older `@tuwaio/quasar-sdk`, a transaction handed over), one of the invoice Quasar
+     * reports (`invoicePaymentOnTheWay`: the page was reopened while it was on its way, another tab paid), or one Quasar
+     * could not confirm yet and reads again (`invoicePaymentUnresolved`).
+     */
+    onExpire?: (params: {
+        kind: 'quote' | 'invoice';
+        paymentOnTheWay: boolean;
+    }) => void;
+}
+/**
+ * Options of {@link PaymentCheckout}. Every text and accessible name comes from the labels, and amounts and dates
+ * follow the language of the checkout.
+ */
+interface PaymentCheckoutConfig {
+    /** Animations. They always follow `prefers-reduced-motion`; `disabled: true` turns them off for everyone. */
+    animation?: {
+        /** Turns the animations off. */
+        disabled?: boolean;
+    };
+    /** Whether the header shows the steps of the payment (default `true`). */
+    showSteps?: boolean;
+    /**
+     * Whether the pay step reads the wallet's balance (through the chain adapter) and, when it is short, offers what the
+     * wallet can pay with (default `true`).
+     */
+    balanceCheck?: boolean;
+    /**
+     * Minutes before the invoice deadline at which screen readers hear the time left, while the buyer can still pay (not
+     * once the payment is on its way) (default `[10, 5, 1]`).
+     */
+    deadlineAnnouncements?: readonly number[];
+}
+/** Customization of the Nova Transactions parts the confirm and paid steps show. */
+interface PaymentCheckoutChildCustomizations {
+    /** The status icon (`TxStatusVisual` of `@tuwaio/nova-transactions`). */
+    statusVisual?: Pick<TxStatusVisualProps, 'className' | 'iconClassNames'>;
+    /** The steps Sent, Confirming, Paid (`TxProgressIndicator` of `@tuwaio/nova-transactions`). */
+    progressIndicator?: Pick<TxProgressIndicatorProps, 'className' | 'stepClassNames' | 'StepComponent'>;
+    /** The transaction with its explorer link (`HashLink` of `@tuwaio/nova-transactions`). */
+    hashLink?: Pick<HashLinkProps, 'className' | 'classNames'>;
+}
+/** Customization of {@link PaymentCheckout} (`customization`). */
+interface PaymentCheckoutCustomization {
+    /** Classes added to the parts, from the state of the checkout. */
+    classNames?: PaymentCheckoutClassNames;
+    /** Components that replace parts. */
+    components?: PaymentCheckoutComponents;
+    /** Handlers that wrap the actions of the buyer or tell what happened. */
+    handlers?: PaymentCheckoutHandlers;
+    /** Options: animations, steps, the balance check, the deadline announcements. */
+    config?: PaymentCheckoutConfig;
+    /** Customization of the Nova Transactions parts of the confirm and paid steps. */
+    childCustomizations?: PaymentCheckoutChildCustomizations;
+}
+/** What a part adds to {@link CheckoutPartState} for its class name function. */
+type PartExtra<K extends keyof PaymentCheckoutClassNames> = Omit<Parameters<NonNullable<PaymentCheckoutClassNames[K]>>[0], keyof CheckoutPartState>;
+/**
+ * The classes `customization.classNames` adds to a part of the checkout.
+ *
+ * @param context - The checkout context (its customization, screen, store state and checkout).
+ * @param part - The part.
+ * @param extra - What the part adds to the state, such as the method of an option.
+ * @returns The classes, or `undefined`.
+ * @internal
+ */
+declare function checkoutClassName<K extends keyof PaymentCheckoutClassNames>(context: Pick<CheckoutContextValue, 'customization' | 'screen' | 'state' | 'checkout'>, part: K, extra?: PartExtra<K>): string | undefined;
+
+/** Where the checkout is shown. */
+type PaymentCheckoutDisplay = 'modal' | 'inline' | 'page';
+/** Props of {@link PaymentCheckout}. */
+interface PaymentCheckoutProps {
+    /** The checkout token of the invoice (its `checkoutToken`, or the end of its `payUrl`). */
+    token: string;
+    /**
+     * `modal` (default): a dialog over the page, 760 px wide (less on a narrower window), a sheet from the bottom under
+     * 640 px; `inline`: a block in the page, as wide as its place up to 760 px; `page`: the whole page, as the Quasar
+     * payment page shows it: a sheet 880 px wide, centered in the window (`min-height: 100svh`; set `--novapay-page-height`
+     * on an ancestor for a page with a header of its own), that grows downward with its step and scrolls nothing inside,
+     * full-bleed under 640 px.
+     */
+    display?: PaymentCheckoutDisplay;
+    /** Whether the modal is open (`display="modal"`; default `true`). */
+    open?: boolean;
+    /**
+     * Called when the modal opens or closes.
+     *
+     * @param open - The new state.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /** Called when the buyer closes the checkout; without it an inline checkout has no close button. */
+    onClose?: () => void;
+    /** The Quasar API; overrides `baseUrl` of `NovaPaymentsProvider`. */
+    baseUrl?: string;
+    /** Calls to make instead of the HTTP ones, for tests and simulations (`CheckoutApi` of `@tuwaio/quasar-sdk/checkout`). */
+    api?: CheckoutApi;
+    /** The `EventSource` to follow the invoice with; `null` reads it every `pollMs` (default: the browser's). */
+    EventSource?: EventSourceConstructor | null;
+    /** How often to read the invoice without an event stream, in milliseconds (default `5000`). */
+    pollMs?: number;
+    /**
+     * The payment page of the invoice (its `payUrl` from the Quasar API, passed as it comes): with it, an EVM method can
+     * also be paid by scanning a QR code that opens the page on a phone. `null` (a node without a dashboard URL) or
+     * leaving it out offers the QR code for Solana methods only.
+     */
+    payUrl?: string | null;
+    /**
+     * Connects a wallet of a chain family, for apps without Nova Connect; overrides the `onConnectWallet` of
+     * `NovaPaymentsProvider`. Inside `NovaConnectProvider` (the app's, or Nova's own connection of `NovaPaymentsProvider`)
+     * the checkout opens its connect modal instead.
+     *
+     * @param family - The family of the chosen method.
+     */
+    onConnectWallet?: (family: PaymentFamily) => void;
+    /**
+     * Called once when the invoice is paid (Quasar confirmed the payment). Fulfil orders from the `invoice.paid` webhook
+     * on your server: this callback is for the page only.
+     *
+     * @param invoice - The paid invoice.
+     */
+    onPaid?: (invoice: CheckoutView['invoice']) => void;
+    /**
+     * Seconds before the paid outcome sends the buyer back to the invoice's `successUrl`, with a visible countdown and
+     * "Stay here" (`0` for no automatic return). Default `5` on a page; `0` in a modal, whose paid outcome offers Close
+     * instead, since the page under it is the seller's (handle the payment there with `onPaid`).
+     */
+    autoReturnSeconds?: number;
+    /** Replaces the link of "Contact <seller>" (the seller's support email, else site) with the app's own handler. */
+    onContact?: () => void;
+    /** Classes added to the checkout block. */
+    className?: string;
+    /**
+     * Class name functions of the parts, from the state of the checkout, and components that replace parts (the
+     * header, the order, the steps, the options of the method step, the main button, the QR code, the outcome icon or
+     * whole screens).
+     */
+    customization?: PaymentCheckoutCustomization;
+}
+/** The screen of the current step or outcome, or its replacement (`customization.components.screens`). @internal */
+declare function ScreenBody(): react.JSX.Element;
+/**
+ * The checkout block: the order on the left (from 640 px; on a phone a compact order above the steps), the header
+ * with the steps, language and close, and the current screen. The language follows the invoice, its texts the labels
+ * of that language, and `lang` is set on the block (WCAG 3.1.2). Screen readers hear the time left at 10, 5 and 1
+ * minutes before the deadline while the buyer can still pay. `customization` adds classes to the order and the screen area, and can replace the
+ * header and the order.
+ *
+ * @internal
+ */
+declare function CheckoutFrame({ className, withDetails, leave, }: {
+    className?: string;
+    withDetails?: boolean;
+    leave: {
+        onStay: () => void;
+        onLeave: () => void;
+    } | null;
+}): react.JSX.Element;
+/**
+ * The checkout of a Quasar Payments invoice, opened by its checkout token: the order, the steps of the payment and
+ * its outcome, in the language of the invoice. It reads the invoice with `createCheckoutStore` of
+ * `@tuwaio/quasar-sdk/checkout` and follows it until it is final; no secret key reaches the browser.
+ *
+ * Side effects: requests to the checkout routes of the Quasar API (`baseUrl`) and an `EventSource` on the invoice
+ * events while the invoice can change; changing the language saves it on the invoice (`POST locale`).
+ *
+ * @param props - See {@link PaymentCheckoutProps}.
+ * @returns The checkout.
+ *
+ * @example
+ * ```tsx
+ * import { PaymentCheckout } from '@tuwaio/payments-sdk';
+ * import { useState } from 'react';
+ *
+ * export function PayButton({ token }: { token: string }) {
+ *   const [open, setOpen] = useState(false);
+ *   return (
+ *     <>
+ *       <button onClick={() => setOpen(true)}>Pay</button>
+ *       <PaymentCheckout token={token} open={open} onOpenChange={setOpen} />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function PaymentCheckout({ token, display, open, onOpenChange, onClose, baseUrl, api, EventSource, pollMs, payUrl, onConnectWallet, onPaid, autoReturnSeconds, onContact, className, customization, }: PaymentCheckoutProps): react.JSX.Element;
+/**
+ * The checkout as a whole page: the block, centered from a floor (`styles/app.css`) and not from its own height, so that
+ * no step can move its top.
+ *
+ * @internal
+ */
+declare function CheckoutPageRoot({ label, className, children, }: {
+    label: string;
+    className?: string;
+    children: ReactNode;
+}): react.JSX.Element;
+
+/** What the parts of a checkout share: its store and state, the screen, the language and its labels. */
+interface CheckoutContextValue {
+    /** The checkout store of the invoice. */
+    store: CheckoutStore;
+    /** The state of the store. */
+    state: CheckoutState;
+    /** The checkout, once loaded. */
+    checkout: CheckoutView | null;
+    /** The screen shown. */
+    screen: CheckoutScreen;
+    /** The language of the checkout (a BCP 47 tag). */
+    locale: string;
+    /** The labels of that language. */
+    labels: NovaPaymentsLabels;
+    /** `Date.now()` of the latest second tick. */
+    now: number;
+    /**
+     * When this page handed its current payment over (the phase became `confirming`), by the clock of the page; `null`
+     * while no payment of it is confirming, or when it was already confirming as the checkout opened.
+     */
+    handedOverAt: number | null;
+    /** The checkout showed a QR code for the invoice, which the buyer may have paid with from a phone. */
+    qrShown: boolean;
+    /**
+     * This page handed a payment of the invoice over, or saw one on its way, and Quasar did not say that it failed for
+     * good: it may still arrive, also after the store stopped following it.
+     */
+    paymentSent: boolean;
+    /** Closes the checkout; `undefined` when it cannot be closed (inline without `onClose`). */
+    close?: () => void;
+    /** The wallet connected through Satellite Connect, if any. */
+    wallet: CheckoutWallet | null;
+    /** How the buyer pays: from a wallet in this browser, or with a QR code on a phone. */
+    payWith: 'wallet' | 'qr';
+    /**
+     * Sets how the buyer pays.
+     *
+     * @param payWith - `wallet` or `qr`.
+     */
+    setPayWith: (payWith: 'wallet' | 'qr') => void;
+    /** The payment page of the invoice (its `payUrl`), for the QR code of an EVM method; `null` without one. */
+    payUrl?: string | null;
+    /**
+     * Asks the buyer to connect a wallet of the method's chain family; the price is locked for it once connected.
+     *
+     * @param method - The chosen method.
+     * @returns Whether the page can connect a wallet (Nova Connect or the app's handler).
+     */
+    connectWallet: (method: CheckoutMethod) => boolean;
+    /**
+     * Asks the buyer to connect a wallet of a chain family and nothing more: no price is locked for it.
+     *
+     * @param family - The chain family.
+     * @returns Whether the page can connect a wallet.
+     */
+    connectFamily: (family: 'eip155' | 'solana') => boolean;
+    /** Whether the page opened on an invoice already paid: the buyer reads its receipt, nothing was just paid. */
+    openedPaid: boolean;
+    /**
+     * The adapter that pays a chain family from the connected wallet.
+     *
+     * @param family - The family.
+     * @returns The adapter of `NovaPaymentsProvider`, if any.
+     */
+    adapterFor: (family: PaymentFamily) => PaymentsAdapter | undefined;
+    /** The buyer continues on a phone: the QR code of the payment page shows before any price. */
+    handoff: boolean;
+    /**
+     * Shows or hides the QR code of the payment page.
+     *
+     * @param handoff - Whether it shows.
+     */
+    setHandoff: (handoff: boolean) => void;
+    /** Goes back to the method step: forgets the locked price and the phone hand-off. */
+    backToMethods: () => void;
+    /**
+     * Whether the buyer continued with a wallet that must confirm the invoice before the price: the step that confirms
+     * it shows while the checkout store waits for the signature (`ConfirmWalletScreen`).
+     */
+    confirmWallet: boolean;
+    /**
+     * Shows or leaves the step that confirms the wallet ("Back to methods").
+     *
+     * @param show - Whether it shows.
+     */
+    setConfirmWallet: (show: boolean) => void;
+    /**
+     * Locks the price for the wallet set on the checkout store, or shows the step that confirms the wallet first while
+     * the store says it must (before the price).
+     *
+     * @returns Resolves when the price is locked, refused, or the step shows.
+     */
+    lockPrice: () => Promise<void>;
+    /**
+     * Remembers the payment the wallet sent: the checkout tracks it while open, and hands it over to the app's Pulsar
+     * store when it closes before Quasar settled it.
+     *
+     * @param payment - The transaction and what it pays.
+     */
+    onPaymentSent: (payment: SentPayment) => void;
+    /** The buyer opened the automatic payments offer after paying a subscription period. */
+    autoPay: boolean;
+    /**
+     * Opens or closes the automatic payments offer.
+     *
+     * @param autoPay - Whether it shows.
+     */
+    setAutoPay: (autoPay: boolean) => void;
+    /** The screen that turns automatic payments off is open (`open`), or they were turned off (`done`). */
+    autoPayOff: 'open' | 'done' | null;
+    /**
+     * Opens or closes the screen that turns automatic payments off, or says they were turned off.
+     *
+     * @param autoPayOff - The new state.
+     */
+    setAutoPayOff: (autoPayOff: 'open' | 'done' | null) => void;
+    /** Whether the wallet has sent the transaction that revokes the permission of this invoice's subscription. */
+    revokeSent: boolean;
+    /**
+     * Keeps that for as long as the page shows the invoice, so the buyer leaving the screen does not send it twice.
+     *
+     * @param sent - Whether it was sent.
+     */
+    setRevokeSent: (sent: boolean) => void;
+    /**
+     * Opens another invoice in this checkout: the one that replaced a corrected invoice.
+     *
+     * @param token - Its checkout token.
+     */
+    openInvoice: (token: string) => void;
+    /** Replaces the link of "Contact <seller>", when the app handles it. */
+    onContact?: () => void;
+    /** Seconds before the paid outcome sends the buyer back to the seller; `0` for no automatic return. */
+    autoReturnSeconds: number;
+    /**
+     * How the checkout shows (`display` of `PaymentCheckout`): a modal belongs to the page under it, so its paid outcome
+     * closes it instead of sending the buyer back to the seller's page.
+     */
+    display: PaymentCheckoutDisplay;
+    /** Class name functions and replacement components of the parts (`customization` of `PaymentCheckout`). */
+    customization: PaymentCheckoutCustomization;
+}
+declare const CheckoutContext: react.Context<CheckoutContextValue | null>;
+/** Gives the parts of a checkout what they share. @internal */
+declare const CheckoutContextProvider: react.Provider<CheckoutContextValue | null>;
+
+/** The merchant's logo (or the first letter of its name), name and website, and the test badge. @internal */
+declare function MerchantBadge({ compact }: {
+    compact?: boolean;
+}): react.JSX.Element | null;
+/** The seller as the invoice document names them, the merchant's policies and what Quasar is. @internal */
+declare function SellerDetailsContent({ checkout, labels }: {
+    checkout: CheckoutView;
+    labels: NovaPaymentsLabels;
+}): react.JSX.Element;
+/**
+ * The countdown to the invoice deadline, through every step of the payment until it succeeded (`deadlineState`); it
+ * stays at 00:00 when the deadline passes while the payment confirms. @internal
+ */
+declare function DeadlineTimer(): react.JSX.Element | null;
+/** The lines, subtotal and tax of the invoice. @internal */
+declare function OrderLines(): react.JSX.Element | null;
+/** The total of the invoice, which stays in place while the lines scroll. @internal */
+declare function OrderTotal(): react.JSX.Element | null;
+/** "Secured by Quasar" and the seller's support email, at the same place on every step (WCAG 3.2.6). @internal */
+declare function SummaryFooter(): react.JSX.Element;
+/** A button that shows or hides a part, with `aria-expanded` and `aria-controls`. @internal */
+declare function Disclosure({ label, children, className, buttonClassName, growsUp, }: {
+    label: string;
+    children: ReactNode;
+    className?: string;
+    buttonClassName?: string;
+    /** The part stands at the bottom of its panel, so its content pushes the button upwards: the arrow says so. */
+    growsUp?: boolean;
+}): react.JSX.Element;
+/**
+ * The order panel on the left of the checkout (from 640 px): the merchant, the seller details (unfolded in place, the
+ * lines scroll while the deadline and the total stay), the countdown to the deadline (through every step of the
+ * payment, also while it confirms, until it succeeded), the lines and the total, and the help.
+ *
+ * @returns The order panel.
+ */
+declare function CheckoutSummary(): react.JSX.Element | null;
+/**
+ * The order on a phone, above the steps: the total and the countdown to the deadline (until the payment succeeded), with
+ * the lines and the seller details behind a "Details" button.
+ *
+ * @param props - The classes.
+ * @param props.className - Classes added to the order (`customization.classNames.compactSummary`).
+ * @returns The compact order.
+ */
+declare function CompactSummary({ className }?: {
+    className?: string;
+}): react.JSX.Element | null;
+
+/**
+ * The confirm step: the transaction is on its way and Quasar follows it until it is final. It reuses the status and
+ * progress of Nova Transactions (Sent → Confirming → Paid, in the language of the checkout) and shows the network, the
+ * amount, the transaction with its explorer link and the sender. The buyer may close the window: the payment keeps
+ * going. It also shows a payment of the invoice that this page did not hand over while Quasar reports it on its way
+ * (the page was reopened or reloaded, another tab paid, Quasar found a Solana Pay transfer), instead of offering to pay
+ * again: its note asks the buyer to wait for it. When the invoice deadline passes while a payment is on its way (the
+ * countdown of the order stays at 00:00), and the invoice is still `open` or `underpaid`, the note follows the payment:
+ * sent before the deadline, it says that the payment was sent in time and is being confirmed (Quasar keeps the invoice
+ * open for a payment it learned of before the deadline while it confirms: for this page's payment Quasar's word on it
+ * decides, `paymentSentInTime` of the checkout store, whatever the clock of the page says; else `paymentCountsUntil`;
+ * with a Quasar that reports neither, a payment this page handed over before the deadline by its clock); otherwise it
+ * says that the seller accepts or returns a payment that arrives after the invoice closes. A payment that failed or settled is no
+ * longer on its way, and the usual note comes back. While the store hands the transaction over again, as Quasar is out of
+ * reach for a moment, the note asks to keep the page open: closing it is what could lose the hand-over.
+ *
+ * @returns The confirm step.
+ */
+declare function ConfirmScreen(): react.JSX.Element;
+
+/**
+ * The step that confirms the paying wallet, right after the wallet and the method and before
+ * the price, for an EVM payment the buyer's wallet sends itself (`payerProof` of the checkout store is `required`): one
+ * sentence that it is free and moves no money, the summary of what the wallet signs (the invoice, the seller, the
+ * amount and the wallet), and the main button that opens the wallet's signature request. Meanwhile the window of the
+ * wallet covers the step, with the site the message names to check, a line that the wallet may show it as a sign-in
+ * request for that site, and "Try again" (signing again moves no money); a smart wallet is said to ask for its passkey.
+ * Once the window is closed the button works again, also while the wallet never answered. A refusal keeps the buyer
+ * on the step, with its reason and the same button to try again; "Back to methods" returns to the methods (or to the
+ * underpaid invoice whose rest another wallet pays). Once the wallet signed, the price is locked on this step and the
+ * pay step follows. One signature per invoice and wallet: a new price or token needs no new one, nor a new network for
+ * an ordinary wallet (a smart wallet's signature counts on its network only).
+ *
+ * Side effects: wallet prompts (a network switch, the signature); `POST payer-proof/message`, `POST payer-proof` and
+ * `POST quote` through the checkout store.
+ *
+ * @returns The step.
+ */
+declare function ConfirmWalletScreen(): react.JSX.Element | null;
+
+/**
+ * The question when the buyer closes the checkout before anything is sent: the invoice stays open until its deadline,
+ * reopened from the email or the seller's site, and the locked price is released. It is a Nova dialog of its own, over
+ * the checkout: one backdrop dims the whole screen, the checkout and its frame included (a layer inside the checkout
+ * left its frame sharp around the dimmed content); on a phone it slides up from the bottom like the other Nova dialogs.
+ * "Stay and pay", Escape or a click outside keep the checkout and give the focus back where it was, "Leave" closes it.
+ * The heading takes the focus.
+ *
+ * @param props - The answers.
+ * @param props.onStay - Keeps the checkout open.
+ * @param props.onLeave - Closes it.
+ * @returns The question, over the checkout.
+ */
+declare function LeaveDialog({ onStay, onLeave }: {
+    onStay: () => void;
+    onLeave: () => void;
+}): react.JSX.Element;
+
+/** Props of {@link LocaleSwitcher}. */
+interface LocaleSwitcherProps {
+    /** The language of the checkout. */
+    locale: string;
+    /** The labels of that language. */
+    labels: NovaPaymentsLabels;
+    /** Whether the receipt is issued: then the language changes the page only. */
+    receiptIssued?: boolean;
+    /**
+     * Called with the language the buyer picks.
+     *
+     * @param locale - The picked language.
+     */
+    onSelect: (locale: CheckoutLocale) => void;
+    /** Classes added to the wrapper. */
+    className?: string;
+}
+/**
+ * The language menu of the checkout: a button with a globe and the language code, always next to the close button,
+ * that opens the six languages under their own names (each with its `lang`). Arrow keys move, Enter or Space picks,
+ * Escape closes and gives the focus back to the button; a click outside closes it. Before payment the note says the
+ * documents follow the language.
+ *
+ * Side effect: while open, a `pointerdown` listener on the document closes it on a click outside.
+ *
+ * @param props - See {@link LocaleSwitcherProps}.
+ * @returns The language menu.
+ */
+declare function LocaleSwitcher({ locale, labels, receiptIssued, onSelect, className }: LocaleSwitcherProps): react.JSX.Element;
+
+/**
+ * The method step: the token first, then its network (left out when the token has one), then how to pay — from a
+ * wallet in this browser or with a QR code on a phone. The connected wallet's network comes first and is marked, the
+ * merchant's Popular methods next; a discount or markup of a method shows on it. Paying from a wallet needs the chain
+ * adapter of the method's family (`adapters` of `NovaPaymentsProvider`). "Continue" locks the price for the connected
+ * wallet (or connects one first), locks it without a payer for a Solana Pay QR code, or shows the QR code of the
+ * payment page for an EVM method paid on a phone; a wallet that must confirm the invoice first (an EVM payment it sends
+ * itself) goes to the step that confirms it before the price. A consent the seller asks (`checkout.consent`) is a box the buyer
+ * ticks under the ways to pay; a required one keeps "Continue" off until it is ticked, and the quote carries it.
+ *
+ * @returns The method step.
+ */
+declare function MethodScreen(): react.JSX.Element | null;
+
+/**
+ * The paid outcome: the amount, network, time and transaction, the steps done, a refund made later, the receipt to
+ * download, the automatic payments offer of a subscription, and the way back to the seller (`successUrl`) with a
+ * visible countdown and "Stay here" (WCAG 2.2.1). In a modal it offers Close instead: the page under it is the
+ * seller's, and loading it again would close everything at once.
+ *
+ * Side effects: navigates to the seller's `successUrl` when the countdown ends.
+ *
+ * @returns The paid outcome.
+ */
+declare function PaidScreen(): react.JSX.Element | null;
+
+/**
+ * The pay step: the connected wallet (with "Change"), the exact amount to send with its network and invoice value,
+ * the price lock with "Keep this price" in its last minute, the rate, the network fee (the merchant's or an estimate),
+ * the recipient, and the main action — "Sign to pay" when the merchant pays the gas, "Pay" otherwise, "Switch to …"
+ * on the wrong network, "Confirm this wallet to pay" before a transfer or a paymaster payment of a method the gasless
+ * relay could pay (the wallet signs Quasar's free confirmation of the invoice first; the relay's authorization needs
+ * none). Before the prompt it reads the wallet's balance (unless `config.balanceCheck` is `false`)
+ * and, when it is short, offers the methods the wallet can pay and the seller's top-up link. `handlers.onSubmit` wraps
+ * the pay button. A Solana payment off mainnet reminds the buyer to switch the wallet to its cluster (Solana wallets
+ * choose their network themselves), with the steps of Phantom and Solflare. The note under the buttons says that the
+ * payment goes straight to the merchant and, when the merchant checks paying wallets (`amlScreening` of the
+ * checkout), that it does.
+ *
+ * Side effects: balance, fee and wallet capability reads from the network through the chain adapter (no request to
+ * Quasar); wallet prompts; checkout requests to Quasar; on a Solana payment, `switchNetwork` of the Satellite store
+ * moves the app's Solana connection to the payment's cluster (no wallet request).
+ *
+ * @returns The pay step.
+ */
+declare function PayScreen(): react.JSX.Element | null;
+
+/**
+ * The QR code step. For Solana, a Solana Pay transfer request a phone wallet scans (or opens with "Open in wallet
+ * app"), with the exact amount, the recipient, the price lock and a warning against paying from an exchange; the page
+ * waits for the payment, which Quasar finds by the reference key. For an EVM method, the QR code of the payment page
+ * opens this checkout on the phone, before any price.
+ *
+ * @returns The QR code step.
+ */
+declare function QrScreen(): react.JSX.Element | null;
+
+/** What a refund asks for: the amount and mode `start` takes (`RefundParams` of `@tuwaio/quasar-sdk`). */
+type RefundRequest = Parameters<RefundState['start']>[1];
+/**
+ * Where a refund stands for the merchant: `amount` (what to refund), `requesting`, `connect` (a wallet of the
+ * payment's network), `confirm`, `switching` and `wallet` (the wallet asks), `submitting`, `confirming` (the network
+ * confirms it), `confirmed` or `failed`.
+ */
+type RefundStep = 'amount' | 'requesting' | 'connect' | 'confirm' | 'switching' | 'wallet' | 'submitting' | 'confirming' | 'confirmed' | 'failed';
+/**
+ * Why a refund was not sent: the wallet holds too little (`notEnough`), the merchant declined, the wallet cannot send
+ * it or sent it on another network, it failed, Quasar does not know the payer (`noRecipient`), or Quasar did not answer when
+ * the window looked again before asking the wallet (`unreachable`), the wallet is the one that paid and would only pay the
+ * fee (`fromBuyer`), or the merchant closed the wait while the request stays open in the wallet (`stillInWallet`).
+ */
+type RefundProblem = 'notEnough' | 'declined' | 'unsupported' | 'wrongNetwork' | 'failed' | 'noRecipient' | 'unreachable' | 'fromBuyer' | 'stillInWallet';
+/** What {@link useRefund} needs. */
+interface UseRefundParams {
+    /** The refund store (`createRefundStore` of `@tuwaio/quasar-sdk/checkout`). */
+    store: RefundStore;
+    /** The paid invoice to refund. */
+    invoiceId: string;
+    /** Its number, for the transaction in Pulsar (the ID without one). */
+    invoice?: string;
+    /** The refund the app worked out: asked for at once, without the amount step. */
+    params?: RefundRequest;
+    /** Whether the window is open: when it opens again after a confirmed refund, it starts over for another one. */
+    open?: boolean;
+    /** The labels of the language. */
+    labels: NovaPaymentsLabels;
+    /** The language, for amounts. */
+    locale: string;
+    /**
+     * Connects a wallet of the payment's chain family, for apps without Nova Connect (the `onConnectWallet` of
+     * `NovaPaymentsProvider` otherwise). Inside `NovaConnectProvider` the refund opens its connect modal instead.
+     *
+     * @param family - The chain family of the payment.
+     */
+    onConnectWallet?: (family: PaymentFamily) => void;
+}
+/** What {@link useRefund} returns. */
+interface RefundFlow {
+    /** Where the refund stands. */
+    step: RefundStep;
+    /** The refund store's phase. */
+    phase: RefundPhase;
+    /**
+     * What a refund would send, before it is asked for: a requested refund holds its amount until it is sent.
+     *
+     * @param request - What to refund.
+     * @returns The preview; `null` when the store cannot show one; `refused` when Quasar would refuse it (`error` says why).
+     */
+    preview: (request: RefundRequest) => Promise<RefundPreview | 'refused' | null>;
+    /** The refund, once asked for. */
+    refund: RefundState['refund'];
+    /** Why the last request to Quasar failed. */
+    error: CheckoutError | null;
+    /** What the wallet sends, or `null` before the refund is asked for or without a payer. */
+    transfer: PaymentInstructions | null;
+    /** The CAIP-2 chain of the payment. */
+    chainId: string | null;
+    /** The name of its network. */
+    network: string;
+    /** The amount to send with its symbol. */
+    amount: string;
+    /** The connected wallet, when it is of the payment's chain family. */
+    wallet: CheckoutWallet | null;
+    /** Whether the EVM wallet is on another network than the payment's: {@link RefundFlow.switchNetwork} first. */
+    wrongNetwork: boolean;
+    /** What the wallet holds of the asset: `undefined` while read, `null` when unknown. */
+    balance: bigint | null | undefined;
+    /** The estimated network fee. */
+    fee: NativeFee | null | undefined;
+    /** Why the refund was not sent, until the next try. */
+    problem: RefundProblem | null;
+    /** The transaction the wallet sent; while Quasar has not taken it, {@link RefundFlow.send} hands it over again. */
+    txKey: string | null;
+    /** The explorer link of a transaction of the refund, when the chain has one. */
+    transactionUrl: (hash: string) => string | undefined;
+    /** The explorer link of an address on the chain of the refund, when the chain has one. */
+    addressUrl: (address: string) => string | undefined;
+    /** Whether the page can connect a wallet. */
+    canConnect: boolean;
+    /** Whether the connect modal is open. */
+    connecting: boolean;
+    /**
+     * Asks Quasar for the refund.
+     *
+     * @param params - Amount, mode and reason.
+     */
+    start: (params: RefundRequest) => Promise<void>;
+    /** Asks the merchant to connect a wallet of the payment's chain family. */
+    connect: () => void;
+    /** Asks the EVM wallet to switch to the payment's network; sends nothing. */
+    switchNetwork: () => Promise<void>;
+    /** Sends the refund from the wallet (switching its network first) and hands its transaction to Quasar. */
+    send: () => Promise<void>;
+    /**
+     * Closes the wait for the wallet. Its request stays open there: a transaction it sends later is still handed to Quasar, a
+     * refusal is not shown, and {@link RefundFlow.send} asks it nothing more meanwhile.
+     */
+    dismiss: () => void;
+    /** Whether a send is under way, from the press on: the button shows it, and another press sends nothing. */
+    sending: boolean;
+}
+/**
+ * Refunds a payment from the merchant's connected wallet: asks Quasar for the refund through the store,
+ * sends its transfer to the payer with the payments adapter of the chain family (switching the wallet to the payment's
+ * network first, and never prompting a wallet that holds too little), hands the transaction to Quasar and lets the
+ * store follow it until Quasar confirms it and issues the credit note. A transaction the wallet sent is handed over
+ * again on the next {@link RefundFlow.send}, never sent twice. Before the wallet is asked the refund is read again, and nothing
+ * goes out when it no longer waits or Quasar does not answer. With the app's Pulsar store (`pulsar` of
+ * `NovaPaymentsProvider`) and an adapter that describes its transactions, the refund is also tracked by Pulsar, and
+ * Nova Transactions shows its toast.
+ *
+ * Side effects: the store's calls; wallet prompts; balance and fee reads from the network; the Pulsar store.
+ *
+ * @param params - See {@link UseRefundParams}.
+ * @returns See {@link RefundFlow}.
+ */
+declare function useRefund({ store, invoiceId, invoice, params, open, labels, locale, onConnectWallet, }: UseRefundParams): RefundFlow;
+
+/** A refund of the store (`Refund` of `@tuwaio/quasar-sdk`). */
+type Refund = NonNullable<RefundState['refund']>;
+/** Props of {@link RefundDialog}. */
+interface RefundDialogProps {
+    /** Whether the window is open. */
+    open: boolean;
+    /**
+     * Opens or closes the window.
+     *
+     * @param open - Whether it is open.
+     */
+    onOpenChange: (open: boolean) => void;
+    /**
+     * The refund store (`createRefundStore` of `@tuwaio/quasar-sdk/checkout`), whose calls the app runs on its server
+     * with the secret key. One store per invoice: it keeps the refund while the window is closed.
+     */
+    store: RefundStore;
+    /** The paid invoice to refund. */
+    invoiceId: string;
+    /** Its number, shown in the title and in the transaction of Pulsar. */
+    invoice?: string;
+    /** The refund the app worked out (amount, mode, reason): asked for at once, without the amount step. */
+    params?: RefundRequest;
+    /** The invoice currency, for the amount step. Defaults to `USD`. */
+    currency?: string;
+    /** What is left to refund, with its currency, shown under the amount (`20.00 USD`). */
+    refundable?: string;
+    /** The language (a BCP 47 tag). Defaults to `en`. */
+    locale?: string;
+    /** Rows the app adds: to the confirm step (what the refund takes back) and to the refunded step. */
+    details?: {
+        confirm?: ReactNode;
+        done?: ReactNode;
+    };
+    /** "Record refund": the app's form for a refund sent another way; offered when the wallet does not send it. */
+    onRecord?: () => void;
+    /**
+     * Connects a wallet of the payment's chain family, for apps without Nova Connect; overrides the `onConnectWallet` of
+     * `NovaPaymentsProvider`. Inside `NovaConnectProvider` (the app's, or Nova's own connection) the window opens its
+     * connect modal instead.
+     *
+     * @param family - The chain family of the payment.
+     */
+    onConnectWallet?: (family: PaymentFamily) => void;
+    /**
+     * Called once Quasar confirmed the refund and issued its credit note.
+     *
+     * @param refund - The confirmed refund (`Refund` of `@tuwaio/quasar-sdk`).
+     */
+    onRefunded?: (refund: NonNullable<RefundState['refund']>) => void;
+}
+/** Props of {@link RefundButton}. */
+interface RefundButtonProps extends Omit<RefundDialogProps, 'open' | 'onOpenChange'> {
+    /** The button's text. Defaults to the `refund.button` label. */
+    label?: ReactNode;
+    /** Classes of the button. */
+    className?: string;
+    /** Whether the button is disabled. */
+    disabled?: boolean;
+}
+/**
+ * A button that refunds a paid invoice from the merchant's connected wallet: it opens {@link RefundDialog}. Put it
+ * inside {@link NovaPaymentsProvider}: it uses the provider's wallet connection (the app's Satellite store and Nova
+ * Connect when the app has them, else Nova's own `ownConnection`) and its adapters. In an app whose wallets connect
+ * without Nova Connect, pass `onConnectWallet` here or to the provider.
+ *
+ * @param props - See {@link RefundButtonProps}.
+ * @returns The button and its window.
+ *
+ * @example
+ * ```tsx
+ * import { createRefundStore } from '@tuwaio/payments-sdk/checkout';
+ * import { RefundButton } from '@tuwaio/payments-sdk';
+ *
+ * // refundInvoice, submitRefund and getRefund are Server Actions calling quasar.payments
+ * const refunds = createRefundStore({ request: refundInvoice, submit: submitRefund, get: getRefund });
+ *
+ * <RefundButton store={refunds} invoiceId={invoice.id} invoice={invoice.number} currency="USD" />;
+ * ```
+ */
+declare function RefundButton({ label, className, disabled, ...props }: RefundButtonProps): react.JSX.Element;
+/**
+ * The window of a refund from the merchant's wallet: what to refund (skipped
+ * with `params`), a wallet of the payment's network, the confirmation (what goes where, from which wallet with its
+ * balance, the network fee, and the app's rows), the wallet's prompt, the transaction on its way, and the credit note.
+ * A refund the wallet did not send says why, offers to send it again and the app's "Record refund". The refund
+ * goes on while the window is closed: the store follows it.
+ *
+ * Side effects: those of `useRefund` (the store's calls, wallet prompts, balance and fee reads, the Pulsar store).
+ *
+ * @param props - See {@link RefundDialogProps}.
+ * @returns The window.
+ */
+declare function RefundDialog({ open, onOpenChange, locale, onRefunded, ...props }: RefundDialogProps): react.JSX.Element;
+/** The step of a refund the window shows. @internal */
+declare function RefundSteps({ flow, labels, locale, close, currency, refundable, details, onRecord, }: Pick<RefundDialogProps, 'currency' | 'refundable' | 'details' | 'onRecord'> & {
+    flow: RefundFlow;
+    labels: NovaPaymentsLabels;
+    locale: string;
+    close: () => void;
+}): react.JSX.Element;
+/** Whether a refund has been on its way for long, from when it last changed. @internal */
+declare const isSlow: (refund: Pick<Refund, "createdAt" | "updatedAt"> | null | undefined) => boolean;
+/** A refusal of Quasar in the words of the window, or of the app when it said it in the reader's language. @internal */
+declare const refusalText: (error: {
+    code: string;
+    text?: string;
+}, text: NovaPaymentsLabels["refund"]) => string;
+/**
+ * A refund whose transaction failed on-chain: why, then the same refund asked for again, priced now, or recorded.
+ *
+ * @internal
+ */
+declare function FailedStep({ flow, labels, locale, values, recordAction, close, }: {
+    flow: RefundFlow;
+    labels: NovaPaymentsLabels;
+    locale: string;
+    values: Record<string, string>;
+    recordAction: ReactNode;
+    close: () => void;
+}): react.JSX.Element;
+/**
+ * What to refund: an amount of the invoice currency (everything left when empty) or everything received.
+ *
+ * @internal
+ */
+declare function AmountStep({ flow, labels, locale, currency, refundable, }: {
+    flow: RefundFlow;
+    labels: NovaPaymentsLabels;
+    locale: string;
+    currency: string;
+    refundable?: string;
+}): react.JSX.Element;
+declare function ConfirmStep({ flow, labels, locale, values, details, recordAction, }: {
+    flow: RefundFlow;
+    labels: NovaPaymentsLabels;
+    locale: string;
+    values: Record<string, string>;
+    details?: ReactNode;
+    recordAction: ReactNode;
+}): react.JSX.Element;
+
+/**
+ * What the wallet asks for: a gasless signature, a transaction, a network switch, the permission of automatic
+ * payments, the signature that confirms the paying wallet (`proof`), or Quasar takes the payment.
+ */
+type WalletPromptKind = 'sign' | 'confirm' | 'switch' | 'permission' | 'proof' | 'submitting';
+/** Props of {@link WalletPrompt}. */
+interface WalletPromptProps {
+    /** What the wallet asks for. */
+    kind: WalletPromptKind;
+    /** The wallet's name, as it calls itself (`name` of the connected wallet). */
+    walletName: string;
+    /** The wallet's id, for the icon Nova has of it when the wallet gives none. */
+    walletId: string;
+    /** The icon the wallet gives itself (`icon` of the connected wallet), usually a `data:` URI. */
+    walletIcon?: string;
+    /** The amount with its symbol. */
+    amount: string;
+    /** The seller. */
+    merchant: string;
+    /** The network of the payment. */
+    network: string;
+    /** The recipient, shortened (not copyable: it is checked, never typed). */
+    to: string;
+    /** The countdown of the price lock; `null` once it ended. */
+    priceTime: string | null;
+    /** Asks the wallet again; only where a second request cannot pay twice (a signature). */
+    onRetry?: () => void;
+    /** What the window says instead of the text of its kind (the signature that confirms the wallet). */
+    text?: string;
+    /** The rows to check in the wallet instead of the payment's (the signature that confirms the wallet). */
+    details?: {
+        name: string;
+        value: string;
+    }[];
+    /** A line under the text: how the wallet may present the request (the signature that confirms the wallet). */
+    hint?: string;
+    /** Closes the window. */
+    onCancel: () => void;
+    /**
+     * The height in px of the step the window stands for, measured while the step showed and capped at the room of the
+     * checkout pane. Below 640 px, where the checkout has no fixed height, the window keeps it as its minimum height, so
+     * the sheet does not shrink while the wallet asks and grow back after. Wider screens have the fixed height of the
+     * checkout and ignore it.
+     */
+    stepHeight?: number | null;
+}
+/**
+ * The window that stands for the pay step while the wallet asks the buyer: what to sign or confirm, and what to check
+ * in the wallet before — the amount, the recipient, the network and the time left of the price (WCAG 3.3.4); for the
+ * signature that confirms the paying wallet, the invoice, the seller and the site the message names. It sits in the
+ * flow of the screen, in place of the step: a screen that shows it (a custom screen of
+ * `customization.components.screens` too) hides its step while it shows, with `display: none` and `inert` (the step
+ * keeps its state), so the window fills the checkout pane, centered, without the scrollbar of a taller step, and
+ * passes the step's height as `stepHeight`, so a phone keeps the height of the sheet. The heading takes the focus, so
+ * screen readers say what happens; when the window closes and the step comes back, the focus returns to the button
+ * that opened it ("Pay", "Switch to …") from the page or the dialog frame it fell back to, unless the buyer moved it
+ * elsewhere. "Try again" re-asks only for a signature; for a transaction the buyer is sent to the wallet, where the
+ * request still waits, so it cannot be paid twice.
+ *
+ * @param props - See {@link WalletPromptProps}.
+ * @returns The window.
+ */
+declare function WalletPrompt({ kind, walletName, walletId, walletIcon, amount, merchant, network, to, priceTime, onRetry, text, details, hint, onCancel, stepHeight, }: WalletPromptProps): react.JSX.Element;
+
+/**
+ * Reads a value once per key: again when the key changes, never for a `null` key. An answer for an old key is
+ * dropped. Used for the balances and fee estimates the pay step reads from the network.
+ *
+ * @param key - What the value depends on, as a string; `null` to read nothing.
+ * @param load - Reads the value for the current key.
+ * @returns The value; `undefined` while it is read (or without a key); `null` when the read failed.
+ */
+declare function useAsyncValue<T>(key: string | null, load: () => Promise<T> | T): T | null | undefined;
+/**
+ * Reads a value like {@link useAsyncValue}, and again when the buyer comes back to the page (focus, visibility) or
+ * `refresh` changes, keeping the last answer meanwhile: a balance the buyer tops up in the wallet opens the pay button
+ * without a reload, and a read under way does not open it before the answer.
+ *
+ * Side effects: `focus` and `visibilitychange` listeners while there is a key.
+ *
+ * @param key - What the value depends on, as a string; `null` to read nothing.
+ * @param load - Reads the value for the current key.
+ * @param refresh - Reads again when it changes, for the same key.
+ * @returns The value; `undefined` until the first answer for this key (or without a key); `null` when the read failed.
+ */
+declare function useRereadValue<T>(key: string | null, load: () => Promise<T> | T, refresh?: unknown): T | null | undefined;
+
+/**
+ * What the parts of the surrounding `PaymentCheckout` share, for components that replace its parts.
+ *
+ * @returns The checkout context.
+ * @throws When called outside a `PaymentCheckout`.
+ */
+declare function useCheckoutContext(): CheckoutContextValue;
+/**
+ * The context of the surrounding `PaymentCheckout`, or `null` outside one: for parts the checkout shares with
+ * `RefundButton`, which take the checkout's customization only inside it.
+ *
+ * @returns The checkout context, or `null`.
+ * @internal
+ */
+declare function useOptionalCheckoutContext(): CheckoutContextValue | null;
+
+/** Parameters of {@link useCheckoutEvents}. */
+interface UseCheckoutEventsParams {
+    /** The state of the checkout store. */
+    state: CheckoutState;
+    /** The screen shown. */
+    screen: CheckoutScreen;
+    /** `Date.now()` of the latest second tick of the checkout. */
+    now: number;
+    /** The handlers of `customization.handlers` of `PaymentCheckout`. */
+    handlers?: PaymentCheckoutHandlers;
+}
+/**
+ * Tells the app what happened in a checkout through its handlers: `onStatusChange` with the first phase and invoice
+ * status and on every change, `onError` once per new error, and `onExpire` when the locked price runs out (at the
+ * tick that crosses its end) and when the invoice expires, with whether a payment is on its way (one this page handed
+ * over, one of the invoice Quasar reports, as on a reopened page, or one Quasar could not confirm yet and reads again).
+ * Handlers that change between renders are called in their latest version.
+ *
+ * @param params - See {@link UseCheckoutEventsParams}.
+ */
+declare function useCheckoutEvents({ state, screen, now, handlers }: UseCheckoutEventsParams): void;
+
+/** What {@link useCheckoutStore} takes. */
+interface UseCheckoutStoreOptions {
+    /** The checkout token of the invoice. */
+    token: string;
+    /** The Quasar API. */
+    baseUrl?: string;
+    /** Calls to make instead of the HTTP ones, for tests and simulations; read when the store is created. */
+    api?: CheckoutApi;
+    /** The `EventSource` to follow the invoice with (`null`: read it every `pollMs`); read when the store is created. */
+    EventSource?: EventSourceConstructor | null;
+    /** How often to read the invoice without an event stream, in milliseconds. */
+    pollMs?: number;
+    /** Whether to load and follow the invoice; `false` keeps the idle store, which makes no requests. Defaults to `true`. */
+    enabled?: boolean;
+}
+/**
+ * The checkout store of an invoice (`createCheckoutStore` from `@tuwaio/quasar-sdk/checkout`): created and loaded
+ * after mount, destroyed on unmount or when `token` or `baseUrl` change. Until then it is a store in the `loading`
+ * phase that makes no requests.
+ *
+ * Side effects: the store reads the checkout and follows the invoice (an `EventSource` on its `events` route, or a
+ * request every `pollMs`) until the invoice is final.
+ *
+ * @param options - See {@link UseCheckoutStoreOptions}.
+ * @returns The store.
+ */
+declare function useCheckoutStore(options: UseCheckoutStoreOptions): CheckoutStore;
+/**
+ * Reads a checkout store and re-renders when the selected part changes (`useStore` of `zustand`).
+ *
+ * @param store - The store, from {@link useCheckoutStore}.
+ * @param selector - What to read.
+ * @returns The selected part of the state.
+ */
+declare function useCheckoutState<T>(store: CheckoutStore, selector: (state: CheckoutState) => T): T;
+
+/**
+ * The wallet connected through Satellite Connect (the active connection of `SatelliteConnectProvider` from
+ * `@tuwaio/satellite-react`), in CAIP identifiers, named and shown as the wallet calls itself: the name and icon of
+ * its wallet in the wallet lists of the store (`getConnectors()`, the wallet with exactly the connector type of the
+ * connection), as Nova Connect lists it; `null` without a connection or without the provider, in which case the
+ * checkout offers the QR code and the wallet connection only.
+ *
+ * Side effects: while mounted in the browser, a subscription to the wallet lists of the store (`watchConnectors` of
+ * `@tuwaio/satellite-core`, when the store has it), so a wallet that announces itself later is named too.
+ *
+ * @returns The wallet, or `null`. The same object while the connection, the name and the icon stay the same.
+ */
+declare function useConnectedWallet(): CheckoutWallet | null;
+
+/** What the labels customization of {@link NovaPaymentsProvider} gets with the labels it transforms. */
+interface NovaPaymentsLabelsContext {
+    /** The language of the checkout. */
+    locale: CheckoutLocale | string;
+}
+/** Customization of {@link NovaPaymentsProvider}. */
+type NovaPaymentsProviderCustomization = {
+    /** Labels. */
+    labels?: {
+        /**
+         * Changes the labels of a language after the built-in ones and `labels` are applied, for example to translate a
+         * language the package does not have.
+         *
+         * @param labels - The labels of the language with `labels` applied.
+         * @param context - The language.
+         * @returns The labels to use.
+         */
+        transform?: (labels: NovaPaymentsLabels, context: NovaPaymentsLabelsContext) => NovaPaymentsLabels;
+    };
+};
+/**
+ * The wallet connection Nova brings when the app has no `SatelliteConnectProvider` above {@link NovaPaymentsProvider}:
+ * a Satellite store, its watchers and a Nova Connect modal, all its own. Create it once, at module level: new adapter
+ * objects on every render would be passed to the store again.
+ *
+ * Nova keeps one store per Satellite adapter (the first of `adapter`) for the life of the page, since the wagmi config
+ * and the wallets keep their connections too: a checkout closed and opened again, another page, or a second
+ * `NovaPaymentsProvider` on the same adapters shows the wallet still connected. Nova's part of the package (its
+ * store and the Nova Connect modal) loads on demand, the first time a provider uses its own connection.
+ */
+interface NovaPaymentsOwnConnection {
+    /**
+     * The Satellite adapters of Nova's store: `satelliteEVMAdapter(wagmiConfig, chains)` of `@tuwaio/satellite-evm`,
+     * `satelliteSolanaAdapter({ rpcUrls })` of `@tuwaio/satellite-solana`.
+     */
+    adapter: SatelliteConnectProviderProps['adapter'];
+    /**
+     * The watchers of that store, which follow the wallets: `<EVMConnectorsWatcher wagmiConfig={wagmiConfig} />` of
+     * `@tuwaio/nova-connect/evm`, `<SolanaConnectorsWatcher />` of `@tuwaio/nova-connect/solana` (without `siwx`).
+     */
+    watchers: ReactNode;
+    /**
+     * The payment adapters, on the same wagmi config as `adapter`: `paymentsEVMAdapter(wagmiConfig)`,
+     * `paymentsSolanaAdapter({ rpcUrls })`.
+     */
+    adapters: PaymentsAdapter[];
+    /**
+     * The props of Nova's own connect modal (`NovaConnectProvider` of `@tuwaio/nova-connect`): `appChains` and/or
+     * `solanaRPCUrls` (the modals are rendered only with them), `labels`, `legal`, `withBalance`… Never `siwx`: Nova's
+     * own connection pays and refunds, it does not sign anyone in.
+     */
+    novaConnect: Omit<NovaConnectProviderPropsWithCustomization, 'children' | 'siwx'>;
+    /**
+     * Whether to reconnect the last wallet after a page load (default `false`). With `true`, Satellite's start-up runs
+     * once per page load (`initializeAutoConnect` of the store): with `@tuwaio/satellite-core` 0.11.1 or later it
+     * reconnects only the last wallet, without a permission prompt, and disconnects only connections this page opened;
+     * earlier versions first disconnect every wallet of its adapters, which can drop the wallets of other tabs. Without it, Nova's connect modal hides "Remember this wallet", since nothing would reconnect the wallet, unless
+     * `novaConnect.customization` sets `hidden` of `modals.connectModal.childComponents.rememberWallet`.
+     */
+    autoConnect?: boolean;
+    /**
+     * Whether to keep the connected wallet in `localStorage` after the tab closes (default `false`: in `sessionStorage`
+     * until the tab closes). See `rememberWallet` of `createSatelliteConnectStore` from `@tuwaio/satellite-core`. The
+     * keys are shared with every Satellite store of the site: connecting a wallet that is not remembered moves the last
+     * connection out of `localStorage`, and disconnecting removes it, so another Satellite app on the same origin
+     * forgets the wallet it remembered.
+     */
+    rememberWallet?: boolean;
+}
+/** Props of {@link NovaPaymentsProvider}. */
+interface NovaPaymentsProviderProps {
+    /** The Quasar API (Quasar Cloud by default, the address of your node for the Community Edition). */
+    baseUrl?: string;
+    /** Texts to replace in every language. */
+    labels?: NovaPaymentsLabelOverrides;
+    /** Customization of the labels. */
+    customization?: NovaPaymentsProviderCustomization;
+    /**
+     * The chain families the checkouts pay from the app's connected wallet on: `paymentsEVMAdapter` of
+     * `@tuwaio/nova-payments/evm` (on the wagmi config of the app's Satellite EVM adapter), `paymentsSolanaAdapter` of
+     * `@tuwaio/nova-payments/solana`. Without the adapter of a method's family, the buyer pays that method with a QR
+     * code. When Nova uses its own connection, the `adapters` of `ownConnection` replace them. Without `adapters`, a
+     * provider on the connection of a `NovaPaymentsProvider` above (the app's, or Nova's own) uses the adapters of that
+     * provider; `[]` asks for QR codes only.
+     */
+    adapters?: PaymentsAdapter[];
+    /**
+     * The app's Pulsar store (`injectExternalPendingTxs` of `createPulsarStore` from `@tuwaio/pulsar-core`). While a
+     * checkout is open it tracks the payment itself; when it closes before Quasar settled a payment the wallet sent, the
+     * payment goes to this store, which tracks it and keeps it in the history, and Nova Transactions shows its toast.
+     */
+    pulsar?: PaymentsPulsar;
+    /**
+     * The wallet connection Nova brings when the app has none: used only when no `SatelliteConnectProvider` is above
+     * (see {@link NovaPaymentsOwnConnection}). Inside the app's Satellite store, Nova uses the app's connection and never
+     * adds a second one.
+     */
+    ownConnection?: NovaPaymentsOwnConnection;
+    /**
+     * Connects a wallet of a chain family when there is no Nova Connect to open (an app that connects wallets its own
+     * way): the default of every `PaymentCheckout`, `RefundButton` and `RefundDialog` below, which their own
+     * `onConnectWallet` overrides.
+     *
+     * @param family - The chain family of the payment.
+     */
+    onConnectWallet?: (family: PaymentFamily) => void;
+    /** The app. */
+    children: ReactNode;
+}
+/**
+ * Gives the checkouts and refunds below it the Quasar API, the labels, the chain adapters and a wallet connection. A
+ * checkout works without it, with Quasar Cloud, the built-in labels and QR payments only.
+ *
+ * The wallet connection is chosen once, on the first render (see {@link PaymentsConnectionMode} and
+ * {@link usePaymentsConnection}): Nova brings its own connection only when the app has none.
+ *
+ * - Inside the app's `SatelliteConnectProvider` (from `@tuwaio/satellite-react`) and `NovaConnectProvider` (from
+ *   `@tuwaio/nova-connect`): the app's wallet, network, connect modal and SIWX, with the `adapters` prop. Nova mounts
+ *   nothing of its own.
+ * - Inside the app's Satellite store without Nova Connect: the app's wallet; "Connect wallet" calls `onConnectWallet`.
+ *   Nova never adds a second store.
+ * - Without a Satellite store, with `ownConnection`: Nova's own store, watchers and connect modal (never SIWX), with
+ *   the adapters of `ownConnection`. It runs Satellite's start-up only when `autoConnect` is set. That part loads on
+ *   demand: until it is loaded, nothing below the provider is rendered.
+ * - Without either: QR payments, and `onConnectWallet`.
+ *
+ * A `NovaPaymentsProvider` inside another one's own connection sees that connection as the app's, so two stores never
+ * stack, and without `adapters` it pays with those of the provider above. A later change of the providers above never
+ * remounts the checkouts on another connection.
+ *
+ * Side effects: with its own connection, those of the Satellite store, kept in memory for the life of the page (the
+ * last wallet in `sessionStorage`, or in `localStorage` with `rememberWallet`, under keys shared with every Satellite
+ * store of the site), of the watchers and of Nova Connect. In development (`NODE_ENV` is `development`),
+ * `console.warn` once when the providers above change after the first render, when `ownConnection` is given inside the
+ * app's store without Nova Connect, and when `ownConnection` is given but the app's connection is used without
+ * `adapters` (its own or those of a `NovaPaymentsProvider` above).
+ *
+ * @param props - See {@link NovaPaymentsProviderProps}.
+ * @returns The provider.
+ *
+ * @example
+ * ```tsx
+ * import { NovaPaymentsProvider, PaymentCheckout } from '@tuwaio/payments-sdk';
+ *
+ * export function Checkout({ token }: { token: string }) {
+ *   return (
+ *     <NovaPaymentsProvider baseUrl="https://quasar.example.com" labels={{ steps: { pay: 'Payment' } }}>
+ *       <PaymentCheckout token={token} display="inline" />
+ *     </NovaPaymentsProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function NovaPaymentsProvider({ baseUrl, labels, customization, adapters, pulsar, ownConnection, onConnectWallet, children, }: NovaPaymentsProviderProps): react.JSX.Element;
+
+/**
+ * Whose wallet connection the checkouts and refunds use, as `NovaPaymentsProvider` decided on its first render:
+ *
+ * - `app`: the app's. A Satellite store (`SatelliteConnectProvider` of `@tuwaio/satellite-react`) and
+ *   `NovaConnectProvider` of `@tuwaio/nova-connect` are above it: the wallet, its network, the connect modal and SIWX
+ *   are the app's, and Nova adds nothing.
+ * - `appStore`: the app's Satellite store without Nova Connect: "Connect wallet" calls `onConnectWallet`.
+ * - `own`: Nova's own. The app has no Satellite store and gave `ownConnection`: Nova runs its own store, watchers and
+ *   connect modal, without SIWX.
+ * - `none`: no connection. The buyer pays with a QR code, or connects through `onConnectWallet`.
+ */
+type PaymentsConnectionMode = 'app' | 'appStore' | 'own' | 'none';
+/** The settings `NovaPaymentsProvider` gives the checkouts below it. */
+interface NovaPaymentsSettings {
+    /** The Quasar API, if set. */
+    baseUrl?: string;
+    /** Texts to replace in every language. */
+    labels?: NovaPaymentsLabelOverrides;
+    /** Customization of the labels. */
+    customization?: NovaPaymentsProviderCustomization;
+    /**
+     * The chain families the checkouts pay from a connected wallet on: the `adapters` prop, or those of `ownConnection`
+     * when Nova runs its own connection.
+     */
+    adapters?: PaymentsAdapter[];
+    /** The app's Pulsar store, which takes over the payments a checkout closed on. */
+    pulsar?: PaymentsPulsar;
+    /** Whose wallet connection the checkouts use; unset without `NovaPaymentsProvider`. */
+    connection?: PaymentsConnectionMode;
+    /**
+     * The app's handler that connects a wallet, for the checkouts and refunds below without Nova Connect.
+     *
+     * @param family - The chain family of the payment.
+     */
+    onConnectWallet?: (family: PaymentFamily) => void;
+}
+/**
+ * The context of `NovaPaymentsProvider`, created once and saved on `globalThis`
+ * (`Symbol.for('tuwaio.nova-payments.context')`), so copies of the package share it. @internal
+ */
+declare const NovaPaymentsContext: Context<NovaPaymentsSettings>;
+
+/**
+ * The settings of the nearest `NovaPaymentsProvider`; empty without one.
+ *
+ * @returns The settings.
+ */
+declare function useNovaPayments(): NovaPaymentsSettings;
+
+/**
+ * The current time, updated every `intervalMs` while `active`.
+ *
+ * Side effect: an interval timer while active.
+ *
+ * @param intervalMs - How often to update, in milliseconds.
+ * @param active - Whether to update (stop on a final state to save renders).
+ * @returns `Date.now()` of the latest update.
+ */
+declare function useNow(intervalMs: number, active?: boolean): number;
+
+/**
+ * Tells the app once that the invoice is paid, when the checkout reaches the paid outcome.
+ *
+ * @param phase - Where the payment stands.
+ * @param invoice - The invoice of the checkout.
+ * @param onPaid - The app's callback, if any.
+ */
+declare function usePaidCallback(phase: CheckoutPhase, invoice: CheckoutView['invoice'] | undefined, onPaid: ((invoice: CheckoutView['invoice']) => void) | undefined, openedPaid?: boolean): void;
+/** What {@link useAutoReturn} needs. */
+interface UseAutoReturnParams {
+    /** Where to send the buyer (the invoice's `successUrl`); `null` for no return. */
+    url: string | null;
+    /** Seconds before the return; `0` for no automatic return. */
+    seconds: number;
+    /** `Date.now()` of the latest second tick of the checkout. */
+    now: number;
+    /**
+     * Sends the buyer to the link (default: `window.location.assign`).
+     *
+     * @param url - The link.
+     */
+    navigate?: (url: string) => void;
+}
+/**
+ * The visible countdown before the paid outcome sends the buyer back to the seller, with "Stay here" (WCAG 2.2.1).
+ *
+ * Side effects: navigates the page when the countdown ends.
+ *
+ * @param params - See {@link UseAutoReturnParams}.
+ * @returns `left`: seconds before the return (`null` when there is none); `stay`: stops it.
+ */
+declare function useAutoReturn({ url, seconds, now, navigate, }: UseAutoReturnParams): {
+    left: number | null;
+    stay: () => void;
+};
+
+/**
+ * @file Why a wallet did not pay: the buyer declined, the wallet cannot do it, it is on another network, or it failed.
+ */
+/**
+ * Why a wallet request did not go through: `declined` by the buyer, `unsupported` by the wallet, `wrongNetwork` when it
+ * was on another network than the request, `switchFailed` when it did not switch, `notAuthorized` when it has not allowed
+ * the account for the site (EIP-1193 4100), `alreadyPending` when another request of the site still waits in it,
+ * `sentUnconfirmed` when it sent a payment that is not confirmed yet (it may still land), or `failed`.
+ */
+type PaymentWalletErrorKind = 'declined' | 'unsupported' | 'wrongNetwork' | 'switchFailed' | 'notAuthorized' | 'alreadyPending' | 'sentUnconfirmed' | 'failed';
+/** The error a payments adapter throws when it knows why the wallet did not pay. */
+declare class PaymentWalletError extends Error {
+    readonly kind: PaymentWalletErrorKind;
+    /**
+     * @param kind - Why: see {@link PaymentWalletErrorKind}.
+     * @param message - What to log.
+     * @param options - The original error as `cause`.
+     */
+    constructor(kind: PaymentWalletErrorKind, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Why a wallet request failed, from the error the wallet library threw and the causes it wraps, whichever of them names
+ * it: EIP-1193 code `4001` and viem's `UserRejectedRequestError`, and the "user rejected" messages of Wallet Standard
+ * wallets, are `declined`. A request the wallet already has waiting (code `-32002`) is `alreadyPending`, also inside a
+ * failed switch: the buyer answers it there. wagmi's `ChainNotConfiguredError` (the network of the payment is not in the
+ * wagmi config of `paymentsEVMAdapter`; the buyer can still pay with the QR code) and `ConnectorNotConnectedError` (that
+ * config has no connection of the wallet) are `unsupported`, as is a wallet that does not know the request (codes 4200,
+ * -32601, -32004). `ConnectorChainMismatchError` and `ChainMismatchError` are `wrongNetwork`; `SwitchChainError` and
+ * `SwitchChainNotSupportedError` are `switchFailed`; code `4100` is `notAuthorized`. Named apart so that the page never
+ * says a payment failed, or that a fee was spent, about a request that never left the wallet.
+ *
+ * Side effects: in development (`NODE_ENV` is `development`), a failure it cannot name logs to the console, and a
+ * `ConnectorNotConnectedError` logs a `console.error`:
+ * the app gave `NovaPaymentsProvider` an EVM adapter built on another wagmi config than the one its wallet connection
+ * (its Satellite EVM adapter) uses.
+ *
+ * @param error - What the wallet library threw.
+ * @returns The kind.
+ */
+declare function walletErrorKind(error: unknown): PaymentWalletErrorKind;
+
+/** Where the confirmation of the paying wallet stands: the wallet switches its network, then signs. */
+type PayerProofStep = 'idle' | 'switching' | 'signing';
+/** Why the wallet did not confirm: its kind of failure, or a network switch the buyer refused, no signature being asked. */
+type PayerProofProblem = PaymentWalletErrorKind | 'switchDeclined';
+/** What {@link usePayerProof} needs. */
+interface UsePayerProofParams {
+    /** The adapter of the method's chain family; without `signMessage` the wallet cannot confirm the invoice. */
+    adapter: PaymentsAdapter | undefined;
+    /** The checkout store. */
+    store: {
+        getState: () => Pick<CheckoutState, 'confirmPayer' | 'requestQuote' | 'payer' | 'abandonConfirmation'>;
+    };
+    /** The connected wallet. */
+    wallet: CheckoutWallet | null;
+    /** The CAIP-2 network of the method: a smart wallet's signature counts there only. */
+    chainId: string;
+}
+/** What {@link usePayerProof} returns. */
+interface PayerProofFlow {
+    /** Where the confirmation stands. */
+    step: PayerProofStep;
+    /** Why the wallet did not switch or sign, until the next try; `switchDeclined`: the buyer refused the network switch. */
+    problem: PayerProofProblem | null;
+    /** The message Quasar issued for the wallet to sign (its site, network, nonce), once Quasar answered. */
+    request: PayerProofMessage | null;
+    /**
+     * Confirms the invoice from the wallet: switches the wallet to the method's network when it is on another one, then
+     * has it sign Quasar's message (`confirmPayer` of the checkout store).
+     *
+     * @param options - `quote: true` locks the price once the wallet confirmed (the step before the price).
+     * @param options.quote - Whether to lock the price after it.
+     * @returns Whether the wallet confirmed the invoice.
+     */
+    confirm: (options?: {
+        quote?: boolean;
+    }) => Promise<boolean>;
+    /**
+     * Closes the wallet window. The request stays open in the wallet: a signature it gives later still confirms the
+     * invoice (and locks the price), a refusal is not shown. A cancel during the network switch asks for no signature.
+     * {@link PayerProofFlow.confirm} can be called again at once: the new request replaces the open one, and signing
+     * twice moves no money.
+     */
+    dismiss: () => void;
+}
+/**
+ * Confirms that the connected wallet pays the invoice, for the step before the price and for a payment of a method the
+ * gasless relay could pay: a free signature of Quasar's EIP-4361 message that moves no money, one per invoice and wallet.
+ *
+ * Side effects: wallet prompts (a network switch, the signature); `POST payer-proof/message` and `POST payer-proof`
+ * through the checkout store, then `POST quote` with `quote: true`.
+ *
+ * @param params - See {@link UsePayerProofParams}.
+ * @returns See {@link PayerProofFlow}.
+ */
+declare function usePayerProof({ adapter, store, wallet, chainId }: UsePayerProofParams): PayerProofFlow;
+
+/**
+ * @file The payment of a locked price: how the wallet pays it, what the buyer sends and the merchant receives, the
+ * market rate behind it, and what a wallet lacks to pay it.
+ */
+
+/**
+ * How the wallet pays a quote: `relay` signs an EIP-3009 authorization that Quasar sends (the merchant pays the gas),
+ * `paymaster` sends the quoted calls with the checkout's ERC-7677 paymaster (a smart wallet; the merchant pays the
+ * gas), `transfer` sends the transfer and pays the gas.
+ */
+type PayPath = 'relay' | 'paymaster' | 'transfer';
+/**
+ * How the wallet pays a quote. A smart wallet that takes a paymaster sends sponsored calls; any other wallet signs the
+ * authorization; the buyer may choose to pay the gas instead.
+ *
+ * @param quote - The locked quote.
+ * @param options - What the buyer and the wallet allow.
+ * @param options.withGas - The buyer chose "Pay with gas instead".
+ * @param options.canSponsorCalls - The wallet sends `wallet_sendCalls` with the `paymasterService` capability.
+ * @returns The path.
+ */
+declare function payPath(quote: CheckoutQuote, options: {
+    withGas: boolean;
+    canSponsorCalls: boolean;
+}): PayPath;
+/** What a quote moves, in base units of its token. */
+interface QuoteAmounts {
+    /** What the buyer sends. */
+    send: string;
+    /** What the merchant receives. */
+    receives: string;
+    /** The token's transfer fee on top, with its percent; `null` when the token keeps none. */
+    fee: {
+        amount: string;
+        percent: string;
+    } | null;
+}
+/**
+ * What the buyer sends and the merchant receives for this payment: the same amount, unless the token keeps a fee on
+ * every transfer. On the quote of a rest that is what is left of the invoice, not its total.
+ *
+ * @param quote - The locked quote.
+ * @returns The amounts.
+ */
+declare function quoteAmounts(quote: CheckoutQuote): QuoteAmounts;
+/**
+ * The market price of one token in the invoice currency behind a quote. Quasar asks for
+ * `total × (1 + markup) × (1 − discount) / price` tokens, so the price is recovered without the method's markup or
+ * discount, which the checkout shows apart. For display only: amounts are never derived from it.
+ *
+ * @param quote - The locked quote.
+ * @param totalMinor - The invoice total in minor units (cents) the quote pays.
+ * @returns The price, or `null` without a total or a token amount.
+ */
+declare function quoteRate(quote: CheckoutQuote, totalMinor: string | null): number | null;
+/** What a wallet lacks for a payment, in base units. */
+interface BalanceShortfall {
+    /** What the wallet has. */
+    have: string;
+    /** What the payment needs. */
+    need: string;
+    /** The difference. */
+    short: string;
+}
+/**
+ * What a wallet lacks to pay a quote.
+ *
+ * @param balance - The wallet's balance of the quoted token, in base units.
+ * @param quote - The locked quote.
+ * @param fee - The network fee, when it is paid in the quoted token (the native coin); counted in what is needed.
+ * @returns The shortfall, or `null` when the balance is enough.
+ */
+declare function balanceShortfall(balance: bigint, quote: CheckoutQuote, fee?: bigint): BalanceShortfall | null;
+/**
+ * The CAIP-2 chain a quote is paid on.
+ *
+ * @param instructions - What the wallet sends.
+ * @returns For example `eip155:8453` or `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`.
+ */
+declare function instructionsChainId(instructions: PaymentInstructions): string;
+
+/**
+ * @file Paying a locked price from the connected wallet, without React: the wallet prompt, then the hand-over to
+ * Quasar.
+ */
+
+/** What {@link payInvoice} needs. */
+interface PayInvoiceParams {
+    /** The adapter of the quote's chain family. */
+    adapter: PaymentsAdapter;
+    /** The checkout store (only `submit` and `relay` are used). */
+    store: {
+        getState: () => Pick<CheckoutState, 'submit' | 'relay'>;
+    };
+    /** The locked quote. */
+    quote: CheckoutQuote;
+    /** The wallet the quote is locked to. */
+    wallet: CheckoutWallet;
+    /** How the wallet pays, from `payPath`. */
+    path: PayPath;
+    /** The checkout's ERC-7677 paymaster URL, for the `paymaster` path. */
+    paymasterUrl: string | null;
+    /** Called when the wallet answered, before the payment is handed to Quasar. */
+    onWalletDone?: () => void;
+    /**
+     * Called with the ID of a sponsored batch as soon as the wallet took it, before it has a transaction.
+     *
+     * @param batchId - The ID of the batch.
+     */
+    onBatchAccepted?: (batchId: string) => void;
+    /**
+     * Called with the transaction the wallet sent (its hash), before Quasar takes it; not for a gasless signature, whose
+     * transaction Quasar sends.
+     *
+     * @param txKey - The transaction hash (EVM) or signature (Solana).
+     */
+    onSent?: (txKey: string) => void;
+}
+/**
+ * Pays a locked quote: `transfer` sends the transfer and hands its key to Quasar (`submit`), `relay` signs the
+ * authorization for Quasar to send (`relay`), `paymaster` sends the sponsored calls and hands their transaction hash
+ * to Quasar. A transaction the wallet sent is always handed over, whatever the page shows meanwhile, with the method it
+ * was quoted for: the buyer may have gone on to a price on another network while the wallet asked.
+ *
+ * Side effects: a wallet prompt; requests to the checkout routes of Quasar.
+ *
+ * @param params - See {@link PayInvoiceParams}.
+ * @returns Whether Quasar took the payment (the store's `error` says why not).
+ * @throws {@link PaymentWalletError} `unsupported` when the adapter or the quote cannot take the path; the wallet's
+ *   error when it refuses or fails.
+ */
+declare function payInvoice({ adapter, store, quote, wallet, path, paymasterUrl, onWalletDone, onBatchAccepted, onSent, }: PayInvoiceParams): Promise<boolean>;
+
+/**
+ * How long a request the wallet never answered blocks a second one. A wallet that lost its request (a mobile session that
+ * ended) gives no answer at all, and the buyer must not be trapped by it for good.
+ *
+ * @internal
+ */
+declare const OPEN_REQUEST_MS: number;
+
+/** Where a payment from the wallet stands: `wallet` while the wallet asks the buyer, `submitting` while Quasar takes it. */
+type PaymentStatus = 'idle' | 'switching' | 'wallet' | 'submitting';
+
+/**
+ * Whether the wallet took a sponsored batch of this checkout that has no hash yet: nothing the store knows of, and still the
+ * page must not say that nothing was sent.
+ *
+ * @param store - The checkout store.
+ * @returns Whether such a batch may be on its way.
+ * @internal
+ */
+declare function isPaymentAccepted(store: object): boolean;
+/** What {@link usePayment} needs. */
+interface UsePaymentParams {
+    /** The adapter of the quote's chain family; without it the wallet cannot pay. */
+    adapter: PaymentsAdapter | undefined;
+    /** The checkout store. */
+    store: PayInvoiceParams['store'];
+    /** The locked quote. */
+    quote: CheckoutQuote | null;
+    /** The wallet the quote is locked to. */
+    wallet: CheckoutWallet | null;
+    /** How the wallet pays. */
+    path: PayPath;
+    /** The checkout's ERC-7677 paymaster URL. */
+    paymasterUrl: string | null;
+    /** The invoice: a sponsored batch the wallet took is kept in the tab under it until its hash comes. */
+    invoiceId?: string;
+    /**
+     * Called with the payment the wallet sent (not a gasless signature, whose transaction Quasar sends).
+     *
+     * @param payment - The transaction and what it pays.
+     */
+    onSent?: (payment: SentPayment) => void;
+}
+/** What {@link usePayment} returns. */
+interface Payment {
+    /** Where the payment stands. */
+    status: PaymentStatus;
+    /** Why the wallet did not pay or switch, until the next try. */
+    problem: PaymentWalletErrorKind | null;
+    /** The wallet asked, for the window: it keeps its name when the buyer disconnects it while the request waits there. */
+    askedWallet: CheckoutWallet | null;
+    /** What the wallet was asked to send, for the window: a request that waits keeps its amount under a new price. */
+    askedInstructions: PaymentInstructions | null;
+    /** Pays the quote from the wallet; resolves when Quasar took it or the wallet refused. */
+    pay: () => Promise<void>;
+    /** Asks the wallet to switch to the quote's chain. */
+    switchNetwork: () => Promise<void>;
+    /**
+     * Closes the wallet window. A request the wallet still shows stays open there: a transaction it sends later is
+     * still handed to Quasar, a refusal is not shown.
+     */
+    dismiss: () => void;
+}
+/**
+ * Pays a locked quote from the connected wallet and says where it stands, for the pay step.
+ *
+ * Side effects: wallet prompts; requests to the checkout routes of Quasar.
+ *
+ * @param params - See {@link UsePaymentParams}.
+ * @returns See {@link Payment}.
+ */
+declare function usePayment({ adapter, store, quote, wallet, path, paymasterUrl, invoiceId, onSent, }: UsePaymentParams): Payment;
+
+/**
+ * What the confirm and paid steps show of the payment: its network and amount (from the locked quote), the
+ * transaction (Quasar's hash, else the submitted key) with its explorer link from the chain adapter, and the sender.
+ *
+ * @returns The facts; each is `null` (or `undefined` for the link) when unknown.
+ */
+declare function usePaymentFacts(): {
+    network: string | null;
+    amount: string | null;
+    paidAmount: string | null;
+    txKey: string | null;
+    lastOfParts: boolean;
+    explorerUrl: string | undefined;
+    from: string | null;
+    fromAddress: string | null;
+    fromUrl: string | undefined;
+};
+
+/** What {@link usePaymentHandOver} needs. */
+interface UsePaymentHandOverParams {
+    /** The checkout store (its state is read when the payment is handed over). */
+    store: {
+        getState: () => Pick<CheckoutState, 'phase' | 'error' | 'checkout'>;
+    };
+    /** Whether the checkout is open (a modal); an inline checkout stays open while it is shown. */
+    open: boolean;
+    /**
+     * The adapter of a chain family.
+     *
+     * @param family - The family.
+     * @returns The adapter, if any.
+     */
+    adapterFor: (family: PaymentFamily) => PaymentsAdapter | undefined;
+    /** The app's Pulsar store, if any. */
+    pulsar: PaymentsPulsar | undefined;
+    /** The labels of the checkout language. */
+    labels: NovaPaymentsLabels;
+    /** The checkout language (a BCP 47 tag). */
+    locale: string;
+}
+/**
+ * Follows the payment the wallet sent until the checkout closes: while it is open the checkout tracks the payment
+ * itself; when it closes (or goes away) before Quasar settled the payment, the payment is handed over to the app's
+ * Pulsar store, where Nova Transactions shows its toast. A wallet that sends after the checkout closed hands its
+ * payment over at once.
+ *
+ * Side effects: on hand-over, a pending transaction in the Pulsar store and its tracker.
+ *
+ * @param params - See {@link UsePaymentHandOverParams}.
+ * @returns The function to call with the payment the wallet sent.
+ */
+declare function usePaymentHandOver({ store, open, adapterFor, pulsar, labels, locale, }: UsePaymentHandOverParams): (payment: SentPayment) => void;
+
+/**
+ * Whose wallet connection the checkouts and refunds use: the choice of the nearest {@link NovaPaymentsProvider}
+ * (made on its first render), or, without one, what the app's providers above give (`app`, `appStore` or `none`). See
+ * {@link PaymentsConnectionMode}.
+ *
+ * @returns The mode.
+ *
+ * @example
+ * ```tsx
+ * import { usePaymentsConnection } from '@tuwaio/payments-sdk';
+ *
+ * export function WalletNote() {
+ *   const connection = usePaymentsConnection();
+ *   return connection === 'own' ? <p>The checkout connects its own wallet.</p> : null;
+ * }
+ * ```
+ */
+declare function usePaymentsConnection(): PaymentsConnectionMode;
+
+/**
+ * The labels of a language: the built-in ones (English for a language without its own), then `labels` of
+ * `NovaPaymentsProvider`, then its `customization.labels.transform`. The built-in labels of a language other than
+ * English load on first use (see `loadLabels`); until they arrive the hook keeps the labels it showed before (English
+ * the first time) and renders again once they are loaded.
+ *
+ * @param locale - The language of the checkout.
+ * @returns The labels.
+ */
+declare function usePaymentsLabels(locale: string): NovaPaymentsLabels;
+
+/** What {@link useWalletConnection} returns. */
+interface WalletConnection {
+    /** Whether the page can connect a wallet: Nova Connect is set up, or the app handles it. */
+    canConnect: boolean;
+    /** Whether the connect modal of Nova Connect is open. */
+    connecting: boolean;
+    /**
+     * Asks the buyer to connect a wallet of a chain family.
+     *
+     * @param family - The family of the chosen method.
+     * @returns Whether the request went anywhere.
+     */
+    connect: (family: PaymentFamily) => boolean;
+}
+/**
+ * Connects a wallet for a payment: opens the connect modal of Nova Connect on the wallets of the method's chain family
+ * when the checkout is inside `NovaConnectProvider` of `@tuwaio/nova-connect` (the app's, or Nova's own connection of
+ * {@link NovaPaymentsProvider}), else calls the app's handler: `onConnectWallet`, or that of `NovaPaymentsProvider`.
+ *
+ * @param onConnectWallet - The app's handler, for apps that connect wallets without Nova Connect; overrides the
+ * `onConnectWallet` of `NovaPaymentsProvider`.
+ * @returns See {@link WalletConnection}.
+ */
+declare function useWalletConnection(onConnectWallet?: (family: PaymentFamily) => void): WalletConnection;
+
+/**
+ * @file The buyer details the checkout collects when the merchant's settings ask for them: which
+ * fields, what is missing, and the countries to pick from.
+ */
+
+/** A field of the buyer details form. */
+interface BuyerField {
+    /** The field of `Buyer`. */
+    name: keyof Buyer;
+    /** Whether the invoice needs it. */
+    required: boolean;
+    /** The `autocomplete` token, so browsers fill it in (WCAG 1.3.5). */
+    autoComplete: string;
+    /** The input type. */
+    type: 'email' | 'text' | 'country';
+}
+/** Why a field is refused: missing, not an email, not a country code. */
+type BuyerIssue = 'required' | 'email' | 'country';
+/** What the checkout collects: `email` or `full` details (the checkout view's `buyer.collect`). */
+type BuyerCollect = 'email' | 'full';
+/**
+ * The fields of the form, in order.
+ *
+ * @param collect - What the checkout collects.
+ * @param company - The buyer wants an invoice for a company: name, address line, country and tax ID are needed.
+ * @returns The fields.
+ */
+declare function buyerFields(collect: BuyerCollect, company: boolean): BuyerField[];
+/**
+ * What is missing or invalid in the details, field by field.
+ *
+ * @param buyer - The details as typed.
+ * @param collect - What the checkout collects.
+ * @param company - Whether the buyer wants a company invoice.
+ * @returns The issue of each refused field; empty when the details can be sent.
+ */
+declare function buyerIssues(buyer: Partial<Record<keyof Buyer, string>>, collect: BuyerCollect, company: boolean): Partial<Record<keyof Buyer, BuyerIssue>>;
+/**
+ * The details to send: trimmed, empty ones left out, the country in capitals.
+ *
+ * @param buyer - The details as typed.
+ * @returns The `Buyer` for `setBuyer` of the checkout store.
+ */
+declare function cleanBuyer(buyer: Partial<Record<keyof Buyer, string>>): Buyer;
+/**
+ * The countries to pick from, named in the language of the page (`Intl.DisplayNames`) and sorted by name.
+ *
+ * @param locale - BCP 47 language of the page.
+ * @returns The country codes and names.
+ */
+declare function countryOptions(locale: string): {
+    code: string;
+    name: string;
+}[];
+
+/**
+ * @file Numbers, amounts, addresses and countdowns as the checkout shows them, in the language of the page.
+ */
+/**
+ * A decimal string from an integer amount of minor units (cents), without floating point.
+ *
+ * @param minor - Minor units, as a decimal integer string (may be negative).
+ * @param digits - Minor digits of the currency (default `2`).
+ * @returns The decimal, for example `89.54` for `8954`.
+ */
+declare function minorToDecimal(minor: string, digits?: number): string;
+/**
+ * A fiat amount with two decimals and the grouping of the language, without the currency (the checkout shows its
+ * code next to it).
+ *
+ * @param amount - A decimal string or a number.
+ * @param locale - BCP 47 language of the page.
+ * @returns The formatted amount, for example `1,234.50` in English and `1.234,50` in German.
+ */
+declare function formatFiat(amount: string | number, locale: string): string;
+/**
+ * A token amount from base units, exact: every decimal the amount has (at least two), never rounded, with the
+ * grouping of the language. What the buyer sends must match the wallet to the last digit.
+ *
+ * @param baseUnits - Base units, as a decimal integer string.
+ * @param decimals - Decimals of the token.
+ * @param locale - BCP 47 language of the page.
+ * @returns The formatted amount, for example `89.54` for `89540000` with 6 decimals.
+ */
+declare function formatTokenAmount(baseUnits: string, decimals: number, locale: string): string;
+/**
+ * A network fee for a line of text: an estimate, so six decimals at most. A fee below that says nothing a reader can use
+ * (the wallet sets its own and may well charge more), so it has no number.
+ *
+ * @param baseUnits - Base units, as a decimal integer string (not negative).
+ * @param decimals - Decimals of the native token.
+ * @param locale - BCP 47 language of the page.
+ * @returns For example `0.000036` for 36082500481100 with 18 decimals; `null` for a fee below `0.000001`.
+ */
+declare function formatFeeAmount(baseUnits: string, decimals: number, locale: string): string | null;
+/**
+ * A token amount as a wallet takes it when pasted: exact, with a dot, without grouping or trailing zeros.
+ *
+ * @param baseUnits - Base units, as a decimal integer string (not negative).
+ * @param decimals - Decimals of the token.
+ * @returns For example `89.54` for `89540000` with 6 decimals, `5` for `5000000`.
+ */
+declare function baseUnitsToDecimal(baseUnits: string, decimals: number): string;
+
+/**
+ * Time left as a countdown: `mm:ss` under an hour, `hh:mm:ss` under a day, `Nd hh:mm` beyond, where seconds say nothing
+ * and would not fit beside the date in the summary.
+ *
+ * @param ms - Milliseconds left; a negative value counts as zero.
+ * @returns The countdown.
+ */
+declare function formatCountdown(ms: number): string;
+
+/**
+ * @file What the outcome steps show: how to reach the seller, when to ask before leaving, what a refusal means, the
+ * terms of automatic payments, what an underpaid invoice still needs, and what arrived on an invoice.
+ */
+
+/**
+ * Where "Contact <seller>" leads: an email to the seller's support address about the invoice, else the seller's site.
+ *
+ * @param merchant - The seller's support email and site.
+ * @param merchant.supportEmail - The support email, if any.
+ * @param merchant.website - The site (http(s) only), if any.
+ * @param subject - The subject of the email, for example `Invoice INV-2026-42`.
+ * @returns The link, or `null` when the seller gave neither.
+ */
+declare function contactHref(merchant: Pick<CheckoutMerchant, 'supportEmail' | 'website'>, subject: string): string | null;
+/**
+ * What the checkout says about a payment that left the wallet, or may have, from the store's error: a transaction that
+ * does not pay the invoice (`pay.mismatch`; `pay.mismatchTakenElsewhere` when Quasar credited it to another invoice;
+ * `pay.mismatchHeldElsewhere` when another invoice holds it for a refund only, `held`;
+ * `pay.mismatchOtherWallet` for a transfer from a wallet that did not confirm the invoice, `pay.mismatchOtherWalletHeld`
+ * when Quasar recorded it as a held transfer the seller returns, `held`; `pay.mismatchChargeHeld` for an automatic charge
+ * that landed after the buyer chose another way to pay), a payment Quasar closed after 24 hours without a result on chain
+ * (`outcome.unconfirmedClosed`), a transaction another invoice handed over first (`outcome.unconfirmedTakenElsewhere`)
+ * and a payment the network confirmed that Quasar has not recorded yet (`outcome.unconfirmedSettlementRetrying` while
+ * Quasar settles it again daily, for 30 days, else `outcome.unconfirmedSettlementFailed`). Never "it failed", "only the
+ * network fee was spent" or "nothing was charged" for them.
+ *
+ * @param error - The store's error, if any.
+ * @param labels - The labels of the checkout language.
+ * @param merchant - The seller's name.
+ * @returns The text, or `null` for any other error, or none.
+ */
+declare function leftTheWalletText(error: CheckoutError | null | undefined, labels: NovaPaymentsLabels, merchant?: string): string | null;
+/**
+ * Whether closing the checkout asks first: only while nothing has been sent. Once a transaction is on its way, or the
+ * invoice is settled, the checkout closes without a question; also after a payment that left the wallet, or may have
+ * ({@link leftTheWalletText}: a transaction that does not pay the invoice, a payment Quasar closed without a result on
+ * chain within 24 hours, a transaction another invoice handed over first, a confirmed payment Quasar has not recorded
+ * yet), so the question's "Nothing is sent yet" would not be true. Nor is it on the rest of an underpaid invoice, whose
+ * price stays as it is.
+ *
+ * @param phase - Where the payment stands.
+ * @param error - The store's last error, if any.
+ * @param status - The state of the invoice, when known.
+ * @returns `true` to ask.
+ */
+declare function needsLeaveConfirm(phase: CheckoutPhase, error?: CheckoutError | null, status?: string | null): boolean;
+/**
+ * The text of a refusal on the method step, with what to do.
+ *
+ * @param error - The store's error.
+ * @param labels - The labels of the checkout language.
+ * @param merchant - The seller's name, for a payment that left the wallet, or may have ({@link leftTheWalletText}).
+ * @returns The text.
+ */
+declare function methodErrorText(error: CheckoutError, labels: NovaPaymentsLabels, merchant?: string): string;
+/** The terms of an automatic payments offer, as the checkout shows them. */
+interface AutoPayTerms {
+    /** The CAIP-2 chain of the charges. */
+    chainId: string;
+    /**
+     * The wallet the charges are paid to: the merchant's, as the `payee` rule of the request names it (the app's
+     * collector, which sends the charges, when the request names no payee).
+     */
+    to: string;
+    /** The most it takes in a period, in base units of the token. */
+    limit: string;
+    /** Decimals of the token. */
+    decimals: number;
+    /** Symbol of the token. */
+    symbol: string;
+    /** The length of a period, in seconds. */
+    periodSeconds: number;
+    /** When the permission ends, in milliseconds; `null` without an expiry rule. */
+    expiresAt: number | null;
+}
+/**
+ * What the connected wallet may ask its wallet for: the offer, or taking over an active permission that holds nothing.
+ *
+ * @param offer - The automatic-charge offer of the checkout.
+ * @returns The method and the request, or `null` when nothing can be given now.
+ */
+declare function grantableOffer(offer: AutoChargeOffer | null): Extract<AutoChargeOffer, {
+    status: 'available';
+}> | NonNullable<Extract<AutoChargeOffer, {
+    status: 'active';
+}>['replacement']> | null;
+/**
+ * The terms of an ERC-7715 automatic payments offer: the periodic limit in the token of the method, the period, the
+ * expiry and the merchant's wallet the charges are paid to.
+ *
+ * @param offer - The view's `autoCharge`.
+ * @param methods - The view's methods (for the token of the offer).
+ * @returns The terms, or `null` when the offer is not available or its method is unknown.
+ */
+declare function autoPayTerms(offer: AutoChargeOffer | null, methods: CheckoutMethod[]): AutoPayTerms | null;
+/**
+ * A period as words of the language: whole days in days, otherwise in hours.
+ *
+ * @param seconds - The period.
+ * @param locale - BCP 47 language of the page.
+ * @returns For example `30 days`, `2 hours`, `30 днів`.
+ */
+declare function formatPeriod(seconds: number, locale: string): string;
+/**
+ * What an underpaid invoice still needs, in base units of the locked token.
+ *
+ * @param quote - The locked quote the payment was for.
+ * @param amountPaid - What arrived, in base units of that token.
+ * @returns The rest, or `null` when it is unknown or nothing is left.
+ */
+declare function underpaidRest(quote: Pick<CheckoutQuote, 'cryptoAmountExpected'> | null, amountPaid: string | null): string | null;
+/**
+ * What the buyer is told about the rate of the rest of an underpaid invoice, in an asset that moves against the invoice
+ * currency (`rateHeldUntil` of the quote): until when a payment settles by itself, or that the seller now decides.
+ *
+ * @param quote - The locked quote.
+ * @param now - The time now, in milliseconds.
+ * @param labels - The labels of the checkout language.
+ * @param merchant - The seller's name.
+ * @param locale - The language of the checkout.
+ * @param ended - What is said past that time; the payment step's `pay.restRateEnded` speaks of the payment being made.
+ * @returns The text, or `null` when the rate holds until the due date.
+ */
+declare function restRateText(quote: Pick<CheckoutQuote, 'rateHeldUntil'> | null, now: number, labels: NovaPaymentsLabels, merchant: string, locale: string, ended?: string): string | null;
+/**
+ * The address of a wallet Quasar names: it keeps the wallet that paid first as an address or as a CAIP-10 account.
+ *
+ * @param wallet - The wallet, in either form.
+ * @returns The address.
+ */
+declare function addressOfWallet(wallet: string): string;
+/**
+ * Whether two wallets Quasar names are one: an EVM address in any letter case, any other exactly.
+ *
+ * @param a - A wallet, as an address or an account.
+ * @param b - Another one.
+ * @returns `true` for the same wallet.
+ */
+declare function isSameWallet(a: string, b: string): boolean;
+/**
+ * What arrived on an invoice, when anything did: an expired invoice says so instead of "nothing was charged".
+ *
+ * @param amountPaid - What arrived, in base units of the locked token (`amountPaid` of the invoice).
+ * @returns The amount, or `null` when nothing arrived.
+ */
+declare function receivedAmount(amountPaid: string | null): string | null;
+/**
+ * Whether a refund sends more tokens than came in, or a noticeably different number of tokens than its amount took at the rate of the payment: half a
+ * percent or more, so a stablecoin at par never asks.
+ *
+ * @param preview - What the refund would send.
+ * @returns Whether the merchant should look first.
+ */
+declare function refundRateMoved(preview: Pick<RefundPreview, 'cryptoAmount' | 'atPaymentRate'> & Partial<Pick<RefundPreview, 'received'>>): boolean;
+/**
+ * Whether the checkout needs its second tick: for the deadline, the price lock and the return countdown. A receipt or an
+ * expired page left open would otherwise render everything once a second for nothing.
+ *
+ * @param phase - The checkout's phase.
+ * @param autoReturnSeconds - The seconds before the paid outcome returns to the seller, when set.
+ * @param labelsShown - Whether the labels of the language are there: their file shows with a render.
+ * @returns Whether to tick.
+ * @internal
+ */
+declare function needsTheClock(phase: string, autoReturnSeconds: number | undefined, labelsShown: boolean): boolean;
+
+/**
+ * @file The paying wallet's confirmation of the invoice: before an EVM payment the buyer's
+ * wallet sends itself, it signs Quasar's message for free, so that Quasar credits its transfers to this invoice only.
+ * When the checkout asks for it, what it says about a refusal, and which wallets sign with a passkey.
+ */
+
+/** Why the wallet did not confirm: its kind of failure, or a network switch the buyer refused. */
+type ConfirmProblem = PaymentWalletErrorKind | 'switchDeclined';
+/**
+ * Whether the wallet is a smart account that signs with a passkey (or a fingerprint), by its connector type.
+ *
+ * @param wallet - The connected wallet.
+ * @returns `true` for Coinbase Smart Wallet, Base Account and Porto.
+ */
+declare function isSmartWallet(wallet: Pick<CheckoutWallet, 'connectorType'> | null | undefined): boolean;
+/**
+ * Whether the wallet confirms the invoice before it pays from the pay step: while the checkout store says it must
+ * (`required`, `confirming`), and for a method the gasless relay could pay (`unless_relayed`) when the wallet sends the
+ * transfer or the paymaster's calls itself; the relay's signed authorization confirms the wallet on its own.
+ *
+ * @param payerProof - `payerProof` of the checkout store (left out by older stores).
+ * @param path - How the wallet pays the quote.
+ * @returns `true` to ask for the confirmation first.
+ */
+declare function needsPayerProof(payerProof: string | undefined, path: PayPath): boolean;
+/** The part of the checkout store {@link lockPrice} reads. */
+interface LockPriceStore {
+    /** The store's state and actions. */
+    getState: () => Pick<CheckoutState, 'requestQuote' | 'error'> & {
+        readonly payerProof?: string;
+    };
+}
+/**
+ * Locks the price for the wallet the buyer continued with, or turns to the step that confirms the wallet first: while
+ * the checkout store says the wallet must confirm the invoice (`payerProof` `required`), no price is asked; when Quasar
+ * refuses the price with `payer_proof_required` (a wallet it wants confirmed, which the checkout did not announce), the
+ * step shows too.
+ *
+ * Side effects: `POST quote` through the checkout store.
+ *
+ * @param store - The checkout store.
+ * @param showConfirmWallet - Shows (`true`) or leaves (`false`) the step that confirms the wallet.
+ * @returns The quote, or `null` when none was locked.
+ */
+declare function lockPrice(store: LockPriceStore, showConfirmWallet: (show: boolean) => void): Promise<CheckoutQuote | null>;
+/**
+ * Whether the error is a refusal of the wallet's confirmation (`payer_proof_*`, `payer_chain_mismatch`,
+ * `too_many_payers`): the pay step shows only these under the confirmation, its other errors have texts of their own.
+ *
+ * @param error - The checkout store's error, if any.
+ * @returns `true` for a refusal of the confirmation.
+ */
+declare function isPayerProofError(error: CheckoutError | null | undefined): boolean;
+/**
+ * Whether an error belongs on the step that confirms the wallet. The store's error may be about something else: a
+ * transfer held from another wallet, or a price refused to the last wallet, opened the step with "Something went wrong"
+ * before the wallet was asked anything.
+ *
+ * @param error - The checkout store's error, if any.
+ * @returns `true` for a refusal of the confirmation or a failure of its requests.
+ */
+declare function isConfirmationError(error: CheckoutError | null | undefined): boolean;
+/**
+ * What the step that confirms the wallet says about a refusal, with what to do: the wallet's (the buyer declined, the
+ * wallet cannot sign messages, it failed) or Quasar's (`payer_proof_invalid`, `payer_proof_unavailable`,
+ * `payer_chain_mismatch`, `too_many_payers`, `rate_limited`…). The buyer stays on the step and can try again.
+ *
+ * @param error - The checkout store's error, if any.
+ * @param problem - Why the wallet did not sign, when the checkout knows it.
+ * @param labels - The labels of the checkout language.
+ * @param values - The wallet's name, the method's network and the seller's name.
+ * @param values.wallet - The wallet's name.
+ * @param values.network - The network of the method.
+ * @param values.merchant - The seller's name.
+ * @returns The text, or `null` with nothing to say (no error, or `payer_proof_required`, the reason the step shows).
+ */
+declare function payerProofErrorText(error: CheckoutError | null | undefined, problem: ConfirmProblem | null, labels: NovaPaymentsLabels, values: {
+    wallet: string;
+    network: string;
+    merchant: string;
+}): string | null;
+
+/**
+ * @file A QR code as one SVG path, so the checkout draws it in its own colors.
+ */
+/**
+ * A QR code as an SVG path: one 1×1 square per dark module, inside a quiet zone of four modules. Error correction `M`
+ * (15 %) keeps payment links short enough to scan from a screen.
+ *
+ * @param text - What the code holds (a Solana Pay URL, a payment page).
+ * @returns The size of the square view box in modules and the path.
+ */
+declare function qrPath(text: string): {
+    size: number;
+    path: string;
+};
+
+/**
+ * @file A refund as the merchant's wallet sends it: the transfer Quasar asks for, in the shape of a payment.
+ */
+
+/** What Quasar asks the merchant to send for a refund (`instructions` of the refund store). */
+type RefundInstructions = NonNullable<RefundState['instructions']>;
+/**
+ * The transfer of a refund as a payments adapter sends it (`sendTransfer`): the asset of the payment to the payer, on
+ * the chain of the payment. The token is the contract or mint of the CAIP-19 asset, `native` for the coin of the chain.
+ *
+ * @param instructions - What Quasar asks to send.
+ * @returns The transfer, or `null` without a recipient or on a chain no adapter pays on.
+ */
+declare function refundTransfer(instructions: RefundInstructions): PaymentInstructions | null;
+
+/**
+ * Subtotal and tax of the invoice from its lines: the lines carry net amounts, the total includes tax. The tax row
+ * shows the rate when all taxed lines share one.
+ *
+ * @param invoice - The invoice of the checkout.
+ * @returns The subtotal, the tax (`null` without tax), its rate (`null` with several) and the total, as decimals.
+ */
+declare function invoiceTotals(invoice: CheckoutView['invoice']): {
+    subtotal: string;
+    tax: string | null;
+    rate: string | null;
+    total: string;
+};
+
+export { AmountStep, AutoPayScreen, BuyerScreen, CheckoutContext, CheckoutContextProvider, CheckoutFrame, CheckoutHeader, CheckoutPageRoot, CheckoutStepper, CheckoutSummary, CheckoutWallet, CompactSummary, ConfirmScreen, ConfirmStep, ConfirmWalletScreen, DEADLINE_ANNOUNCEMENTS, DeadlineTimer, Disclosure, FailedStep, LeaveDialog, LocaleSwitcher, MerchantBadge, MethodScreen, MobileSteps, NativeFee, NovaPaymentsContext, NovaPaymentsProvider, OPEN_REQUEST_MS, OrderLines, OrderTotal, OutcomeScreen, PaidScreen, PayScreen, PaymentCheckout, PaymentFamily, PaymentWalletError, PaymentsAdapter, QUOTE_WARNING_MS, QrScreen, RefundButton, RefundDialog, RefundSteps, ScreenBody, SellerDetailsContent, SummaryFooter, WalletPrompt, addressOfWallet, autoPayTerms, balanceShortfall, baseUnitsToDecimal, buyerFields, buyerIssues, checkoutClassName, checkoutScreen, checkoutSteps, cleanBuyer, contactHref, countryOptions, deadlineAnnouncement, deadlineState, formatCountdown, formatFeeAmount, formatFiat, formatPeriod, formatTokenAmount, grantableOffer, groupMethodsByToken, handOverPayment, instructionsChainId, invoiceTotals, isConfirmationError, isFinalPaymentFailure, isInvoicePaymentOnTheWay, isInvoicePaymentUnresolved, isMovedMoneyFailure, isPaidElsewhere, isPayerProofError, isPaymentAccepted, isPaymentOnTheWay, isQuoteEnding, isSameWallet, isSlow, isSmartWallet, leftTheWalletText, lockPrice, lockedPriceOnWallet, methodErrorText, minorToDecimal, needsLeaveConfirm, needsPayerProof, needsTheClock, paidSteps, payInvoice, payPath, payerProofErrorText, qrPath, quoteAmounts, quoteRate, receivedAmount, refundRateMoved, refundTransfer, refusalText, restRateText, screensPayingWallets, sentBeforeDeadline, shouldHandOver, takeOverOpens, unconfirmedFollowUp, unconfirmedTxKey, underpaidRest, useAsyncValue, useAutoReturn, useCheckoutContext, useCheckoutEvents, useCheckoutState, useCheckoutStore, useConnectedWallet, useNovaPayments, useNow, useOptionalCheckoutContext, usePaidCallback, usePayerProof, usePayment, usePaymentFacts, usePaymentHandOver, usePaymentsConnection, usePaymentsLabels, useRefund, useRereadValue, useWalletConnection, walletErrorKind, walletOnConfirmStep };
+export type { AutoPayTerms, BalanceShortfall, BuyerCollect, BuyerField, BuyerIssue, CheckoutContextValue, CheckoutHeaderProps, CheckoutNetworkOptionProps, CheckoutPartState, CheckoutPrimaryButtonProps, CheckoutQrCodeProps, CheckoutScreen, CheckoutScreenChoices, CheckoutScreenProps, CheckoutStatusIconProps, CheckoutStep, CheckoutStepperProps, CheckoutTokenGroup, CheckoutTokenOptionProps, ConfirmProblem, HandOverParams, LocaleSwitcherProps, LockPriceStore, NovaPaymentsLabelsContext, NovaPaymentsOwnConnection, NovaPaymentsProviderCustomization, NovaPaymentsProviderProps, NovaPaymentsSettings, OutcomeKind, PayInvoiceParams, PayPath, PayerProofFlow, PayerProofProblem, PayerProofStep, Payment, PaymentCheckoutChildCustomizations, PaymentCheckoutClassNames, PaymentCheckoutComponents, PaymentCheckoutConfig, PaymentCheckoutCustomization, PaymentCheckoutDisplay, PaymentCheckoutHandlers, PaymentCheckoutProps, PaymentStatus, PaymentWalletErrorKind, PaymentsConnectionMode, PaymentsPulsar, QuoteAmounts, RefundButtonProps, RefundDialogProps, RefundFlow, RefundInstructions, RefundProblem, RefundRequest, RefundStep, SentBeforeDeadlineParams, SentPayment, UnconfirmedFollowUp, UseAutoReturnParams, UseCheckoutEventsParams, UseCheckoutStoreOptions, UsePayerProofParams, UsePaymentHandOverParams, UsePaymentParams, UseRefundParams, WalletConnection, WalletPromptKind, WalletPromptProps };