@webround/commerce 0.0.0-stage → 0.3.0

package/dist/catalog/types.d.ts

@@ -0,0 +1,430 @@
+/** What every call of the catalog can be given besides what it asks. */
+export interface CallOptions {
+    /** To give up on the call. */
+    signal?: AbortSignal;
+}
+export type ProductSortField = 'createdAt' | 'updatedAt' | 'alphabetical' | 'price' | 'match' | 'availability' | `attribute:${string}` | `tag:${string}`;
+export type SortDirection = 'asc' | 'desc';
+/** What a product is loaded with: the shape of the answer does not change (the lists are always there), only what is in them. */
+export interface ProductLoad {
+    includeAssets?: boolean;
+    includeTagValues?: boolean;
+    includeAttributes?: boolean;
+    includeOptions?: boolean;
+    includeVariantAssets?: boolean;
+    includeVariantTagValues?: boolean;
+    includeVariantAttributes?: boolean;
+}
+/** The body of `POST /public/products`. The server refuses a key it does not know (400), so there is no other. */
+export interface ProductSearch extends ProductLoad {
+    /** Prices come in this currency (three letters: `EUR`). The one thing the server always asks for. */
+    currencyCode: string;
+    page?: number;
+    /** 1 to 100. */
+    limit?: number;
+    sortBy?: ProductSortField;
+    sortDirection?: SortDirection;
+    /** `once`, `daily`, `weekly`, `monthly`, `quarterly`, `semiannual` or `yearly` (another is refused). What prices are read and sorted in; sorting by price with none is sorting by `once`. */
+    cadence?: string;
+    /**
+     * The language the texts come in. `default` is the code of the store's DEFAULT language, whatever it is called (`it`, for a store whose default is Italian): it is always accepted. A language that is
+     * left out, or that the store does not use, is answered in the default one.
+     */
+    langCode?: string;
+    /**
+     * The filters to apply: a filter's id, or `<id>[<min>;<max>]` for a range of a range filter (either bound may be left empty: `[;100]`, `[10;]`; only `;` separates). Filters are combined with AND.
+     * Ids are matched as the store wrote them (in capitals they match nothing); one the store does not have is ignored, one that is not a UUID is refused. More than one range of the SAME filter is not
+     * something to send: the catalog keeps one of them.
+     */
+    filterIds?: readonly string[];
+    /** Tag values to filter by: values of the SAME tag are OR (either), values of different tags are AND (both). Ids as in `filterIds`. */
+    tagValueIds?: readonly string[];
+    /** A text to search for (1 to 255 characters). */
+    search?: string;
+    /** With a search, the filters are not applied. */
+    searchIgnoresFilters?: boolean;
+    includeNestedVariants?: boolean;
+}
+/** What the two ways of asking for ONE product have in common. A product is found by an id that is its own (a variant's slug, or the product's id): no page, no limit, no sorting. */
+export interface ProductDetailInput extends ProductLoad {
+    currencyCode: string;
+    cadence?: string;
+    /** The language the texts come in: `default` is the store's default language (see `ProductSearch.langCode`); one the store does not use is answered in the default one. */
+    langCode?: string;
+}
+/** By a variant's slug the answer is the variant's product; this route reads `includeNestedVariants` (and not `includeAllVariants`). */
+export interface ProductBySlugInput extends ProductDetailInput {
+    includeNestedVariants?: boolean;
+}
+/** By the product's id; this route reads `includeAllVariants` (and not `includeNestedVariants`). */
+export interface ProductByIdInput extends ProductDetailInput {
+    includeAllVariants?: boolean;
+}
+/**
+ * The body of `POST /public/products/{id}/related`: which of the product's related ones, and what they are loaded with. The catalog checks it against the same schema as a product's
+ * detail (so a page, a limit or a sorting are accepted), but reads only what is here: the related ones are always the first ten, in order of relevance, and a product has no `includeOptions` here.
+ */
+export interface ProductRelatedInput extends Omit<ProductLoad, 'includeOptions'> {
+    currencyCode: string;
+    cadence?: string;
+    /** The language the texts come in: `default` is the store's default language (see `ProductSearch.langCode`); one the store does not use is answered in the default one. */
+    langCode?: string;
+    includeNestedVariants?: boolean;
+}
+/** The body of `POST /public/products/{id}/reviews`: which reviews of a product, in which order. Everything is optional; what is left out is the server's to decide. */
+export interface ProductReviewsInput {
+    page?: number;
+    /** 1 to 100. */
+    limit?: number;
+    sortBy?: 'createdAt' | 'rating';
+    sortDirection?: SortDirection;
+    /** Only the reviews with this grade. */
+    rating?: 1 | 2 | 3 | 4 | 5;
+}
+export type AssetType = 'image' | 'video' | 'document';
+export type TagType = 'string' | 'number' | 'date';
+export type ValueFormat = 'year' | 'month-year' | 'date' | 'datetime' | 'datetime+tz';
+/**
+ * What an attribute or a tag says about how its value is written. The catalog documents `ValueFormat`, but a real one also sends `"number"` and `"string"` here (the type of the value, in the place of
+ * its format), so any text can come: the known ones are what an editor suggests.
+ */
+export type Format = ValueFormat | (string & Record<never, never>);
+export type Availability = 'not_available' | 'low_availability' | 'available';
+export interface AssetSummary {
+    url: string;
+    type: AssetType;
+    position: number;
+    /** A video's picture. */
+    thumbnail?: string;
+}
+export interface TagValueSummary {
+    value: string;
+    alias?: string;
+}
+/** In a list there are only the tags that are marked relevant. */
+export interface TagSummary {
+    name: string;
+    label?: string | null;
+    type: TagType;
+    format?: Format | null;
+    icon?: string | null;
+    relevant: boolean;
+    values: TagValueSummary[];
+}
+/** In a list there are only the attributes that are marked relevant. */
+export interface AttributeSummary {
+    name: string;
+    label?: string | null;
+    relevant: boolean;
+    type: TagType;
+    format?: Format | null;
+    icon?: string | null;
+    value: string;
+}
+/** What something costs, for one currency and cadence: net, gross (with the tax rate of the visitor's country) and the price before a discount. */
+export interface PriceRange {
+    cadence?: string;
+    currencyCode?: string;
+    netMin?: number;
+    netMax?: number;
+    grossMin?: number;
+    grossMax?: number;
+    compareNetMin?: number;
+    compareNetMax?: number;
+    compareGrossMin?: number;
+    compareGrossMax?: number;
+    rate?: number;
+}
+export interface VariantSummary {
+    id: string;
+    name: string;
+    slug: string;
+    /** The variant that is shown first. */
+    isFavourite: boolean;
+    productId: string;
+    availability: Availability;
+    /** At most 3. */
+    assets: AssetSummary[];
+    tags: TagSummary[];
+    attributes: AttributeSummary[];
+    quantity: number;
+    allowBackorder: boolean;
+    priceRanges: PriceRange[];
+    sku?: string;
+}
+export interface ReviewStats {
+    /** The average, 1 to 5 (0 with no reviews). */
+    rating: number;
+    count: number;
+}
+export interface ProductSummary {
+    id: string;
+    name?: string;
+    metadata: Record<string, unknown>;
+    /** At most 3. */
+    assets: AssetSummary[];
+    tags: TagSummary[];
+    attributes: AttributeSummary[];
+    reviews: ReviewStats;
+    /** One for each currency and cadence, over all the visible variants. */
+    priceRanges: PriceRange[];
+    /** At most 5, with different covers, the favourite ones first. */
+    variants: VariantSummary[];
+    /** How many visible variants are not in `variants`. */
+    remainingVariantsCount: number;
+}
+export interface Pagination {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+}
+/** The answer of `POST /public/products`. */
+export interface ProductPage {
+    data: ProductSummary[];
+    pagination: Pagination;
+}
+export interface Review {
+    id: string;
+    /** The name of the customer who wrote it. */
+    customerName: string;
+    /** 1 to 5. */
+    rating: number;
+    title: string;
+    comment: string;
+    /** True when the customer had an order before they wrote it. */
+    verifiedPurchase: boolean;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+/** The answer of `POST /public/products/{id}/reviews`, as the catalog sends it. */
+export interface ReviewPage {
+    data: Review[];
+    pagination: Pagination;
+    /** How many reviews there are for each grade, over all of the product's reviews that match `rating` (a grade nobody gave is not there). */
+    breakdown: Partial<Record<'1' | '2' | '3' | '4' | '5', number>>;
+}
+export interface AssetDetail {
+    id: string;
+    url: string;
+    type: AssetType;
+    position: number;
+    thumbnail?: string;
+    inherited: boolean;
+}
+export interface TagValueDetail {
+    id: string;
+    value: string;
+    alias?: string;
+}
+export interface TagDetail {
+    id: string;
+    name: string;
+    label?: string | null;
+    relevant: boolean;
+    sortable: boolean;
+    filterable: boolean;
+    type: TagType;
+    format?: Format | null;
+    icon?: string | null;
+    values: TagValueDetail[];
+}
+export interface AttributeDetail {
+    id: string;
+    name: string;
+    label?: string | null;
+    relevant: boolean;
+    sortable: boolean;
+    type: TagType;
+    format?: Format | null;
+    icon?: string | null;
+    value: string;
+}
+export interface OptionValueDetail {
+    optionId: string;
+    /** What a variant's `options` holds for this option when it has this value. */
+    optionValueId: string;
+    tagValueId: string;
+    /** The text of the value, in the language asked. */
+    tagValue: string;
+    position: number;
+}
+/** What a variant is chosen by (a colour, a size), with the values it can have. */
+export interface OptionDetail {
+    id: string;
+    name: string;
+    type: 'tagValue';
+    position: number;
+    values: OptionValueDetail[];
+}
+/**
+ * A discount by quantity: from `min` to `max` (`null`: with no end) of a variant bought, the price has `discountValue` (a percentage, for `discountType: "percentage"`) off. The catalog declares
+ * `quantityTable` as `any`; this shape is the one seen on a real catalog (`rounding` was `"00"` and `"99"`) and the one the v1 template uses. Only `percentage` has been seen as a `discountType`.
+ */
+export interface QuantityTier {
+    min: number;
+    max: number | null;
+    rounding: string;
+    discountType: string;
+    discountValue: number;
+}
+/** A price of a variant: the list price (`amount` is the net one) and what it is gross, with the tax rate of the visitor's country. */
+export interface PriceDetail {
+    id: string;
+    currencyCode: string;
+    cadence: string;
+    amount: number;
+    comparePrice: number;
+    isDefault?: boolean;
+    /** `null` when the price has no discounts by quantity (seen on a real catalog). */
+    quantityTable?: QuantityTier[] | null;
+    netAmount: number;
+    grossAmount: number;
+    rate: number;
+    netCompare: number;
+    grossCompare: number;
+}
+export interface VariantDetail {
+    id: string;
+    name: string;
+    slug: string;
+    isFavourite: boolean;
+    productId: string;
+    availability: Availability;
+    assets: AssetDetail[];
+    tags: TagDetail[];
+    attributes: AttributeDetail[];
+    quantity: number;
+    allowBackorder: boolean;
+    /** One for each currency and cadence (the lists have `priceRanges` instead). */
+    prices: PriceDetail[];
+    metadata: Record<string, unknown>;
+    inheritAssets: boolean;
+    inheritAttributes: boolean;
+    inheritTagValues: boolean;
+    sku?: string;
+    ean?: string;
+    mpn?: string;
+    upc?: string;
+    gtin?: string;
+    isbn?: string;
+    asin?: string;
+    hsCode?: string;
+    supplierCode?: string;
+    /** The value this variant has for each option of the product: the option's id → the value's `optionValueId`. */
+    options: Record<string, string>;
+}
+export interface ProductDetail {
+    id: string;
+    name?: string;
+    /** HTML. */
+    description?: string;
+    metadata: Record<string, unknown>;
+    assets: AssetDetail[];
+    tags: TagDetail[];
+    options: OptionDetail[];
+    attributes: AttributeDetail[];
+    reviews: ReviewStats;
+    /** All the visible variants. */
+    variants: VariantDetail[];
+}
+/** The answer of `POST /public/products/by-slug/{slug}` and `POST /public/products/{id}`, as the catalog sends it. */
+export interface ProductDetailResponse {
+    data: ProductDetail;
+}
+/** The store's own settings. What the server has not got comes with its default (`EUR`, `once`, `IT`, `default`, a list with the default one). */
+export interface StoreSettings {
+    defaultCurrencyCode: string;
+    defaultCadence: string;
+    defaultCountryCode: string;
+    /** What the store's default language is (`it`). To ask for it, a query says `default`, not this: see `ProductSearch.langCode`. `languages` are the OTHER languages the store has. */
+    defaultLangCode: string;
+    languages: string[];
+    currencies: string[];
+    cadences: string[];
+    /** The link to Stripe's customer portal, to manage a subscription: an empty text when the store has none. */
+    stripeCustomerPortalUrl: string;
+}
+export interface StoreTagValue {
+    id: string;
+    value: string;
+    alias: string | null;
+    position: number;
+    /** How many visible products have it. */
+    count: number;
+}
+/** The tags a customer can filter by (the visible and filterable ones), with their values in the language asked. */
+export interface StoreTag {
+    id: string;
+    name: string;
+    label: string | null;
+    type: TagType;
+    format: Format | null;
+    sortable: boolean;
+    relevant: boolean;
+    icon: string | null;
+    position: number;
+    values: StoreTagValue[];
+}
+/** The attributes products can be sorted by (the visible and sortable ones). */
+export interface StoreAttribute {
+    id: string;
+    name: string;
+    label: string | null;
+    type: TagType;
+    format: Format | null;
+    relevant: boolean;
+    sortable: boolean;
+    icon: string | null;
+    position: number | null;
+}
+/** A visible collection, with the visible ones inside it: a tree. `filterIds` are what the products of the collection are filtered by (they go in a search's `filterIds`). */
+export interface StoreCollection {
+    id: string;
+    name: string;
+    slug: string;
+    parentId?: string | null;
+    position: number | null;
+    visible: boolean;
+    filterIds: string[];
+    children: StoreCollection[];
+}
+export interface StoreFilterCondition {
+    id: string;
+    /** `range`, … */
+    operator: string;
+    min: number | null;
+    max: number | null;
+    /** `price`, `number`, `date`, or another. */
+    type: string | null;
+    attributeId: string | null;
+    attribute: {
+        id: string;
+        type: TagType;
+        name: string;
+        format: Format | null;
+    } | null;
+}
+/** The filters a customer can set: the visible ones that have a range condition (a price, a number, a date). */
+export interface StoreFilter {
+    id: string;
+    name: string;
+    operator: 'AND' | 'OR';
+    position: number | null;
+    visible: boolean;
+    conditionIds: string[];
+    type: 'price' | 'date' | 'number';
+    conditions: StoreFilterCondition[];
+}
+export interface StoreData {
+    store: StoreSettings;
+    tags: StoreTag[];
+    attributes: StoreAttribute[];
+    collections: StoreCollection[];
+    filters: StoreFilter[];
+}
+/** The answer of `GET /public/store_data`, as the catalog sends it. */
+export interface StoreDataResponse {
+    data: StoreData;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/catalog/types.js

@@ -0,0 +1,4 @@
+// What the catalog (`wr-commerce-catalog`) takes and answers, written from what its code does (ProductMapper), not from its OpenAPI document. Nothing here is a default of the server's:
+// what is not said is for the server to decide.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/checkout/api.d.ts

@@ -0,0 +1,14 @@
+import type { HttpClient } from '../http.js';
+import type { CallOptions } from '../catalog/types.js';
+import type { PayAnswer, PayInput, Quote, QuoteInput } from './types.js';
+export interface CheckoutApi {
+    /**
+     * `POST /v2/checkout/quote`: what the customer would pay for this cart, with the store's rules and hooks applied. It changes nothing in the store, so it can be asked as often as needed, and it is always asked
+     * again (availability and prices change). A refusal says why: `CHECKOUT_BLOCKED`, `CHECKOUT_HOOK_FAILED`, `SHIPPING_METHOD_UNAVAILABLE`, or an HTTP 400 for the cart itself (stock, quantities, delivery, the address).
+     */
+    quote(input: QuoteInput, options?: CallOptions): Promise<Quote>;
+    /** `POST /v2/checkout/stripe`: starts the payment. It reserves the stock and makes the order, so it is asked once; the answer is the payment page to send the customer to. Refuses what `quote` refuses. */
+    pay(input: PayInput, options?: CallOptions): Promise<PayAnswer>;
+}
+export declare function createCheckoutApi(http: HttpClient): CheckoutApi;
+//# sourceMappingURL=api.d.ts.map

package/dist/checkout/api.js

@@ -0,0 +1,7 @@
+export function createCheckoutApi(http) {
+    return {
+        quote: (input, options) => http.request({ method: 'POST', path: '/v2/checkout/quote', body: input, signal: options?.signal }),
+        pay: (input, options) => http.request({ method: 'POST', path: '/v2/checkout/stripe', body: input, signal: options?.signal }),
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/checkout/errors.d.ts

@@ -0,0 +1,23 @@
+import { CHECKOUT_ERROR_CODES, type CheckoutBlockTarget } from './types.js';
+export type CheckoutRefusal = {
+    code: typeof CHECKOUT_ERROR_CODES.blocked;
+    meta: {
+        hookId: string;
+        code: string;
+        target: CheckoutBlockTarget;
+    };
+} | {
+    code: typeof CHECKOUT_ERROR_CODES.hookFailed;
+    meta: {
+        hookId: string;
+        reason: string;
+    };
+} | {
+    code: typeof CHECKOUT_ERROR_CODES.shippingMethodUnavailable;
+    meta: {
+        shippingMethodId: string;
+    };
+};
+/** What the checkout refused with a code of its own (a hook stopped it, a hook failed, the shipping method is not available), or `null` for any other error. */
+export declare function checkoutRefusalOf(error: unknown): CheckoutRefusal | null;
+//# sourceMappingURL=errors.d.ts.map

package/dist/checkout/errors.js

@@ -0,0 +1,18 @@
+import { isCommerceError } from '../errors.js';
+import { CHECKOUT_ERROR_CODES } from './types.js';
+/** What the checkout refused with a code of its own (a hook stopped it, a hook failed, the shipping method is not available), or `null` for any other error. */
+export function checkoutRefusalOf(error) {
+    if (!isCommerceError(error))
+        return null;
+    switch (error.code) {
+        case CHECKOUT_ERROR_CODES.blocked:
+            return { code: CHECKOUT_ERROR_CODES.blocked, meta: error.meta };
+        case CHECKOUT_ERROR_CODES.hookFailed:
+            return { code: CHECKOUT_ERROR_CODES.hookFailed, meta: error.meta };
+        case CHECKOUT_ERROR_CODES.shippingMethodUnavailable:
+            return { code: CHECKOUT_ERROR_CODES.shippingMethodUnavailable, meta: error.meta };
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/checkout/index.d.ts

@@ -0,0 +1,10 @@
+export { createCheckoutApi } from './api.js';
+export type { CheckoutApi } from './api.js';
+export { checkoutRefusalOf } from './errors.js';
+export type { CheckoutRefusal } from './errors.js';
+export { browserReturnUrls } from './return-urls.js';
+export { createCheckoutStore } from './store.js';
+export type { CheckoutState, CheckoutStore, CheckoutStoreOptions } from './store.js';
+export { CHECKOUT_ERROR_CODES, DELIVERY_METHODS, PROMOTION_REJECTION_REASONS } from './types.js';
+export type { CheckoutAddress, CheckoutBlockTarget, DeliveryMethod, InvoiceInput, PayAnswer, PayInput, PromotionRejectionReason, Quote, QuoteDiscount, QuoteDiscountSource, QuoteDiscountTarget, QuoteInput, QuoteLine, QuoteLinePresentation, QuoteUnavailableLine, QuotePromotions, QuoteShippingOption, QuoteTotals, ReturnUrls, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/checkout/index.js

@@ -0,0 +1,6 @@
+export { createCheckoutApi } from './api.js';
+export { checkoutRefusalOf } from './errors.js';
+export { browserReturnUrls } from './return-urls.js';
+export { createCheckoutStore } from './store.js';
+export { CHECKOUT_ERROR_CODES, DELIVERY_METHODS, PROMOTION_REJECTION_REASONS } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/checkout/return-urls.d.ts

@@ -0,0 +1,7 @@
+import type { ReturnUrls } from './types.js';
+/**
+ * Where the customer comes back to when the site says nothing else: this page's own origin, the success page (`/checkout/success`, which empties the cart when it finds `clean_cart=true`) and the home page for giving
+ * up. The same the site's checkout has always sent. Without a page (a server) it says nothing, and the store's own pages are used. A site that wants others gives them to `pay` or to `createCommerce`.
+ */
+export declare function browserReturnUrls(): ReturnUrls;
+//# sourceMappingURL=return-urls.d.ts.map

package/dist/checkout/return-urls.js

@@ -0,0 +1,11 @@
+/**
+ * Where the customer comes back to when the site says nothing else: this page's own origin, the success page (`/checkout/success`, which empties the cart when it finds `clean_cart=true`) and the home page for giving
+ * up. The same the site's checkout has always sent. Without a page (a server) it says nothing, and the store's own pages are used. A site that wants others gives them to `pay` or to `createCommerce`.
+ */
+export function browserReturnUrls() {
+    const origin = globalThis.location?.origin;
+    if (!origin || origin === 'null')
+        return {};
+    return { successUrl: `${origin}/checkout/success?clean_cart=true`, cancelUrl: `${origin}/` };
+}
+//# sourceMappingURL=return-urls.js.map

package/dist/checkout/store.d.ts

@@ -0,0 +1,98 @@
+import { CommerceError } from '../errors.js';
+import type { CartLineInput } from '../cart/types.js';
+import type { CheckoutApi } from './api.js';
+import { type CheckoutAddress, type DeliveryMethod, type PayAnswer, type Quote, type ReturnUrls } from './types.js';
+export interface CheckoutState {
+    /** How each variant of the cart reaches the customer, by variant id. A variant with no choice here is asked to the store without one (and the store says so). */
+    deliveryMethods: Record<string, DeliveryMethod>;
+    shippingAddress: CheckoutAddress | null;
+    billingAddress: CheckoutAddress | null;
+    /** The shipping method chosen from the preview's options, or null. */
+    shippingMethodId: string | null;
+    promotionCodes: string[];
+    additionalData: Record<string, unknown> | null;
+    /** Who pays: for a guest, who the order is for. Not part of the preview. */
+    email: string;
+    requestsInvoice: boolean;
+    invoiceVatCode: string | null;
+    invoiceRecipientCode: string | null;
+    /** What the store said it costs, or null until it said. While `isStale`, it is the answer to something the customer has since changed. */
+    quote: Quote | null;
+    /** What the preview would ask NOW (the cart and the choices that matter to it): a change that leaves it as it was (the email, the invoice) does not make the preview out of date. */
+    requestKey: string;
+    /** What the preview on show was asked, or null. */
+    quotedKey: string | null;
+    /** `quote` is not the answer to what would be asked now. */
+    isStale: boolean;
+    /** How many lines the cart has (the preview asks nothing of an empty one). */
+    lineCount: number;
+    quoting: boolean;
+    paying: boolean;
+    /** Why the last preview failed (it goes when one works); an action's own failure is thrown, not kept. */
+    error: CommerceError | null;
+}
+export interface CheckoutStore {
+    getState(): CheckoutState;
+    subscribe(listener: () => void): () => void;
+    /** Starts following the cart: a change of its lines or of whose it is makes the preview out of date. Once. */
+    start(): void;
+    /** How this variant reaches the customer. */
+    setDeliveryMethod(variantId: string, method: DeliveryMethod): void;
+    setShippingAddress(address: CheckoutAddress | null): void;
+    setBillingAddress(address: CheckoutAddress | null): void;
+    /** The shipping method the customer chose (one of the preview's options), or null for none. */
+    selectShippingMethod(id: string | null): void;
+    setPromotionCodes(codes: readonly string[]): void;
+    setAdditionalData(data: Record<string, unknown> | null): void;
+    setEmail(email: string): void;
+    /** An invoice asked for or not, with the codes it needs. */
+    setInvoice(invoice: {
+        requested: boolean;
+        vatCode?: string | null;
+        recipientCode?: string | null;
+    }): void;
+    /**
+     * Asks the store what the cart costs with these choices, and keeps the answer in `state.quote`. Asked again while one is on its way, the first is cancelled (and throws `aborted`). Throws what the store refuses
+     * (see `checkoutRefusalOf`); the same refusal is left in `state.error`, and the last good preview stays on show as stale.
+     */
+    quote(options?: {
+        signal?: AbortSignal;
+    }): Promise<Quote>;
+    /**
+     * What a page does by itself when the cart or the choices change: asks the preview, unless the cart is empty or this very question was already asked (by anyone: a refusal is not asked again by itself, and
+     * any number of components can call this). Resolves `null` when it asked nothing; otherwise what `quote` does.
+     */
+    ensureQuote(): Promise<Quote | null>;
+    /**
+     * Starts the payment: the store reserves the stock, makes the order and gives the page to send the customer to (`url`). `returnUrls` says where they come back to (both or neither; the checkout's `returnUrls` option
+     * when not given). Asked once per order: it is not asked again by this store. Throws what the store refuses.
+     */
+    pay(returnUrls?: ReturnUrls): Promise<PayAnswer>;
+    /** Everything chosen and the preview, forgotten: the customer starts again. */
+    reset(): void;
+    /** The payment is done (the success page): the cart is emptied (a guest's here; a customer's was emptied by the store, and is read again) and the checkout is forgotten. */
+    complete(): Promise<void>;
+    /** Stops following the cart. */
+    dispose(): void;
+}
+export interface CheckoutStoreOptions {
+    api: CheckoutApi;
+    /** The cart the checkout is for: only what is needed to follow it. */
+    cart: {
+        getState(): {
+            owner: string;
+            lines: CartLineInput[];
+        };
+        subscribe(listener: () => void): () => void;
+    };
+    /** Webround Commerce's id of this cart: the same for a guest and for the customer they become. */
+    trackingId: () => string;
+    /** The language the store answers in: read at each call (`default` when there is none). */
+    langCode?: () => string | undefined;
+    /** Where the customer comes back to after paying: read when `pay` is not given any. Nothing = the store's own pages. */
+    returnUrls?: () => ReturnUrls | undefined;
+    /** Empties the cart (`complete`). */
+    clearCart: () => Promise<void>;
+}
+export declare function createCheckoutStore(options: CheckoutStoreOptions): CheckoutStore;
+//# sourceMappingURL=store.d.ts.map