@openrails/billing-ui 0.235.0 → 0.237.0

package/CHANGELOG.md

@@ -1,5 +1,160 @@
 # Changelog
 
+## Running charges
+
+- `Balance` gains `accrued_amount`, `accrual_rate_per_hour`, `as_of` and
+  `depletes_at`: what the customer's running charges have charged and not yet
+  posted, the rate they draw the balance at, and when it runs out.
+  `available_amount` is net of the accrual.
+
+## Orders replace checkout sessions
+
+- Breaking: `<BuyButton>` and `<Offers>` create the customer's order and pay
+  it in `<OrderCheckout>`; `onPaid` receives the completed `Order`.
+  `returnUrl` replaces `successUrl`, and `autoRenew` is gone.
+- Breaking: `<CheckoutPage>`, `<CheckoutFrame>` and the shared payment page
+  are removed with checkout sessions; so are `CheckoutLayout`,
+  `CheckoutFrameTheme`, `CheckoutSession`, `CheckoutSessionStatus`,
+  `CheckoutPlan`, `CheckoutLineItem`, `CheckoutPhase`, `PaymentOption`,
+  `PayRequest`, `PayResult`, their schemas, `amountSchema`,
+  `unitDecimalsSchema`, `isCardRail`, `savedMethodsFor` and the client's
+  `CheckoutSessionLink`. `NextAction` and `PaymentFailure` are the order's,
+  from `@openrails/billing-ui/client`.
+- A page that paid a server-minted session pays the server's order instead:
+  the Go `Client.CreateOrder` creates it, and `<OrderCheckout orderId>` pays
+  it, a subscription line included.
+- `SavedPaymentMethod` names its `psp_id` (was `option_id`).
+
+## Usage orders
+
+- Breaking: `listInvoices`, `getInvoice` and `Invoice` are removed. Usage
+  billed in arrears is an order (`origin: usage`): `listOrders({ origin:
+  "usage" })` lists them, and `<OrderCheckout>` pays one with a saved card.
+- `Order` gains `usage` (its period, `due_at`, `amount_paid`, `amount_due`,
+  collection and `delinquent`) and `uncollectible_at`; `status` may be
+  `uncollectible`. A usage line names its `source`; its `price_id` and
+  `product_id` are null.
+- `Order.checkout.expires_at` is read again.
+
+## Embedded checkout
+
+- `<EmbeddedCheckout url onComplete?>` frames a merchant order's embedded
+  checkout (`checkout.ui_mode: embedded`): it follows the page's height and
+  hears its completion only from its own frame on the checkout host's origin;
+  without `onComplete` it goes to the checkout's `success_url`.
+- `Order.checkout.ui_mode`; `PublicMerchant.embed_origins`;
+  `PublicConfig.network` (the checkout page's sign-in to the customer network).
+- `createNetworkLinkChallenge()` and `createNetworkLink({challengeId, idToken})`
+  link the customer to a customer-network account.
+
+## No Solana token list
+
+- `listSolanaTokens` and `SolanaToken` are gone with `GET /v1/solana/tokens`:
+  the accepted tokens are `getConfig()`'s `payment.solana.tokens`.
+
+## Apple Pay and Google Pay
+
+- `<OrderCheckout wallets>` offers Apple Pay and Google Pay through a Stripe
+  PSP's Express Checkout Element, above the saved and new cards. Off by
+  default: the page's host must be a payment-method domain registered on that
+  Stripe account.
+
+## Renewals are orders
+
+- `Order` gains `renewal` (a subscription renewal's period and `due_at`) and
+  `voided_at`; `expires_at` is null on a renewal; `status` may be `void`.
+- `PaymentRecovery` gains `order_id`: an engine-owned subscription's unpaid
+  renewal, paid through `<OrderCheckout>`.
+- `<OrderCheckout>` offers new card entry only where the order takes one (a
+  renewal takes saved cards), and lets the customer authenticate a payment
+  their bank challenged while they were away.
+
+## Hosted checkout
+
+- `getConfig()` returns `merchant` (`PublicMerchant`: `display_name`, and
+  `logo_url` and `support_url` when they are https), null when the request
+  resolves no merchant.
+- `Order` carries `checkout` (its hosted checkout: `expires_at`,
+  `success_url`, `cancel_url`, `saved_payment_methods`; `url` only on the
+  answer that made it), null without one.
+
+## Orders take Solana and hosted pages
+
+- `<OrderCheckout>` offers an order's Solana option: one button per token,
+  then the Solana Pay QR of the order's `solana_pay` next action, confirmed
+  until the transfer lands.
+- A PSP with no fields in the page (Stripe without a publishable key) takes
+  the order on its hosted page: `<OrderCheckout>` sends the customer there and
+  back to `returnUrl` (default: the current page).
+- `OrderPaymentInput` gains `{ token_symbol, psp_id? }` and
+  `{ return_url, psp_id? }`.
+
+## OrderCheckout pays an order
+
+- `<OrderCheckout orderId>` shows an order and pays it with a saved card or a
+  new card in the PSP's fields, running any `next_action` and `confirm`. It
+  takes an optional `client` and offers only cards kept for one-click buys
+  (`PaymentMethod.reusable`).
+- The client gains `getOrder`, and `payOrder` and `confirmOrder`, which answer
+  `{ order, error? }`: a declined payment (402) is the order with
+  `payment.last_payment_error`, not a throw. `BillingError` carries `order`.
+- `StripeCardEntry`'s handle gains `tokenize()` and `handleNextAction()`.
+
+## A card is saved in one call
+
+- `addPaymentMethod` takes `token` (was `payment_token`). A Stripe card is a
+  `pm_` from Stripe's fields, saved by the same call; a card the bank wants to
+  authenticate answers `status: "requires_action"` with `next_action`, and
+  `confirmPaymentMethod(id)` finishes it after Stripe.js `handleNextAction`.
+  `StripeCardEntry` and `SavePaymentMethod` do this themselves.
+- `createCardSetup`, `getCardSetup`, `confirmCardSetup`, the `CardSetup` type
+  and the `returnURL` / `cardSetupReturnURL` props are gone: 3-D Secure runs in
+  the page.
+
+## Offers sell products by key
+
+- The public catalog is a lookup by product key: `listProducts({ keys })` and
+  `useProducts({ keys })` take the keys alone (1 to 100) and read one page;
+  `entitlements`, `limit` and `cursor` are gone, and so is
+  `ProductsState.nextCursor`. No keys fetch nothing.
+- `<Offers keys>` replaces `<Offers entitlements>`: your server names the
+  products, with the Go `Client.ListOffers` when it finds them by
+  entitlement.
+
+## Apps buy through BuyButton and Offers
+
+- `Checkout` and `CheckoutModal` (and their props), the fixture sources and
+  the `CheckoutSource` type are no longer exported; the client no longer has
+  `createCheckoutSession` or `checkoutSource`. Buy with `<BuyButton>` (it takes
+  `amount`, `autoRenew` and `successUrl`) or `<Offers>`. `CheckoutPage` and
+  `CheckoutFrame` stay, for the shared payment page.
+- The main entry also exports `createBillingClient` (with `BillingClient`,
+  `BillingClientOptions` and `ProductListOptions`) beside `formatAmount`, so a
+  React app imports from `@openrails/billing-ui` alone; `./client` and
+  `./react` are unchanged.
+
+## One provider
+
+- `BillingProvider` takes what `BillingUiProvider` took (`appearance`,
+  `messages`, `t`, `locale`, `navigate`) beside `client` and `onChange`, and
+  `BillingUiProvider` is gone. The main entry exports it; `./react` exports the
+  same component for hook-only apps, without the stylesheet. `client` is
+  optional: leave it out where no customer signs in, such as `CheckoutPage`.
+- Inside a provider with a client, the checkout saves a new card to the
+  customer first and pays on the customer surface.
+
+## Offers sell an entitlement
+
+- `<BuyButton product price onPaid onSignInRequired>` buys one price, labelled
+  from the catalog unless given `label`. The app never touches a checkout
+  session: when orders take a new card (#1168) it creates an order instead.
+- `<Offers entitlements onPaid onSignInRequired>` lists every product on sale
+  granting any of the entitlements, a `BuyButton` per price; `products` feeds
+  it from the host's server instead.
+- `listProducts({ entitlements, keys })` and `useProducts({ entitlements, keys })`
+  filter the public catalog. One of them is required: OpenRails no longer
+  lists the whole catalog publicly.
+
 ## Checkout saves a new card under its PSP
 
 - Inside a `BillingProvider`, `Checkout` saved a new card with the session

package/README.md

@@ -6,19 +6,17 @@ billing (subscriptions, saved cards, payment history).
 | Import                            | Contents                                                                           |
 | --------------------------------- | ---------------------------------------------------------------------------------- |
 | `@openrails/billing-ui/client`    | Framework-free typed client for `/billing/v1/me/*` and the catalog, `BillingError` |
-| `@openrails/billing-ui/react`     | `BillingProvider` and headless hooks                                               |
-| `@openrails/billing-ui`           | Styled checkout and account components, `BillingUiProvider`, i18n                  |
+| `@openrails/billing-ui/react`     | `BillingProvider` and headless hooks, without styles                               |
+| `@openrails/billing-ui`           | `BillingProvider`, styled checkout and account components, i18n                    |
 | `@openrails/billing-ui/locales/*` | `en de es ja ko zh` message bundles                                                |
 
-The checkout owns the browser payment flow. OpenRails holds the checkout
-session: the signed-in customer mints one for a price, and its `ocs_` id alone
-reads and pays it. Card data is tokenized in NMI-hosted Collect.js iframes and
-never enters the host application, unless the PSP takes cards on OpenRails
-itself (`card_entry: server`, driver `card`).
+The checkout owns the browser payment flow, behind `<BuyButton>`, `<Offers>`
+and `<OrderCheckout>`: the signed-in customer's order, read and paid with
+their own credential. Card data is tokenized in the PSP's own fields
+(Collect.js, Stripe Elements) and never enters the host application.
 
-See [Payment form contract](docs/payment-form-contract.md) for the exact-money
-session document, billing fields, browser-autofill behavior, and the checkout
-request schema.
+See [Payment form contract](docs/payment-form-contract.md) for exact money,
+billing fields, browser-autofill behavior and the payment request.
 
 The package lives in the OpenRails repository and shares its version: each
 OpenRails release `vX.Y.Z` publishes `@openrails/billing-ui@X.Y.Z` to npm, with
@@ -28,35 +26,57 @@ provenance.
 pnpm add @openrails/billing-ui@X.Y.Z
 ```
 
-## Checkout
+## Buying
+
+A React app imports from one place:
 
 ```tsx
-import { createBillingClient } from "@openrails/billing-ui/client"
-import { Checkout, CheckoutFrame } from "@openrails/billing-ui"
-import "@openrails/billing-ui/styles.css"
-
-const billing = createBillingClient({ fetch: auth.authFetch })
-const session = await billing.createCheckoutSession({
-  productKey: "pro",
-  priceKey: "monthly",
-})
+import { BillingProvider, BuyButton, Offers, createBillingClient, formatAmount } from "@openrails/billing-ui"
 
-// 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()} />
+// auth-ui's authFetch attaches the bearer and retries once after a refresh;
+// `getToken: () => token` works for any other auth.
+const billing = createBillingClient({ baseUrl: "/billing/v1", fetch: auth.authFetch })
+
+<BillingProvider client={billing} appearance={{ theme: "auto" }}>
+  <App />
+</BillingProvider>
 ```
 
-`onComplete` is a hint: confirm access from your own authenticated API before
-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`.
+`<BuyButton>` buys one price, `<Offers>` the products your server names by
+key (a course, its bundle and the membership that also unlocks it; the Go
+`Client.ListOffers` finds the products granting an entitlement): a
+`BuyButton` per price ("$4.99", "Rent for 3 days, $1.99",
+"$10.00 every 30 days"). The purchase is theirs from start to payment: a
+button creates the customer's order and pays it in a dialog
+(`<OrderCheckout>`); a second click before it is paid opens the same order.
+Signing in is the host's: with `signedIn={false}`, or when OpenRails answers
+401, they call `onSignInRequired` instead. `onPaid` receives the completed
+order; it is a hint, so confirm access from your own API (your gate) before
+granting anything.
+
+```tsx
+<BuyButton
+  product="course-101"
+  price="rent" // labelled from the catalog unless you pass label
+  signedIn={signedIn}
+  onSignInRequired={() => openSignIn()}
+  onPaid={() => navigate("/courses/css-101")} // your gate now admits them
+/>
+
+<Offers
+  keys={["course-101", "course-bundle", "channel-membership"]} // from your server, or products={...} from its Client.ListOffers
+  signedIn={signedIn}
+  onSignInRequired={() => openSignIn()}
+  onPaid={() => navigate("/courses/css-101")}
+/>
+```
 
-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:
+`returnUrl` returns the buyer from a redirect step (Stripe's hosted page); it
+must be on one of your app's return origins.
+
+For prepaid credits, a fixed pack is another product/price. A
+`customer_amount` price takes the buyer's `amount`: collect it on your product
+page, and the checkout charges exactly that:
 
 ```tsx
 import { decimalToAmount } from "@openrails/billing-ui/client"
@@ -65,72 +85,59 @@ import { decimalToAmount } from "@openrails/billing-ui/client"
 // `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
-})
+const valid = amount && bounds && BigInt(amount) >= BigInt(bounds.min_amount) && BigInt(amount) <= BigInt(bounds.max_amount)
+
+<BuyButton product="api-credits" price="deposit" amount={valid ? amount : undefined} label="Add credits" {...handlers} />
 ```
 
 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.
+use NMI or Stripe.
 
-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.
+A rail's own step is the order's `payment.next_action`: `redirect_to_url` (an
+https page, opened in the top window), `solana_pay` (a `solana:` link shown
+as a QR code) or `authenticate` (the bank's challenge, run in the page).
 
-The payment host serves `<CheckoutPage>` from one HTML entry at `PageURL`,
-behind its adapter's `CheckoutFramePolicy` (only the sites in
-`Config.Checkout.EmbedOrigins` may frame it):
+### An order your server creates
 
-```tsx
-import { BillingUiProvider, CheckoutPage } from "@openrails/billing-ui"
+A server that decides what its customer buys creates the order with the Go
+`Client.CreateOrder` (`POST /v1/app/orders`) and hands its id to the
+customer's browser, which pays it signed in:
 
-createRoot(root).render(
-  <BillingUiProvider>
-    <CheckoutPage appearance={{ variables: brand }} />
-  </BillingUiProvider>
-)
+```tsx
+<OrderCheckout orderId={orderId} returnUrl={returnUrl} onSettled={(order) => refetchAccess(order)} />
 ```
 
-The page reads the session id from its URL fragment and talks to its frame
-with `postMessage`, origin-checked both ways: page to app `ready`,
-`resize {height}`, `complete {status}` and `redirect {url}` (a nested frame
-cannot navigate the top window, so the app does); app to page
-`init {theme}`. The page messages only the app origin recorded on its session.
+`onSettled` follows a complete order, or one processing on an asynchronous
+rail. A subscription line names its subscription once paid.
 
 ## Account billing
 
+One `BillingProvider`, usually at the app's root, gives every component the
+client, the appearance and the words. `@openrails/billing-ui/react` exports the
+same provider for an app that uses only the hooks; it loads no stylesheet.
+
 ```tsx
-import { createBillingClient } from "@openrails/billing-ui/client"
-import { BillingProvider } from "@openrails/billing-ui/react"
-import { AccountBilling, BillingUiProvider } from "@openrails/billing-ui"
+import { AccountBilling, BillingProvider, createBillingClient } from "@openrails/billing-ui"
 import { de } from "@openrails/billing-ui/locales/de"
 
-// auth-ui's authFetch attaches the bearer and retries once after a refresh;
-// `getToken: () => token` works for any other auth.
 const billing = createBillingClient({ baseUrl: "/billing/v1", fetch: auth.authFetch })
 
-<BillingUiProvider appearance={{ theme: "auto" }} messages={de} locale="de" navigate={navigate}>
-  <BillingProvider client={billing} onChange={() => queryClient.invalidateQueries({ queryKey: ["billing"] })}>
-    <AccountBilling
-      plansHref="/plans"
-      defaultCurrency="USD" // offers "Make default"
-      sendSolanaTransaction={(tx) => wallet.signAndSend(tx)} // signs a Solana cancel
-    />
-  </BillingProvider>
-</BillingUiProvider>
+<BillingProvider
+  client={billing}
+  appearance={{ theme: "auto" }}
+  messages={de}
+  locale="de"
+  navigate={navigate}
+  onChange={() => queryClient.invalidateQueries({ queryKey: ["billing"] })}
+>
+  <AccountBilling
+    plansHref="/plans"
+    defaultCurrency="USD" // offers "Make default"
+    sendSolanaTransaction={(tx) => wallet.signAndSend(tx)} // signs a Solana cancel
+  />
+</BillingProvider>
 ```
 
 The panels read OpenRails' public configuration (`GET /config`) themselves,
@@ -143,17 +150,15 @@ 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 and Solana reads
-are public routes, served only when the host mounts OpenRails' checkout
-routes; `GET /config` is always served.
+The catalog read is a public route, served only when the host mounts
+OpenRails' checkout routes; `GET /config` is always served.
 
 | Call                                                                                                | Route                                                           |
 | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
-| `listProducts()` (each product embeds its prices on sale)                                           | `GET /catalog/products`                                         |
+| `listProducts({ keys })`: the products on sale named by `keys` (1 to 100 product keys), each with its prices, in one page; `useProducts` reads the same | `GET /catalog/products` |
 | `getConfig()` (capabilities, `currencies`, `payment` with PSPs, `solana.network` and tokens; `client.currencies` is the pinned registry) | `GET /config` |
 | `previewSubscriptionChange(id, { priceId?, quantity? })`                                            | `POST /me/subscriptions/{id}/change/preview`                    |
 | `changeSubscription(id, { priceId?, quantity?, idempotencyKey, signature? })`                       | `POST /me/subscriptions/{id}/change`                            |
-| `listSolanaTokens({ priceId, wallet })`                                                             | `GET /solana/tokens`                                            |
 
 ```ts
 const preview = await billing.previewSubscriptionChange(sub.id, { quantity: 5 }) // amount_due_now, effective
@@ -188,18 +193,15 @@ 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:
 
-- 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 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 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.
+- An order's `payment_options` are exactly the armed PSPs whose rail can make
+  this sale (Solana for one-time lines when it is configured, never CCBill),
+  each with what it `accepts`. `OrderCheckout` renders one panel: the
+  customer's saved cards on them, newest first, an inline new card and one Pay
+  button. No provider chooser with one rail.
+- A new card is charged and saved in one pay; an `authenticate` next action
+  runs 3-D Secure in the page, then `confirm`. A decline stays on the panel
+  with its message, so the buyer can pick another card under a new
+  idempotency key.
 - Only PSPs with `checkout !== false` (`checkoutPsps`) take new cards; others
   stay listed so existing cards and subscriptions keep working.
 - `<SavePaymentMethod psp={psp} onSaved={(id) => ...} />` saves a card in the
@@ -208,10 +210,8 @@ provider:
   `returnURL(setupId)`; confirm with `client.confirmCardSetup(id)`.
 - `authenticatePayment(client, operationId, psp)` completes a pending
   payment's 3-D Secure challenge when `canAuthenticatePayment(psp)`.
-- `defaultCountry` (Checkout, SavePaymentMethod, AccountBilling) preselects
-  the billing country, else the browser locale's region.
-- `CheckoutModal gate={<SignIn />}` renders host content (e.g. sign-in) in
-  the modal instead of the checkout until cleared.
+- `defaultCountry` (SavePaymentMethod, AccountBilling)
+  preselects the billing country, else the browser locale's region.
 
 - Panels: `SubscriptionsPanel` (cancel, resume, change card),
   `PaymentMethodsPanel`, `PaymentHistory`, `BillingStatusBadge`,
@@ -220,8 +220,8 @@ provider:
   subscription row; `useBillingRefresh()` refetches after host-side changes.
 - Hooks: `useSubscriptions` (`cancel`, `resume`, `setPaymentMethod`,
   `changeSubscription`, per-row `pending`, `nextCursor`), `usePaymentMethods` (`add`,
-  `remove`, `setDefault`), `usePayments` (cursor pages), `useProducts` (the
-  catalog).
+  `remove`, `setDefault`), `usePayments` (cursor pages), `useProducts` (a
+  catalog lookup by product key).
   Actions resolve to `null` or a `BillingError`; they never throw.
   `changeSubscription` resolves to the `SubscriptionChange` instead of `null`. Cancel, resume
   and the card change answer the subscription, which replaces the row.

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

@@ -1,12 +1,10 @@
 import { CheckoutAppearance } from '../appearance';
 import { SendSolanaTransaction } from '../client/client';
-import { PaymentMethodsPanelProps } from './payment-methods-panel';
 import { SubscriptionsPanelProps } from './subscriptions-panel';
 export interface AccountBillingProps {
-    cardSetupReturnURL?: PaymentMethodsPanelProps["cardSetupReturnURL"];
     /**
      * Offers to make a card the default for this currency: it pays the
-     * currency's invoices and every subscription in it without its own card.
+     * currency's usage orders and every subscription in it without its own card.
      */
     defaultCurrency?: string;
     /** Billing country to preselect when adding a card. */
@@ -19,4 +17,4 @@ export interface AccountBillingProps {
     className?: string;
 }
 /** Subscriptions, payment methods and history in one column. */
-export declare function AccountBilling({ cardSetupReturnURL, defaultCurrency, defaultCountry, sendSolanaTransaction, plansHref, renderSubscriptionFooter, historyPageSize, appearance, className, }: AccountBillingProps): import("react").JSX.Element;
+export declare function AccountBilling({ defaultCurrency, defaultCountry, sendSolanaTransaction, plansHref, renderSubscriptionFooter, historyPageSize, appearance, className, }: AccountBillingProps): import("react").JSX.Element;

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

@@ -1,11 +1,9 @@
 import { CheckoutAppearance } from '../appearance';
 import * as React from "react";
 export interface PaymentMethodsPanelProps {
-    /** Return target after off-page card verification; see `SavePaymentMethod`. */
-    cardSetupReturnURL?: (setupId: string) => string;
     /**
      * Offers to make a card the default for this currency: it pays the
-     * currency's invoices and every subscription in it without its own card.
+     * currency's usage orders and every subscription in it without its own card.
      */
     defaultCurrency?: string;
     /** Billing country to preselect when adding a card. */
@@ -17,4 +15,4 @@ export interface PaymentMethodsPanelProps {
  * 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, defaultCurrency, defaultCountry, appearance, className, }: PaymentMethodsPanelProps): React.JSX.Element;
+export declare function PaymentMethodsPanel({ defaultCurrency, defaultCountry, appearance, className, }: PaymentMethodsPanelProps): React.JSX.Element;

package/dist/buy-button.d.ts

@@ -0,0 +1,40 @@
+import { CheckoutAppearance } from './appearance';
+import { Order } from './client/types';
+import * as React from "react";
+export interface BuyButtonProps {
+    /** The product's catalog key. */
+    product: string;
+    /** The price's key within the product. */
+    price: string;
+    /** The button's text; by default the price's amount and terms, from the catalog. */
+    label?: string;
+    /**
+     * A customer-chosen deposit, in the price currency's native units, for a
+     * price with `customer_amount`; the order charges exactly this.
+     */
+    amount?: string;
+    /** Where a redirect PSP (Stripe's hosted page) returns the buyer: one of the app's return origins. */
+    returnUrl?: string;
+    /**
+     * The order is paid. A hint: the host's own gate decides access, so send
+     * the buyer to the content it guards.
+     */
+    onPaid: (order: Order) => void;
+    /**
+     * Buying needs a signed-in customer: called instead of the checkout when
+     * `signedIn` is false or OpenRails answers 401.
+     */
+    onSignInRequired: () => void;
+    /** false when the host knows the visitor is signed out. */
+    signedIn?: boolean;
+    appearance?: CheckoutAppearance;
+    className?: string;
+}
+export declare function BuyButton(props: BuyButtonProps): React.JSX.Element;
+export type PurchaseProps = Omit<BuyButtonProps, "product" | "price"> & {
+    /** The price to buy; the button waits while it is unknown. */
+    priceId?: string;
+    label: string;
+};
+/** One price's button and its order. Requires `BillingProvider`. */
+export declare function Purchase({ priceId, label, amount, returnUrl, onPaid, onSignInRequired, signedIn, appearance, className, }: PurchaseProps): React.JSX.Element;

package/dist/cart.d.ts

@@ -0,0 +1,18 @@
+import { CheckoutAppearance } from './appearance';
+import { BillingClient } from './client/client';
+import { Order } from './client/types';
+import * as React from "react";
+export interface CartProps {
+    /** The client to read and buy through; default: the provider's. */
+    client?: BillingClient;
+    /**
+     * The order made from the cart. Default: pay it here with OrderCheckout.
+     */
+    onOrder?: (order: Order) => void;
+    /** Passed to OrderCheckout: the order is complete, or processing. */
+    onSettled?: (order: Order) => void;
+    appearance?: CheckoutAppearance;
+    className?: string;
+}
+/** The customer's cart. Requires `BillingProvider`. */
+export declare function Cart({ client: given, onOrder, onSettled, appearance, className, }: CartProps): React.JSX.Element;