@tuwaio/nova-payments 0.0.0-stage → 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,1296 @@
+import { P as PaymentsAdapter, C as CheckoutWallet, a as PaymentFamily } from './types-Bmj8ctqc.js';
+export { N as NativeFee, b as PulsarTransactionParams, c as canPayWithQr, d as connectedWallet, m as methodFamily, e as methodToken, n as networkName, p as payerFor, f as priceAdjustment, w as walletLabel } from './types-Bmj8ctqc.js';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { CheckoutMethod, CheckoutPhase, CheckoutView, CheckoutQuote, PaymentInstructions, CheckoutError, CheckoutStore, CheckoutState, CheckoutApi, EventSourceConstructor, AutoChargeOffer, CheckoutMerchant } from '@tuwaio/quasar-sdk/checkout';
+import { N as NovaPaymentsLabels, a as CheckoutLocale, b as NovaPaymentsLabelOverrides } from './locales-DtReb4Tp.js';
+import { Transaction } from '@tuwaio/pulsar-core';
+import { Buyer } from '@tuwaio/quasar-sdk';
+
+/**
+ * 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 account that takes the charges, until when, and how to turn it off. "Allow" asks
+ * the wallet for the ERC-7715 permission and hands it to Quasar (then the paid outcome says automatic payments are
+ * on); "Not now" keeps paying each invoice.
+ *
+ * Side effects: a wallet prompt; `POST permission` of the checkout.
+ *
+ * @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, or the full details, and a company invoice on request (name, address, country and 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 warn about time.
+ */
+
+/**
+ * A screen of the checkout: the steps of a payment (`buyer`, `method`, `pay` or `qr`, `confirm`, `autoPay`) or its
+ * outcome.
+ */
+type CheckoutScreen = 'loading' | 'error' | 'buyer' | 'method' | 'pay' | 'qr' | 'confirm' | 'paid' | 'autoPay' | '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 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 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.
+ * @param choices - What the buyer chose on the page.
+ * @returns The screen: `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.
+ */
+declare function checkoutScreen(state: {
+    phase: CheckoutPhase;
+    checkout: CheckoutView | null;
+    quote?: CheckoutQuote | 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 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 (decision of 2026-10-10). 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[];
+/** 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 {@link DEADLINE_ANNOUNCEMENTS}: 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.
+ * @returns The minutes to announce (the nearest when several were crossed at once), or `null`.
+ */
+declare function deadlineAnnouncement(previousMs: number | null, ms: 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;
+/**
+ * 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;
+
+/**
+ * @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.
+ *
+ * @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.
+ * @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>;
+
+/** 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;
+    /** 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. */
+    payUrl?: string;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+declare const CheckoutContext: react.Context<CheckoutContextValue | null>;
+/** Gives the parts of a checkout what they share. @internal */
+declare const CheckoutContextProvider: react.Provider<CheckoutContextValue | null>;
+
+/** 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;
+}
+/**
+ * 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).
+ *
+ * @param props - See {@link CheckoutStepperProps}.
+ * @returns The stepper.
+ */
+declare function CheckoutStepper({ steps, labels, className }: CheckoutStepperProps): react.JSX.Element;
+
+/** 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, while the invoice can be paid. @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;
+/**
+ * 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, 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, with the lines and the seller details behind a
+ * "Details" button.
+ *
+ * @returns The compact order.
+ */
+declare function CompactSummary(): 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.
+ *
+ * @returns The confirm step.
+ */
+declare function ConfirmScreen(): react.JSX.Element;
+
+/**
+ * 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. "Stay and pay" keeps the checkout,
+ * "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.
+ *
+ * @returns The method step.
+ */
+declare function MethodScreen(): react.JSX.Element | null;
+
+/** The outcomes this screen shows. */
+type OutcomeKind = Extract<CheckoutScreen, 'underpaid' | 'held' | 'refunded' | 'expired' | 'cancelled' | 'replaced' | 'blocked'>;
+/**
+ * An outcome other than paid: an underpaid invoice ("Pay the rest"), a payment the seller reviews (screening, late,
+ * overpaid), a refunded, expired or cancelled invoice, 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;
+
+/**
+ * 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).
+ *
+ * Side effects: navigates to the seller's `successUrl` when the countdown ends.
+ *
+ * @returns The paid outcome.
+ */
+declare function PaidScreen(): react.JSX.Element | null;
+
+/** 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, a sheet from the bottom under 640 px; `inline`: a block in the page;
+     * `page`: the block centered on its own page, as the Quasar payment page shows it.
+     */
+    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): with it, an EVM method can also be paid by
+     * scanning a QR code that opens the page on a phone.
+     */
+    payUrl?: string;
+    /**
+     * Connects a wallet of a chain family, for apps without Nova Connect. Inside `NovaConnectProvider` 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" (default `5`; `0` for no automatic return).
+     */
+    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;
+}
+/**
+ * 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/nova-payments';
+ * 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, }: PaymentCheckoutProps): react.JSX.Element;
+
+/**
+ * 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. Before the prompt it reads the wallet's balance and, when it is short, offers the methods
+ * the wallet can pay and the seller's top-up link.
+ *
+ * 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.
+ *
+ * @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 the wallet asks for: a gasless signature, a transaction, a network switch, the permission of automatic
+ * payments, or Quasar takes the payment.
+ */
+type WalletPromptKind = 'sign' | 'confirm' | 'switch' | 'permission' | 'submitting';
+/** Props of {@link WalletPrompt}. */
+interface WalletPromptProps {
+    /** What the wallet asks for. */
+    kind: WalletPromptKind;
+    /** The wallet's name. */
+    walletName: string;
+    /** The wallet's id, for its icon. */
+    walletId: 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;
+    /** Closes the window. */
+    onCancel: () => void;
+}
+/**
+ * The window over 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). The heading
+ * takes the focus, so screen readers say what happens. "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, amount, merchant, network, to, priceTime, onRetry, onCancel, }: 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;
+
+/**
+ * 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;
+
+/** 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;
+}
+/**
+ * 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; `null` without a connection or without the provider, in which case
+ * the checkout offers the QR code and the wallet connection only.
+ *
+ * @returns The wallet, or `null`.
+ */
+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;
+    };
+};
+/** 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 a connected wallet on: `paymentsEVMAdapter` of
+     * `@tuwaio/nova-payments/evm`, `paymentsSolanaAdapter` of `@tuwaio/nova-payments/solana`. Without the adapter of a
+     * method's family, the buyer pays that method with a QR code.
+     */
+    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 app. */
+    children: ReactNode;
+}
+/**
+ * Gives the checkouts below it the Quasar API, the labels and the chain adapters. A checkout works without it, with
+ * Quasar Cloud, the built-in labels and QR payments only.
+ *
+ * @param props - See {@link NovaPaymentsProviderProps}.
+ * @returns The provider.
+ *
+ * @example
+ * ```tsx
+ * import { NovaPaymentsProvider, PaymentCheckout } from '@tuwaio/nova-payments';
+ *
+ * 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, children, }: NovaPaymentsProviderProps): react.JSX.Element;
+
+/** 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. */
+    adapters?: PaymentsAdapter[];
+    /** The app's Pulsar store, which takes over the payments a checkout closed on. */
+    pulsar?: PaymentsPulsar;
+}
+/** The context of `NovaPaymentsProvider`. @internal */
+declare const NovaPaymentsContext: react.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): 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 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: the same amount, unless the token keeps a fee on every transfer.
+ *
+ * @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 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.
+ *
+ * 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, onSent, }: PayInvoiceParams): Promise<boolean>;
+
+/**
+ * @file Why a wallet did not pay: the buyer declined, the wallet cannot do it, or it failed.
+ */
+/** Why a wallet request did not go through. */
+type PaymentWalletErrorKind = 'declined' | 'unsupported' | '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: `declined` by the buyer, `unsupported` by the wallet, or `failed`.
+     * @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: EIP-1193 code `4001` and viem's
+ * `UserRejectedRequestError` (also as a `cause`), and the "user rejected" messages of Wallet Standard wallets, are
+ * `declined`.
+ *
+ * @param error - What the wallet library threw.
+ * @returns `declined`, `unsupported` or `failed`.
+ */
+declare function walletErrorKind(error: unknown): PaymentWalletErrorKind;
+
+/** 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';
+/** 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;
+    /**
+     * 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;
+    /** 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, 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;
+    txKey: string | null;
+    explorerUrl: string | undefined;
+    from: string | null;
+};
+
+/** 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;
+
+/**
+ * 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`.
+ *
+ * @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`, else calls the app's handler.
+ *
+ * @param onConnectWallet - The app's handler, for apps that connect wallets without Nova Connect.
+ * @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 (plan 12 §6.8): 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 Russian.
+ */
+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 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;
+/**
+ * An address shortened to its start and end, as wallets show it.
+ *
+ * @param address - The address (`0x…` or base58).
+ * @param head - Characters kept at the start; `0x` counts toward it (default `6` for `0x`, `4` otherwise).
+ * @param tail - Characters kept at the end (default `4`).
+ * @returns For example `0x1111…2222`; a short address unchanged.
+ */
+declare function shortAddress(address: string, head?: number, tail?: number): string;
+/**
+ * Time left as a countdown: `mm:ss` under an hour, `hh:mm:ss` under a day, `Nd hh:mm:ss` beyond.
+ *
+ * @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, and what an underpaid invoice still needs.
+ */
+
+/**
+ * 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;
+/**
+ * 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.
+ *
+ * @param phase - Where the payment stands.
+ * @returns `true` to ask.
+ */
+declare function needsLeaveConfirm(phase: CheckoutPhase): 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.
+ * @returns The text.
+ */
+declare function methodErrorText(error: CheckoutError, labels: NovaPaymentsLabels): 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 account that takes the payments (the merchant's collector). */
+    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;
+}
+/**
+ * The terms of an ERC-7715 automatic payments offer: the periodic limit in the token of the method, the period, the
+ * expiry and the accounts.
+ *
+ * @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;
+
+/**
+ * @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;
+};
+
+/**
+ * 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 { AutoPayScreen, type AutoPayTerms, type BalanceShortfall, type BuyerCollect, type BuyerField, type BuyerIssue, BuyerScreen, CheckoutContext, CheckoutContextProvider, type CheckoutContextValue, CheckoutHeader, type CheckoutHeaderProps, type CheckoutScreen, type CheckoutScreenChoices, type CheckoutStep, CheckoutStepper, type CheckoutStepperProps, CheckoutSummary, type CheckoutTokenGroup, CheckoutWallet, CompactSummary, ConfirmScreen, DEADLINE_ANNOUNCEMENTS, DeadlineTimer, type HandOverParams, LeaveDialog, LocaleSwitcher, type LocaleSwitcherProps, MerchantBadge, MethodScreen, MobileSteps, NovaPaymentsContext, type NovaPaymentsLabelsContext, NovaPaymentsProvider, type NovaPaymentsProviderCustomization, type NovaPaymentsProviderProps, type NovaPaymentsSettings, OrderLines, OrderTotal, type OutcomeKind, OutcomeScreen, PaidScreen, type PayInvoiceParams, type PayPath, PayScreen, type Payment, PaymentCheckout, type PaymentCheckoutDisplay, type PaymentCheckoutProps, PaymentFamily, type PaymentStatus, PaymentWalletError, type PaymentWalletErrorKind, PaymentsAdapter, type PaymentsPulsar, QUOTE_WARNING_MS, QrScreen, type QuoteAmounts, SellerDetailsContent, type SentPayment, SummaryFooter, type UseAutoReturnParams, type UseCheckoutStoreOptions, type UsePaymentHandOverParams, type UsePaymentParams, type WalletConnection, WalletPrompt, type WalletPromptKind, type WalletPromptProps, autoPayTerms, balanceShortfall, baseUnitsToDecimal, buyerFields, buyerIssues, checkoutScreen, checkoutSteps, cleanBuyer, contactHref, countryOptions, deadlineAnnouncement, formatCountdown, formatFiat, formatPeriod, formatTokenAmount, groupMethodsByToken, handOverPayment, instructionsChainId, invoiceTotals, isQuoteEnding, methodErrorText, minorToDecimal, needsLeaveConfirm, payInvoice, payPath, qrPath, quoteAmounts, quoteRate, shortAddress, shouldHandOver, underpaidRest, useAsyncValue, useAutoReturn, useCheckoutContext, useCheckoutState, useCheckoutStore, useConnectedWallet, useNovaPayments, useNow, usePaidCallback, usePayment, usePaymentFacts, usePaymentHandOver, usePaymentsLabels, useWalletConnection, walletErrorKind };