@openrails/billing-ui 0.230.0 → 0.234.0

package/CHANGELOG.md

@@ -1,6 +1,115 @@
 # Changelog
 
-## Hosted checkout sessions (openrails#1124)
+## The customer's summary
+
+- `getAccount()` reads `GET /me`: the balance per currency, the card that
+  pays each currency, and the unread notice count.
+- `Invoice.delinquent`: overdue past grace; new usage in its currency is
+  refused until it is paid.
+
+## A subscription's dunning is one object
+
+- `Subscription.dunning` (`SubscriptionDunning`) replaces `grace_ends_at` and
+  `next_retry_at`: the declines so far, the retries left, the next and the
+  final retry, and whether it waits for a new card. Null unless the
+  subscription is `past_due` or `awaiting_method`.
+
+## The public catalog is under /catalog
+
+- `listProducts()` reads `GET /catalog/products` (was `GET /products`).
+
+## One public configuration
+
+- `getConfig()` reads `GET /config`: the mount's `capabilities`, the currency
+  registry (`currencies`) and the merchant's `payment` setup (its PSPs and
+  Solana network and tokens; null without a merchant). It replaces
+  `getCheckoutConfig()` and `listCurrencies()`: `checkoutConfigSchema` and
+  `CheckoutConfig` are `publicConfigSchema` and `PublicConfig` (its `payment`
+  is a `PaymentConfig`), and `currencyRegistrySchema` is removed.
+  `client.currencies` stays the pinned registry.
+- `BillingProvider` fetches it once and shares it: `useConfig()` reads it,
+  `useCurrencyScales()` layers the pinned registry and host overrides over its
+  currencies, and the account panels use both.
+- `AccountBilling` and `PaymentMethodsPanel` take their PSPs from it; their
+  `psps` prop is removed. "Add card" waits for it, says so when it fails (with
+  a retry) or every card PSP is temporarily unavailable, and asks again after
+  the PSP's `retry_after`.
+- `PspConfig` has `status` and `retry_after`; a temporarily unavailable PSP
+  saves no card (`cardSetupDriver` is null).
+
+## Prices come with their products
+
+- `listPrices` is removed with `GET /prices`: `listProducts()` returns every
+  product on sale with its current prices. Filter by currency, product or
+  renewal in the browser.
+
+## Paying on a customer surface
+
+- `client.checkoutSource(id, { customerBase })` reads and pays a checkout
+  session as its signed-in customer at a customer surface's
+  `/checkout-sessions/{id}` (for example a host's
+  `/api/v1/merchants/acme/billing/me`), so its saved cards pay. Without
+  `customerBase` the session id alone pays at `/checkout-sessions/{id}` as
+  before. `<CheckoutPage customerBase>` passes it through.
+
+## 1.0.0
+
+Ships with OpenRails v1.0.0; use the two at the same version. Everything a host
+changes is in [Migrating to v1](../../docs/migrating-to-v1.md).
+
+Checkout
+
+- A checkout session is the only browser purchase. `createCheckoutSession()`
+  mints at `/me/checkout-sessions` and returns a `CheckoutSessionLink` (`url`
+  null without a payment page); `client.checkoutSource(id)` is the source of
+  `<Checkout>`, `<CheckoutModal>` and `<CheckoutPage>`.
+- The session document's `rails` is `options` (`PaymentOption`, with the
+  option's `psp_id`). A rail's own step is one `next_action`
+  (`redirect_to_url`, `solana_pay`); a card challenge is `operation`. Saved
+  methods carry `card` (`brand`, `last4`, `exp_month`, `exp_year`) and no
+  `default`. Fields OpenRails sends as null read as `undefined`.
+- `PayRequest` carries one `billing_details` (`name`, `email`, `phone`,
+  `address` with `postal_code` and `country`) in place of the flat
+  `name_on_card`, `zip`, `country`, `last_four`, `card_type` and `expiry_date`.
+- Stripe Elements runs on a session inside a `BillingProvider`: the card is
+  saved through the customer's client and the session pays it by id.
+- Removed: `createHttpSource`, `CheckoutSourceError`, `checkoutRails`,
+  `CheckoutRailOffer`, `PaymentRailOption`.
+
+Client
+
+- Lists are cursor pages: `listSubscriptions`, `listPaymentMethods`,
+  `listPayments` and `listInvoices` take `cursor` and answer `next_cursor`;
+  there is no `total`. The hooks page with `nextCursor`.
+- `cancelSubscription`, `resumeSubscription` and
+  `setSubscriptionPaymentMethod` resolve to the `Subscription`. A Solana cancel
+  or tier change answers `next_action` (`solana_sign_transactions`); sign it
+  with `signWalletAction` and repeat the call with `signature`. The separate
+  Solana cancel and tier-change methods are removed.
+- `addPaymentMethod` takes `NewCard` with `psp_id`, a `payment_token` or
+  `card`, and `billing_details`.
+- There is no default card: `setDefaultPaymentMethod` is
+  `setCollectionPaymentMethod`, the hook's `setDefault` is `setCollection`, the
+  change event is `payment_method.collection_changed`, and the
+  `AccountBilling` / `PaymentMethodsPanel` prop `defaultCurrency` is
+  `collectionCurrency`. `PaymentMethod` lists `collection_currencies`.
+- `getSolanaConfig()` is `getCheckoutConfig()` (the network is
+  `solana.network`); `listSolanaTokens` takes `{ priceId, wallet }`.
+- `getStatus()` and `BillingStatus` are removed: read `/me/entitlements` and
+  `listSubscriptions()`.
+- `listPrices` filters by `productId` and `autoRenew`. A `Price` has
+  `product_id`, `archived`, `access_duration_hours` (null: for good) and
+  `auto_renew`; `type`, `recurring.interval` and `active` are gone.
+- `Payment` has `kind`, a typed `status` and the `price` it bought; a
+  subscription's status is `canceled`.
+- A `TierChange` has no `mode`, `url` or `payment`: a redirect is
+  `next_action.url`. Generated list fields are `T[]`, never `null`.
+- A subscription's `access` windows are `starts_at` and `ends_at`.
+- A `Product` has no `catalog_id`. A refusal's code fixes its status:
+  `changeTier` answers a registered code for each condition, and a declined
+  tier-change charge is `card_declined` with `decline_reason`.
+
+## Hosted checkout sessions
 
 - OpenRails serves the checkout session; hosts no longer write
   `/api/v1/checkout/sessions` routes. `client.createCheckoutSession()` mints
@@ -14,7 +123,7 @@
 - `<Checkout onRedirect>` replaces the top-window navigation of redirect rails.
 - The session document gains `embed_origin`.
 
-## Server card entry (openrails#1129)
+## Server card entry
 
 - Driver `card` (a PSP declared `card_entry: server`, flow `card`): `<Checkout>`
   and `SavePaymentMethod` render plain card inputs with the Collect.js form's
@@ -26,7 +135,7 @@
 - `cardSetupDriver` may return `"card"`; `NewCard` takes `payment_token` or
   `card`, never both.
 
-## Catalog and plan-change client (openrails#1128)
+## Catalog and plan-change client
 
 - `@openrails/billing-ui/client` gains the public catalog (`listProducts`,
   `listPrices`, `listCurrencies`), plan change (`previewTierChange`,
@@ -40,7 +149,7 @@
   `"change_tier"`, `onChange` `subscription.tier_changed`), which resolves to
   the `TierChange` or a `BillingError`.
 
-## Explicit payment method, fail-fast errors (openrails#1087, #1088)
+## Explicit payment method, fail-fast errors
 
 - The checkout pre-selects the customer's default card (`PaymentMethod.default`,
   `SavedPaymentMethod.default`) and always sends the chosen card's id.
@@ -55,13 +164,13 @@
   (2 s). New `isServerError`; a 5xx without an error envelope has code
   `server_error`.
 
-## One-click card subscriptions (openrails#1085)
+## One-click card subscriptions
 
 - A checkout host relays a card subscription's pay request with OpenRails'
   `CreateCheckoutSessionRequest.Confirm`; a new Collect.js token subscribes in
   one call. No package API change.
 
-## Advertised checkout rails (openrails#1078)
+## Advertised checkout rails
 
 - Breaking: `checkoutRails(offers)` takes OpenRails' checkout options alone.
   Each option carries the `driver` and `public_config` OpenRails derived from
@@ -80,7 +189,7 @@ generated contract.
 ## 0.9.0
 
 One embedded card panel for one-time purchases and subscriptions, on every
-card PSP (openrails#1064). Requires OpenRails v0.164.0.
+card PSP. Requires OpenRails v0.164.0.
 
 - Stripe Elements checkout rail (`driver: "stripe_elements"`, from a PSP with
   `flow: "elements"`): saved Stripe cards or a new card in the page, 3-D
@@ -127,8 +236,7 @@ and never branches on Stripe, NMI or any other provider.
   `getPaymentAuthentication`, `confirmPaymentAuthentication`.
 - Breaking: `AccountBilling`/`PaymentMethodsPanel` take `psps` (and optional
   `cardSetupReturnURL`) instead of `cardSetup`; `CardSetupConfig` is removed.
-  Stripe card setup needs OpenRails serving Stripe's `publishable_key`
-  (openrails#1062).
+  Stripe card setup needs OpenRails serving Stripe's `publishable_key`.
 
 ## 0.7.0
 

package/README.md

@@ -35,21 +35,63 @@ import { Checkout, CheckoutFrame } from "@openrails/billing-ui"
 import "@openrails/billing-ui/styles.css"
 
 const billing = createBillingClient({ fetch: auth.authFetch })
-const session = await billing.createCheckoutSession({ priceKey: "pro-monthly" })
+const session = await billing.createCheckoutSession({
+  productKey: "pro",
+  priceKey: "monthly",
+})
 
-// A shared payment page (Config.HTTP.Checkout.PageURL) answers with a url:
+// A shared payment page (Config.Checkout.PageURL) answers with a url:
 <CheckoutFrame url={session.url} theme="dark" onComplete={() => refetchAccess()} />
 // Without one, the app renders the checkout itself:
 <Checkout source={billing.checkoutSource(session.id)} onComplete={() => refetchAccess()} />
 ```
 
 `onComplete` is a hint: confirm access from your own authenticated API before
-granting anything. Pass `successUrl` to return the buyer from a redirect rail
-(CCBill, Stripe hosted); it must be on one of your app's return origins.
+granting anything. Pass `successUrl` to return the buyer from a redirect step
+(Stripe's hosted page); it must be on one of your app's return origins. A
+server that starts checkout itself mints the session with the Go
+`Client.CreateCheckoutSession` and hands the browser its `id` and `url`.
+
+For prepaid credits, a fixed pack is another product/price selection. A
+`customer_amount` price also accepts `amount` when minting. Collect the amount
+on your product page before opening checkout; the resulting session shows and
+charges that exact amount, and its payment form cannot change it:
+
+```tsx
+import { decimalToAmount } from "@openrails/billing-ui/client"
+
+// `depositPrice` is in a product from listProducts; `currency` from getConfig().currencies.
+// `enteredAmount` is the text from an <input inputMode="decimal">, e.g. "100".
+const amount = decimalToAmount(enteredAmount, currency.decimals)
+const bounds = depositPrice.customer_amount
+if (
+  !amount ||
+  !bounds ||
+  BigInt(amount) < BigInt(bounds.min_amount) ||
+  BigInt(amount) > BigInt(bounds.max_amount)
+) {
+  throw new Error("Choose an amount within the deposit limits")
+}
+const session = await billing.createCheckoutSession({
+  priceId: depositPrice.id,
+  amount, // USD 100 becomes "100000000"; no floating-point conversion
+})
+```
+
+OpenRails validates the bounds and whole currency minor units before accepting
+payment. Fixed prices reject `amount`; their pack benefit can be greater than
+the purchase price for a bulk discount. Customer-selected deposits currently
+use NMI or Stripe. Changing the selected amount requires minting a new session.
+
+A rail's own step is the pay result's `next_action`: `redirect_to_url` (an
+https page, opened in the top window) or `solana_pay` (a `solana:` link shown
+as a QR code). A card challenge is its `operation`, authenticated in the page.
+Stripe Elements needs the buyer's billing client (`<Checkout>` inside a
+`BillingProvider`): the shared payment page offers token rails only.
 
 The payment host serves `<CheckoutPage>` from one HTML entry at `PageURL`,
 behind its adapter's `CheckoutFramePolicy` (only the sites in
-`Config.HTTP.Checkout.EmbedOrigins` may frame it):
+`Config.Checkout.EmbedOrigins` may frame it):
 
 ```tsx
 import { BillingUiProvider, CheckoutPage } from "@openrails/billing-ui"
@@ -83,29 +125,34 @@ const billing = createBillingClient({ baseUrl: "/billing/v1", fetch: auth.authFe
   <BillingProvider client={billing} onChange={() => queryClient.invalidateQueries({ queryKey: ["billing"] })}>
     <AccountBilling
       plansHref="/plans"
-      psps={checkoutConfig.psps} // OpenRails checkout config; enables "Add card"
-      defaultCurrency="USD" // enables "Make default"
-      sendSolanaTransaction={(tx) => wallet.signAndSend(tx)} // Solana-rail cancel
+      collectionCurrency="USD" // offers "Use for invoices"
+      sendSolanaTransaction={(tx) => wallet.signAndSend(tx)} // signs a Solana cancel
     />
   </BillingProvider>
 </BillingUiProvider>
 ```
 
+The panels read OpenRails' public configuration (`GET /config`) themselves,
+once per `BillingProvider`: "Add card" offers each PSP of its `payment` that
+saves a card in the page, and says so while the configuration fails or its
+card PSPs are temporarily unavailable; amounts use its currency registry over
+the pinned copy. `useConfig()` and `useCurrencyScales()` read the same copy
+for host components.
+
 ## Catalog and plan changes
 
 The client also reads the public catalog and changes a subscription's plan.
-No UI ships for these; hosts render their own. The catalog, currency and
-Solana reads are public routes, served only when the host mounts OpenRails'
-checkout routes.
+No UI ships for these; hosts render their own. The catalog and Solana reads
+are public routes, served only when the host mounts OpenRails' checkout
+routes; `GET /config` is always served.
 
 | Call                                                                                                | Route                                                           |
 | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
-| `listProducts()`, `listPrices({ currency, product, type })`                                         | `GET /products`, `GET /prices`                                  |
-| `listCurrencies()` (`client.currencies` is the pinned copy)                                         | `GET /currencies`                                               |
+| `listProducts()` (each product embeds its prices on sale)                                           | `GET /catalog/products`                                         |
+| `getConfig()` (capabilities, `currencies`, `payment` with PSPs, `solana.network` and tokens; `client.currencies` is the pinned registry) | `GET /config` |
 | `previewTierChange(id, priceId)`                                                                    | `POST /me/subscriptions/{id}/change-tier/preview`               |
-| `changeTier(id, { priceId, idempotencyKey })`                                                       | `POST /me/subscriptions/{id}/change-tier`                       |
-| `getSolanaConfig()`, `listSolanaTokens({ priceId, wallet })`                                        | `GET /solana/config`, `GET /solana/tokens`                      |
-| `prepareSolanaTierChange(id, newPriceId)`, `confirmSolanaTierChange(id, { signature, newPriceId })` | `POST /me/subscriptions/{id}/solana-tier-change`, `.../confirm` |
+| `changeTier(id, { priceId, idempotencyKey, signature? })`                                         | `POST /me/subscriptions/{id}/change-tier`                       |
+| `listSolanaTokens({ priceId, wallet })`                                                             | `GET /solana/tokens`                                            |
 
 ```ts
 const preview = await billing.previewTierChange(sub.id, price.id) // amount_due_now, effective
@@ -121,30 +168,32 @@ const change = await billing.changeTier(sub.id, {
   lost response), so OpenRails replays the stored result instead of charging
   twice. `requires_action` carries `operation_id` for `authenticatePayment`;
   replay the same key afterwards.
-- Solana rail: the wallet signs and sends `prepareSolanaTierChange`'s
-  `transaction`; pass its signature to `confirmSolanaTierChange`. Keep the
-  signature until the confirm succeeds; confirming again replays the result.
+- A rail that needs the customer's own step answers `requires_action` with a
+  `next_action`. Solana's is `solana_sign_transactions`:
+  `signWalletAction(change.next_action, send)` signs and sends its
+  transactions and returns the signature; repeat `changeTier` with the same
+  key and `signature`. `cancelSubscription(id, { reason, signature? })` works
+  the same way: its answer is the subscription, unchanged and carrying
+  `next_action` until the signed cancel lands. The hooks run this when given
+  `sendTransaction`.
 
 ## Provider-neutral flows
 
-Hosts pass OpenRails's browser PSP configs (`GET /checkout-config`, `psps`)
-through unchanged; the PSP's `flow` and public `config` pick the browser flow
+OpenRails's browser PSP configs (`GET /config`'s `payment.psps`) pick the
+browser flow from each PSP's `flow` and public `config`
 (Collect.js, native card inputs, Stripe Elements, redirect, wallet). Hosts never branch on a
 provider:
 
-- `checkoutRails(offers)` and `savedMethodsFor(methods, rails)` build a
-  `CheckoutSource`'s `rails` and `saved_methods` (the default card first, pre-selected; paying sends
-  the chosen card's id explicitly).
-  `offers` is OpenRails' `ListCheckoutRailOptions` result, passed through: it
-  lists exactly the armed PSPs whose rail can make this sale (Solana when it is
-  configured, never CCBill for a new subscription), each with its `driver` and
-  `public_config`. An offer without a driver is not rendered.
+- A session's `options` are exactly the armed PSPs whose rail can make this
+  sale (Solana when it is configured, never CCBill),
+  each with its `driver` and `public_config`; `saved_methods` are the buyer's
+  cards on them, newest first (paying sends the chosen card's id explicitly).
   Card rails (`collect_js`, `card`, `stripe_elements`) render one panel: saved cards,
-  an inline new card and one Pay/Subscribe button, which is the payer's
+  an inline new card and one Pay/Subscribe button, which is the customer's
   confirmation of the displayed terms. No provider chooser with one rail.
 - Inside a `BillingProvider`, a new card is always saved to the account first
   and the source is paid with `payment_method_id`; `requires_action` results
-  carrying `operation_id` run 3-D Secure in the page. A `failed` result stays
+  carrying an `operation` run 3-D Secure in the page. A `failed` result stays
   on the panel with `failure.message` next to its `field`, so the buyer can
   pick another card; the host gives each new attempt a new idempotency key.
 - Only PSPs with `checkout !== false` (`checkoutPsps`) take new cards; others
@@ -165,13 +214,13 @@ provider:
   `CancelSubscriptionDialog`; `AccountBilling` stacks them.
 - `renderSubscriptionFooter={(s) => ...}` adds host content under a
   subscription row; `useBillingRefresh()` refetches after host-side changes.
-- Hooks: `useSubscriptions` (`cancel`, `cancelOnChain`, `resume`,
-  `setPaymentMethod`, `changeTier`, per-row `pending`), `usePaymentMethods`
-  (`add`, `remove`, `setDefault`), `usePayments` (offset pages), `useProducts`
-  (the catalog). Actions resolve to `null` or a `BillingError`; they never
-  throw. `changeTier` resolves to the `TierChange` instead of `null`. Cancel
-  and resume are queued by OpenRails (202); hooks re-read the subscription
-  until the change shows.
+- Hooks: `useSubscriptions` (`cancel`, `resume`, `setPaymentMethod`,
+  `changeTier`, per-row `pending`, `nextCursor`), `usePaymentMethods` (`add`,
+  `remove`, `setCollection`), `usePayments` (cursor pages), `useProducts` (the
+  catalog).
+  Actions resolve to `null` or a `BillingError`; they never throw.
+  `changeTier` resolves to the `TierChange` instead of `null`. Cancel, resume
+  and the card change answer the subscription, which replaces the row.
 - Money is exact: `/me` amounts are int64 native-unit strings, scaled by the
   OpenRails currency registry (`currencies` option to extend it).
 - Messages: English is complete and the fallback; `messages` layers bundles,
@@ -201,8 +250,8 @@ sale and saved card on a credential-less NMI PSP).
 
 ```sh
 pnpm test:e2e        # Playwright against the real server
-pnpm contract        # regenerate src/client/generated from the in-repo OpenRails
-pnpm contract:check  # fail if the generated contract is stale
+pnpm contract        # regenerate OpenRails' contract files, src/client/generated among them
+pnpm contract:check  # fail if a generated contract file is stale
 ```
 
 `e2e/openrails/account.spec.ts` drives the packaged `AccountBilling` (built from

package/dist/account/account-billing.d.ts

@@ -3,9 +3,9 @@ import { SendSolanaTransaction } from '../client/client';
 import { PaymentMethodsPanelProps } from './payment-methods-panel';
 import { SubscriptionsPanelProps } from './subscriptions-panel';
 export interface AccountBillingProps {
-    psps?: PaymentMethodsPanelProps["psps"];
     cardSetupReturnURL?: PaymentMethodsPanelProps["cardSetupReturnURL"];
-    defaultCurrency?: string;
+    /** Offers to make a card the one that collects this currency's invoices. */
+    collectionCurrency?: string;
     /** Billing country to preselect when adding a card. */
     defaultCountry?: string;
     sendSolanaTransaction?: SendSolanaTransaction;
@@ -16,4 +16,4 @@ export interface AccountBillingProps {
     className?: string;
 }
 /** Subscriptions, payment methods and history in one column. */
-export declare function AccountBilling({ psps, cardSetupReturnURL, defaultCurrency, defaultCountry, sendSolanaTransaction, plansHref, renderSubscriptionFooter, historyPageSize, appearance, className, }: AccountBillingProps): import("react").JSX.Element;
+export declare function AccountBilling({ cardSetupReturnURL, collectionCurrency, defaultCountry, sendSolanaTransaction, plansHref, renderSubscriptionFooter, historyPageSize, appearance, className, }: AccountBillingProps): import("react").JSX.Element;

package/dist/account/cancel-dialog.d.ts

@@ -7,12 +7,12 @@ export interface CancelSubscriptionDialogProps {
     onOpenChange: (open: boolean) => void;
     /** Subscription display name. */
     name: string;
-    /** On-chain (Solana) cancel: no feedback, the wallet signs. */
+    /** On-chain (Solana) cancel: the wallet signs after the reason. */
     onChain?: boolean;
     /** In-flight stage, when cancelling. */
     pending?: SubscriptionAction;
     /** Resolves null on success; the dialog then closes. */
-    onConfirm: (feedback: string) => Promise<BillingError | null>;
+    onConfirm: (reason: string) => Promise<BillingError | null>;
     appearance?: CheckoutAppearance;
 }
 export declare function CancelSubscriptionDialog({ open, onOpenChange, name, onChain, pending, onConfirm, appearance, }: CancelSubscriptionDialogProps): React.JSX.Element;

package/dist/account/format.d.ts

@@ -1,10 +1,10 @@
-import { CardSummary, CurrencyScales, Payment, Subscription, SubscriptionPrice } from '../client/types';
+import { CardSummary, CurrencyScales, Payment, Price, Subscription } from '../client/types';
 import { Translator } from '../i18n/messages';
 export declare function formatDate(value: string | null | undefined, locale?: string): string | null;
 /** Exact money, or null while the currency's scale is unknown. */
 export declare function formatMoney(amount: string | null | undefined, currency: string, scales: CurrencyScales, locale?: string): string | null;
 /** "every 30 days", "30 days of access" or "one-time". */
-export declare function intervalLabel(price: SubscriptionPrice | null | undefined, m: Translator): string | null;
+export declare function intervalLabel(price: Pick<Price, "access_duration_hours" | "billing_interval_hours"> | null | undefined, m: Translator): string | null;
 export declare function subscriptionName(s: Subscription, { t }: Translator): string;
 /** What a payment bought: the product's name, else its kind, plus its cadence. */
 export declare function paymentItem(p: Payment, m: Translator): {
@@ -16,9 +16,9 @@ export declare function brandName(brand: string | null | undefined, fallback: st
 export declare function cardText(card: CardSummary | null | undefined, m: Translator): string;
 export declare function expiry(card: CardSummary | null | undefined): string | null;
 export declare const LIVE_STATUSES: Set<string>;
-/** Still grants access: live, or cancelled with the paid period running. */
+/** A current subscription, or a canceled subscription retaining paid access. */
 export declare const isLive: (s: Subscription) => boolean;
-/** Access ends at period end and nothing renews it. */
+/** Future billing has stopped or cancellation is scheduled. */
 export declare const isEnding: (s: Subscription) => boolean;
 export type StatusTone = "success" | "warning" | "destructive" | "neutral";
 export declare const statusTone: (status: string) => StatusTone;

package/dist/account/payment-methods-panel.d.ts

@@ -1,19 +1,17 @@
 import { CheckoutAppearance } from '../appearance';
-import { PspConfig } from '../psp';
 import * as React from "react";
 export interface PaymentMethodsPanelProps {
-    /**
-     * OpenRails's browser PSP configs (checkout config). "Add card" offers
-     * each one a card can be saved with in the page.
-     */
-    psps?: readonly PspConfig[];
     /** Return target after off-page card verification; see `SavePaymentMethod`. */
     cardSetupReturnURL?: (setupId: string) => string;
-    /** Enables "Make default" for this currency's invoice collection. */
-    defaultCurrency?: string;
+    /** Offers to make a card the one that collects this currency's invoices. */
+    collectionCurrency?: string;
     /** Billing country to preselect when adding a card. */
     defaultCountry?: string;
     appearance?: CheckoutAppearance;
     className?: string;
 }
-export declare function PaymentMethodsPanel({ psps, cardSetupReturnURL, defaultCurrency, defaultCountry, appearance, className, }: PaymentMethodsPanelProps): React.JSX.Element;
+/**
+ * The customer's saved cards. "Add card" offers each PSP of the merchant's
+ * payment setup (`GET /config`) that saves a card in the page.
+ */
+export declare function PaymentMethodsPanel({ cardSetupReturnURL, collectionCurrency, defaultCountry, appearance, className, }: PaymentMethodsPanelProps): React.JSX.Element;

package/dist/account/section.d.ts

@@ -19,7 +19,9 @@ export declare function EmptyState({ title, description, action, }: {
     description?: string;
     action?: React.ReactNode;
 }): React.JSX.Element;
-export declare function ErrorState({ error, onRetry, }: {
+export declare function ErrorState({ error, message, onRetry, }: {
     error: BillingError;
+    /** Replaces the error's own message. */
+    message?: string;
     onRetry: () => void;
 }): React.JSX.Element;

package/dist/checkout-page.d.ts

@@ -7,10 +7,15 @@ export interface CheckoutPageProps {
     baseUrl?: string;
     /** Replaces the client built from `baseUrl`. */
     client?: BillingClient;
+    /**
+     * Pay as the signed-in customer on this customer surface (its `/me`
+     * prefix) instead of with the session id alone; see `checkoutSource`.
+     */
+    customerBase?: string;
     /** This host's branding; the framing app chooses the theme. */
     appearance?: CheckoutAppearance;
     layout?: CheckoutLayout;
     defaultCountry?: string;
     className?: string;
 }
-export declare function CheckoutPage({ baseUrl, client, appearance, layout, defaultCountry, className, }: CheckoutPageProps): React.JSX.Element;
+export declare function CheckoutPage({ baseUrl, client, customerBase, appearance, layout, defaultCountry, className, }: CheckoutPageProps): React.JSX.Element;