@estoreclub/api 0.0.0-stage → 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,2123 @@
+/**
+ * What the public API answers with.
+ *
+ * These mirror the server's DTOs (`companyResponse.dto.ts`,
+ * `productCategoryWithTranslations.dto.ts`, `productWithTranslations.dto.ts`) and stop at the
+ * fields a site actually renders. Optional means the API marks it optional — a product with
+ * no price or no photo is ordinary, and the caller has to handle it.
+ */
+/**
+ * Which dataset version a record belongs to, as the API reports it (`PublicCart.workspace`).
+ *
+ * The public API serves only `production`, what visitors see, so no client asks for one: there
+ * is no workspace parameter to send.
+ */
+export type Workspace = "production" | "sandbox";
+export interface PublicLanguage {
+    code: string;
+    codeLocal: string;
+    name: string;
+}
+/**
+ * The shop's terms and privacy policy, for a customer asked to accept them (`getTerms`).
+ */
+export interface PublicTerms {
+    /**
+     * Whether customers must accept them (the shop's Terms & privacy rule). While true, a
+     * signed-in customer who has not accepted cannot order or book (`customer_terms_required`)
+     * until they do - `updateCustomerProfile({ acceptTerms: true })`.
+     */
+    required: boolean;
+    /**
+     * The text the shop wrote, Markdown, in the visitor's language - else the shop's default
+     * language's. Null: none written; link `termsUrl` / `privacyUrl` instead. Render it as
+     * Markdown WITHOUT raw HTML.
+     */
+    markdown: string | null;
+    /** The language `markdown` is in; null with it. */
+    language: string | null;
+    /** When the text last changed (ISO); null with it. */
+    updatedAt: string | null;
+    /** The shop's terms address; empty: the site's own `/terms` page, or `markdown` in place. */
+    termsUrl: string;
+    /** The shop's privacy policy address; empty: the site's `/privacy`, or `markdown` in place. */
+    privacyUrl: string;
+}
+/**
+ * One of the shop's physical locations — a restaurant, a pickup point — for a "find us" section
+ * or a map. The address is the one Google verified when the shop entered it, so `latitude` /
+ * `longitude` and `placeId` always describe the same place as `address`.
+ */
+export interface PublicStoreLocation {
+    id: string;
+    /**
+     * The shop's own number for the location (`2`). Use it in your site's addresses
+     * (`/book?location=2`) - every `locationId` the API takes accepts it as well as `id`.
+     */
+    number: number;
+    name: string;
+    /** Free text the shop wrote: how to find the entrance, parking. Empty when none. */
+    description: string;
+    /** ISO 3166-1 alpha-2, e.g. `"NZ"`. Null on a location saved before countries were asked. */
+    countryCode: string | null;
+    /** The city, as Google names it — e.g. `"Auckland"`. */
+    city: string | null;
+    cityPlaceId: string | null;
+    /** Postcode, e.g. `"1011"`. Null when none was given. */
+    postalCode: string | null;
+    /** As the shop writes it, e.g. `"+64 9 123 4567"` — for a `tel:` link, strip the spaces. */
+    phone: string | null;
+    /** The location's own contact address — for a `mailto:` link. */
+    email: string | null;
+    /**
+     * When it is open, sorted by day: ISO weekday (1 = Monday … 7 = Sunday) and `HH:MM` times on
+     * the shop's clock; an `until` not after `from` runs past midnight. A weekday with no range is
+     * CLOSED. `null` means the shop gave no hours — print nothing rather than "closed".
+     */
+    workingHours: Array<{
+        day: number;
+        from: string;
+        until: string;
+    }> | null;
+    /**
+     * The street part only — "120 Ponsonby Road, Grey Lynn". The city and country are `city` and
+     * `countryCode`; print them after it for a full line.
+     */
+    address: string;
+    /** Google Place ID — for a "directions" link: `https://www.google.com/maps/place/?q=place_id:<placeId>`. */
+    placeId: string;
+    latitude: number;
+    longitude: number;
+    /** Its pictures, in the shop's order — the first is the one to show in a list. */
+    images: Array<{
+        mediaId: string;
+        url: string;
+        isExternal: boolean;
+    }>;
+    /**
+     * The days ahead (90) on which other hours hold than `workingHours` — Christmas closed, a late
+     * New Year's Eve — the location's own over the shop's, by date. `kind: "hours"` replaces that
+     * day's opening hours, `"delivery"` its delivery hours; `hours` empty is CLOSED. Orders,
+     * pickup, delivery and bookings already follow them: these are for the page to SHOW ("Closed
+     * on 25 December"), and for "open now" on such a day, read them before `workingHours`.
+     */
+    specialDays: Array<{
+        date: string;
+        kind: "hours" | "delivery";
+        hours: Array<{
+            from: string;
+            until: string;
+        }>;
+        note: string;
+    }>;
+}
+/**
+ * What the platform knows of a picture the site holds only as a URL — see `lookupImages`. The
+ * fields `Image` from `@estoreclub/client` draws a `srcset` from.
+ */
+export interface PublicImage {
+    url: string;
+    width: number | null;
+    height: number | null;
+    /** Widths (px) of the resized WebP copies stored beside it, as `<name>@<width>.webp`. */
+    variants: number[];
+}
+export interface PublicMedia {
+    id: string;
+    url: string;
+    type: string;
+    description?: string;
+    /** The original's size in pixels. Set once the resized copies are made; absent until then. */
+    width?: number | null;
+    height?: number | null;
+    /**
+     * Widths (px) of the resized WebP copies stored beside the original as
+     * `<name>@<width>.webp`. Empty until they are made, and always for external or SVG media —
+     * render it with `Image` from `@estoreclub/client`, which falls back to `url`.
+     */
+    variants?: number[] | null;
+}
+/** A company, as `GET public/company` returns it. The API never includes its key. */
+/** Which side of the amount a currency's symbol sits on. */
+export type CurrencySymbolPosition = "prefix" | "suffix";
+export interface PublicCompany {
+    name: string;
+    defaultLanguage: string;
+    /** ISO 4217 code every product of this company is priced in. */
+    defaultCurrency?: string;
+    /** ISO 3166-1 alpha-2 country the shop trades in, null until it is set. */
+    countryCode?: string | null;
+    /** "₽", "$", or the code itself where a currency has no distinct sign. */
+    currencySymbol?: string;
+    /** Where that symbol goes. See `PublicSiteInfo.currencySymbolPosition`. */
+    currencySymbolPosition?: CurrencySymbolPosition;
+    /** Sales tax rate in percent; 0 for none. */
+    taxRate?: number;
+    /** Whether product prices already include the tax. */
+    taxInclusive?: boolean;
+    /** What the tax is called where the shop trades — GST, VAT, Sales tax. */
+    taxName?: string;
+    /** Whether an order names its location: never asked, the customer's choice, or a must. */
+    orderLocation?: OrderLocationMode;
+    /** How customers may receive an order, in the order offered. */
+    orderTypes?: OrderType[];
+    /** How bookings run: `off` (none), a whole table, seats at a shared table, or a time only. */
+    reservationMode?: "off" | "table" | "seat" | "time";
+    /** What a guest may book, the main way first - see `SiteInfo.reservationKinds`. */
+    reservationKinds?: ReservationKind[];
+    /** The ways visitors may sign in - signing in is always offered. */
+    customerSignInMethods?: {
+        email: boolean;
+        google: boolean;
+        apple?: boolean;
+    };
+    /** Who sees the site: everybody, or signed-in customers only. */
+    customerAccess?: CustomerAccess;
+    /** Only a signed-in customer may book a table online. */
+    reservationRequiresSignIn?: boolean;
+    /** What a reservation may be booked for - see `PublicSiteInfo.reservationOrder`. */
+    reservationOrder?: "off" | "any" | "list";
+    /** How a booking may be paid when it is made - see `PublicSiteInfo.reservationPayment`. */
+    reservationPayment?: PublicReservationPayment;
+    /** Only a signed-in customer may order online. */
+    orderRequiresSignIn?: boolean;
+    /** A guest may track a delivered order by its tracking number and email. */
+    publicOrderTracking?: boolean;
+    /** Money off for paying one way — see `PublicSiteInfo`. */
+    paymentDiscounts?: PublicPaymentDiscounts;
+    /** The Google client id for the site's Google sign-in button. */
+    googleClientId?: string | null;
+    /** The platform's Google sign-in page, opened in a popup — see `PublicSiteInfo`. */
+    googleSignInUrl?: string | null;
+    /** The Apple Services ID for the site's Apple sign-in — see `PublicSiteInfo`. */
+    appleClientId?: string | null;
+    /** The platform's Apple sign-in page, opened in a popup — see `PublicSiteInfo`. */
+    appleSignInUrl?: string | null;
+    settings?: Record<string, string>;
+    languages: PublicLanguage[];
+}
+/** The company as a *site*: the shape a page asks for by `getSiteInfo()`. */
+export interface PublicSiteInfo {
+    siteName: string;
+    defaultLanguage: string;
+    languages: PublicLanguage[];
+    /**
+     * ISO 4217, the code every price on this site is in.
+     *
+     * A product carries an amount and no currency — the company's is the currency — so a page
+     * showing a price without this one is guessing, and the guess is always "$".
+     */
+    currency?: string;
+    /**
+     * ISO 3166-1 alpha-2 country the shop trades in ("NZ"), null until it is set. A visitor from
+     * there reads the shop's own dollar as a bare "$"; anyone else is told whose dollar it is
+     * ("NZ$1.10"), and a dollar not the shop's always carries its code ("USD$1.10").
+     */
+    countryCode?: string | null;
+    /**
+     * The country the visitor reading this page is in ("NZ"), from their request - null when it
+     * is not known (a static build, a browser that names no region). With `countryCode`: a visitor
+     * at home reads the shop's dollar as "$1.10", anyone else "NZ$1.10".
+     */
+    visitorCountry?: string | null;
+    /** The sign to print beside an amount: "₽", "$", or the code where there is no sign. */
+    currencySymbol?: string;
+    /**
+     * Which side of the number that sign goes on, and it is a property of the CURRENCY rather
+     * than of the reader: the ruble trails ("1 000 ₽") and the dollar leads ("$1,000") whatever
+     * language the page is written in. `Intl` answers the other question — how an ENGLISH page
+     * writes a ruble — which is why this comes from the server instead.
+     *
+     * A trailing symbol is written with a space before it, a leading one without.
+     */
+    currencySymbolPosition?: CurrencySymbolPosition;
+    /**
+     * The sales tax rate in percent (0: none), and whether the prices on this site already
+     * include it — for "Prices include 15% GST" on a page, before anything is in a basket.
+     */
+    taxRate?: number;
+    taxInclusive?: boolean;
+    /** What the tax is called where the shop trades — GST, VAT, Sales tax. */
+    taxName?: string;
+    /**
+     * Whether to ask which location an order is for (`getLocations`): `never` - show no picker
+     * (a `locationId` sent anyway is not kept); `optional` - offer one; `required` - ask first:
+     * `createCheckout` without a `locationId` is refused.
+     */
+    orderLocation: OrderLocationMode;
+    /**
+     * How customers may receive an order, in the order the shop offers them: `pickup` (takeaway),
+     * `reservation` and/or `delivery`. The hosted payment page asks when there is more than one (and,
+     * for delivery, takes the address and adds the fee); a page may also ask in the cart and pass
+     * the choice as `createCheckout({ orderType })`.
+     */
+    orderTypes: OrderType[];
+    /**
+     * How guests book online (`getBookingSlots`, `createBooking`): `off` - no booking, hide any
+     * "Book" link; `table` a whole table; `seat` seats at a shared table; `time` a time only (no
+     * table, no plan).
+     */
+    reservationMode?: "off" | "table" | "seat" | "time";
+    /**
+     * What a guest may book - `table`, `list` (an entry of the shop's list: a specialist, a room),
+     * `time` alone - the shop's main way first, the one `reservationMode` describes. With more than
+     * one, let the guest pick and pass it as `kind` to `getBookingSlots`, `getBookingPlan` and
+     * `createBooking`. Empty while reservations are off.
+     */
+    reservationKinds: ReservationKind[];
+    /**
+     * @deprecated `reservationMode !== "off"` - worked out here for sites written before; the
+     * server no longer sends it.
+     */
+    tableReservations?: boolean;
+    /**
+     * @deprecated Always true: signing in is always offered (`customerSignInMethods` says how).
+     * Kept for sites written before; the server no longer sends it.
+     */
+    customerSignIn?: boolean;
+    /**
+     * Which ways to offer: `email` (`requestSignInCode` +
+     * `verifySignInCode`), `google` (`signInWithGoogle`) and `apple` (`signInWithApple`). A way
+     * that is off is refused.
+     */
+    customerSignInMethods: {
+        email: boolean;
+        google: boolean;
+        apple: boolean;
+    };
+    /**
+     * Who sees the site. `public`: everybody. `signed_in`: signed-in customers only - the
+     * catalogue, cart, checkout and bookings refuse a guest (`PublicApiError` 401, code
+     * `customer_sign_in_required`), so show the sign-in instead of the menu.
+     */
+    customerAccess: CustomerAccess;
+    /**
+     * Only a signed-in customer may book a table: `createBooking` rejects a guest (401). Ask them
+     * to sign in before the booking form.
+     */
+    reservationRequiresSignIn: boolean;
+    /**
+     * What a reservation may be booked for: `off` nothing; `any` any product; `list` only the
+     * products the booked entry allows (each entry `getBookingSlots` offers lists its
+     * `productIds`).
+     *
+     * The booking window, the per-customer limit, a payment due at booking and the cancellation
+     * notice are the server's to apply and are not published here: `getBookingSlots` marks times
+     * outside the window unavailable and says `cancelHours`; `createBooking` refuses what the
+     * rules refuse (and answers `pending` with `payment` when the booking is paid for up front);
+     * each of the customer's bookings says `cancellableUntil`.
+     */
+    reservationOrder?: "off" | "any" | "list";
+    /**
+     * How a booking's order may be paid when it is made: `order` - charged at once; `deferred` -
+     * the card held and charged when the shop accepts the booking. Both: let the guest choose and
+     * send it as `payment` to `createBooking`. Neither: paid at the visit.
+     */
+    reservationPayment: PublicReservationPayment;
+    /**
+     * Only a signed-in customer may order: `createCheckout` rejects a guest (401, "Sign in to place
+     * an order"). Sign them in when they go to pay, then check out.
+     */
+    orderRequiresSignIn: boolean;
+    /**
+     * A guest may follow a delivered order on the tracking page: `trackOrder({ code, email })` -
+     * the delivery's tracking number (`K7P-QX9-M2T`, in the order's emails) and the order's email.
+     * False: offer signing in instead (the account lists every order); `trackOrder` by number
+     * refuses.
+     */
+    publicOrderTracking: boolean;
+    /**
+     * Money off for paying one way — `online` by card at checkout, `inStore` at the counter — or
+     * null for none. For the basket to SAY ("Save 10% paying online"): the customer chooses how to
+     * pay on the checkout page, which takes it off then; the basket's own total is before it.
+     */
+    paymentDiscounts: PublicPaymentDiscounts;
+    /**
+     * The client id to render Google's sign-in button with (Google Identity Services). Null: Google
+     * sign-in is not configured on the platform — offer no Google button.
+     */
+    googleClientId: string | null;
+    /**
+     * The platform's Google sign-in page. A site opens it in a popup (`?origin=<site origin>`) and
+     * receives `{ type: "salespoint:google-credential", credential }` by `postMessage` — Google's
+     * button is drawn there, on the one origin registered with Google, not on every site's. Null:
+     * offer no Google button.
+     */
+    googleSignInUrl: string | null;
+    /**
+     * The Apple Services ID the platform's Apple sign-in page signs in with. Null: Apple sign-in is
+     * not configured on the platform — offer no Apple button.
+     */
+    appleClientId: string | null;
+    /**
+     * The platform's Apple sign-in page. A site opens it in a popup (`?origin=<site origin>`, and
+     * `client=<appleClientId>`) and receives `{ type: "salespoint:apple-credential", credential,
+     * name }` by `postMessage` — pass both to `signInWithApple`. `name` is "First Last" on the
+     * first sign-in only (Apple sends it once), else null. Null: offer no Apple button.
+     */
+    appleSignInUrl: string | null;
+    settings?: Record<string, string>;
+}
+/**
+ * A category. Only active ones are ever returned, so there is no `status`; the list comes
+ * back already in the author's order, so there is no `order` either.
+ *
+ * The optional parts are there only when asked for through `include` — which this client
+ * does by default, see `PublicCategoryInclude`.
+ */
+export interface PublicCategory {
+    id: string;
+    name: string;
+    /**
+     * The name the shop gave it, untranslated - the same in every language (`name` is in the
+     * page's). For links and anchors that must not change with the language. Absent from an
+     * API older than it.
+     */
+    canonicalName?: string;
+    description?: string;
+    /** The parent category's id, or `null` for a root. A shop may have several roots. */
+    parentId: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    /** With `include: ["media"]`. */
+    media?: PublicMedia[];
+    /** With `include: ["count"]`: active products linked to this category. */
+    productCount?: number;
+    /** With `include: ["count"]`: active products here AND in every category beneath it. */
+    descendantProductCount?: number;
+    /** With `include: ["translations"]`: every enabled language, then field name. */
+    translations?: Record<string, Record<string, string>>;
+}
+/** One way a product is sold — see `PublicProduct.variants`. */
+export interface PublicProductVariant {
+    id: string;
+    /** In the request language, falling back to the base name; `""` when the shop gave none. */
+    name: string;
+    /** What this variant costs: its own price, or the product's where it has none. A number, as
+     *  `PublicProduct.price` is — this client converts it the same way. */
+    price?: number;
+    /** Whether it can be bought now. Show an unavailable one as sold out rather than hiding it. */
+    isAvailable: boolean;
+    order: number;
+    /** The variant's own first image, when it has one; otherwise use the product's. */
+    image?: string;
+    /** The variant-scoped settings, described like the product's: the variant's own value, or
+     *  the product's where the variant has none. */
+    settings: Record<string, PublicProductSetting>;
+}
+/**
+ * The optional parts of a category. `count` is `productCount` + `descendantProductCount`.
+ *
+ * The API returns none of them unless asked. This client asks for ALL of them when a caller
+ * passes no `include`, so a page written before `include` existed renders as it did; pass a
+ * narrower list (or `[]`) to trim the response.
+ */
+export type PublicCategoryInclude = "translations" | "media" | "count";
+export interface PublicProductCategoryRef {
+    id: string;
+    name?: string;
+}
+/** What kind of value a product setting holds — and so, how a page renders it. */
+export type PublicProductSettingType = "text" | "richtext" | "boolean" | "number" | "range"
+/** A day, `"YYYY-MM-DD"`. */
+ | "date" | "dictionary" | "dictionary_multi";
+/** A `range` value: where the product sits, and the scale it sits on. */
+export interface PublicProductSettingRange {
+    value: number;
+    max: number;
+}
+/**
+ * One of a product's settings, described.
+ *
+ * The API used to answer a bare `{ KEY: value }` bag, which left a page guessing at all
+ * three things it needs: a `4` could be a count, a rating out of five or a number of
+ * minutes; a `"Large"` could be free text or one entry of a list the shop curates; and an
+ * absent key could mean "this shop does not use the field" or "nobody filled it in". None of
+ * those is answerable from a value, and a page cannot ask the catalogue — `getProductSettings`
+ * describes the SHOP, not this product.
+ */
+export interface PublicProductSetting {
+    type: PublicProductSettingType;
+    /**
+     * What the product holds, or `""` when it holds nothing. The key is still there: a shop
+     * that shows a field nobody filled in renders differently from a shop without the field.
+     *
+     * `range` answers `{ value, max }`; `dictionary_multi` answers the entry NAMES, not ids.
+     */
+    value: string | number | boolean | string[] | PublicProductSettingRange | "";
+    /**
+     * `dictionary_multi` only: the entries of `value` the customer may not take off the product -
+     * an ingredient the dish is not made without. NAMES, as `value` holds them; absent when none.
+     * Show them kept and do not offer to leave them off: a line leaving one off is refused.
+     */
+    required?: string[];
+    /** The list the value is an entry of, as the shop writes it. Only on the two `dictionary`
+     *  types — it is what tells one shop's "Size" (pizza sizes) from another's (bottle sizes).
+     *  This is the one to PRINT; it is translated and reworded, so fetch with `listIdentifier`. */
+    listName?: string;
+    /**
+     * The same list by identifier — what to FETCH it with:
+     * `getDictionary({ identifier: setting.listIdentifier })`.
+     *
+     * The handle the shop gave the list. Unlike the name it does not move, so a page that reads
+     * a product's sizes or add-ons through it keeps working when the shop retitles the list or
+     * translates it. Absent on a list the shop has not given one, and on a list the shop keeps
+     * private (not "Visible on site") - there is nothing a page could fetch with it.
+     */
+    listIdentifier?: string;
+}
+/**
+ * One setting as the SHOP has it — the catalogue, not a product's value.
+ *
+ * `getProductSettings()` answers a list of these: what fields this shop keeps on its
+ * products, what kind of value each holds, and which of them it actually shows. A page uses
+ * it to lay out a form or a spec table before it has a product in hand; for one product's
+ * values, read `PublicProduct.settings`, which describes the same keys with values attached.
+ *
+ * Only the fields the shop has switched on AND lets websites read are listed. A disabled or
+ * private field (a SKU, a bar code, a cost) is not here, and its values never appear on a product.
+ */
+export interface PublicProductSettingDefinition {
+    /** What the value is stored under — `IS_VEGETARIAN`, `SIZE`, `CUSTOM_ROAST`. */
+    key: string;
+    /** What to call it on the page — "Size", "Calories per serving (kcal)". */
+    label?: string;
+    type: PublicProductSettingType;
+    /** Section it is listed under, when the shop said. */
+    groupKey?: string;
+    /** Unit shown after the value, e.g. "g". Never on the list types. */
+    suffix?: string;
+    /** The list it draws from, on the two `dictionary` types. */
+    dictionaryId?: string;
+    /** What that list is called. Absent on a list nobody has named. */
+    listName?: string;
+    /** Top of the scale, on `range` only. */
+    rangeMax?: number;
+}
+export interface PublicProduct {
+    id: string;
+    /**
+     * The shop's own number for the product - link it as its key, `PR-12`
+     * (`/menu/PR-12`); `getProduct({ name: "PR-12" })` finds it by that key.
+     */
+    productNumber: number;
+    name: string;
+    description?: string;
+    story?: string;
+    /**
+     * Always a number here, and worth knowing why that is not free: the API answers with a
+     * STRING (`"13.00"`), because the column is a Postgres decimal. `@estoreclub/api` converts it
+     * so this type is true — anything reading the endpoint directly must do the same.
+     */
+    price?: number;
+    /** The product's type, or `null` for a flexible product. */
+    schemaId?: string | null;
+    /** A product or a service: chosen when the shop sells both, else the one kind it sells. */
+    kind?: "product" | "service";
+    createdAt?: string;
+    /** With `include: ["media"]`. */
+    media?: PublicMedia[];
+    /**
+     * True when the shop stops selling at zero (its sales rules) and this product has none left.
+     * Absent otherwise — including for a product nobody counts. Show it as sold out: adding it to
+     * a basket is refused.
+     */
+    soldOut?: boolean;
+    /**
+     * What customers' stars come to: the average (one decimal), how many rated, and the top of
+     * the scale. Only while the shop has customers vote with stars, and only once somebody has.
+     */
+    customerRating?: {
+        average: number;
+        count: number;
+        max: number;
+    };
+    /**
+     * What customers' likes come to: how many liked it and how many disliked it. Only while the
+     * shop has customers vote with likes (`dislikes` is 0 where it takes likes only), and only once
+     * somebody has.
+     */
+    customerLikes?: {
+        likes: number;
+        dislikes: number;
+    };
+    /**
+     * Where it stands among the shop's best sellers: 1 for the most units sold in paid,
+     * non-cancelled orders over the last 30 days, 2 for the next (ties share a rank) - the SALES
+     * rank; `sortBy: "popularity"` leads with ratings and only then follows it. A rank, never the
+     * units. Absent for a product that sold nothing in that time.
+     */
+    popularRank?: number;
+    /** With `include: ["categories"]`. Active categories only. */
+    categories?: PublicProductCategoryRef[];
+    /** With `include: ["settings"]`. Every setting the shop shows, described — see
+     *  `PublicProductSetting`. Keys the company has switched off are absent, even where the
+     *  product's type lists them; keys this product has not filled in carry an empty value. */
+    settings?: Record<string, PublicProductSetting>;
+    /** With `include: ["translations"]`: every enabled language, then field name. */
+    translations?: Record<string, Record<string, string>>;
+    /**
+     * The product's variants — its sizes, crusts, volumes — in the shop's order. Present with
+     * `include: ["settings"]`, and only on a product that has any.
+     *
+     * A product WITH variants is bought as one of them: `addCartItem` needs the variant's `id`
+     * as `variantId`, and the cart and checkout then charge that variant's price and discount.
+     */
+    variants?: PublicProductVariant[];
+}
+/**
+ * The optional parts of a product in a LISTING. Only active products are returned, so there
+ * is no `status`.
+ *
+ * As with categories, the API returns none unless asked and this client asks for all of them
+ * when a caller passes no `include`. `settings` is by far the largest part — a page that only
+ * shows names and prices should leave it out.
+ *
+ * One product read by id or name (`getProduct`) always carries everything.
+ */
+export type PublicProductInclude = "translations" | "media" | "categories" | "settings";
+/** One field every entry of a list carries, so a page knows how to read the values. */
+/** What a list column holds. `entry` is the id of an entry of another list. */
+export type PublicDictionaryColumnType = "text" | "number" | "money" | "date" | "translated_text" | "product" | "category" | "image" | "boolean" | "entry";
+export interface PublicDictionaryColumn {
+    key: string;
+    label?: string;
+    type: PublicDictionaryColumnType;
+    /** For `entry`: the list the ids belong to - `getDictionary({ id })` names them. */
+    referenceDictionaryId?: string;
+    /**
+     * Several values of the type: the value is an array (several numbers, images, entry ids).
+     * Never for `boolean` or `translated_text`.
+     */
+    multiple?: boolean;
+}
+export interface PublicDictionaryEntry {
+    id: string;
+    /** Resolved to the language the site is read in. */
+    name: string;
+    /**
+     * Column values by key. A `money` column is a signed number of the shop's currency; a
+     * `multiple` column's value is an array of its type's values.
+     */
+    values: Record<string, string | number | boolean | string[] | number[]>;
+}
+/**
+ * A list the shop keeps — its sizes, its add-ons, what its kitchen cooks with.
+ *
+ * The other half of `product.settings`: a product says WHICH size it is and which add-ons it
+ * offers, this says what the shop's sizes and add-ons ARE — every entry, and the columns they
+ * carry. An add-on's surcharge lives on the entry, so a page pricing "large with extra
+ * mozzarella" needs both halves and only one of them rides on a product.
+ */
+export interface PublicDictionary {
+    id: string;
+    /**
+     * The shop's own machine name for the list — `add_ons`, `pizza_sizes`. Set once and never
+     * changed, which is why a page should read by it rather than by the label.
+     */
+    identifier?: string;
+    /** What the shop calls it, in the language asked for. */
+    label: string;
+    description?: string;
+    columns: PublicDictionaryColumn[];
+    entries: PublicDictionaryEntry[];
+}
+/**
+ * A list without its entries — what `listDictionaries()` answers. Only the lists the shop
+ * marked "Visible on site", and only their public columns.
+ */
+export type PublicDictionarySummary = Omit<PublicDictionary, "entries">;
+/**
+ * How a single read names its row: by `id`, or by what it is called. Exactly one — the
+ * client refuses both or neither before anything leaves the process.
+ */
+export type ByIdOrName = {
+    /** The row's id (a UUID), e.g. from a listing. */
+    id: string;
+    name?: never;
+} | {
+    /**
+     * What it is called. Matched case-insensitively on the trimmed text, so a page need
+     * not reproduce the shop's capitalisation.
+     */
+    name: string;
+    id?: never;
+};
+/**
+ * A list by IDENTIFIER, by id, or by its label. Exactly one.
+ *
+ * `identifier` is the one to write a page against: the shop sets it once and it never changes.
+ * The label — `"Add-ons"`, `"Pizza sizes"` — still works and survives a retitling in another
+ * case, but it is translated and reworded, and a page reading by it breaks the day the shop
+ * tidies it up.
+ */
+export type GetDictionaryParams = {
+    /** The shop's machine name for the list, e.g. `"add_ons"`. */
+    identifier: string;
+    id?: never;
+    name?: never;
+} | (ByIdOrName & {
+    identifier?: never;
+});
+/** Products are paginated; categories are not. The asymmetry is the API's, not ours. */
+export interface PaginationMetadata {
+    page: number;
+    limit: number;
+    hasNext: boolean;
+}
+export interface Paginated<T> {
+    data: T[];
+    pagination: PaginationMetadata;
+}
+export interface ListCategoriesParams {
+    search?: string;
+    /** Optional parts to include. Omitted → all of them; `[]` → none. */
+    include?: PublicCategoryInclude[];
+    /**
+     * At most this many.
+     *
+     * Applied HERE, not by the server: the categories route takes no paging, while the
+     * products one does. Callers write the two calls side by side and reasonably expect the
+     * same parameter to mean something in both, so it is honoured rather than ignored — a
+     * category list is tens of rows, so trimming the answer costs nothing.
+     */
+    limit?: number;
+}
+/**
+ * One category by `id`, or by what it is called — `"Wood-fired"`.
+ *
+ * A name is matched case-insensitively on the trimmed text, against the category's own name
+ * and its translations, so a page read in German may ask for the German heading. Names are
+ * not unique: where several match, the oldest is returned.
+ */
+export type GetCategoryParams = ByIdOrName & {
+    /** Optional parts to include. Omitted → all of them; `[]` → none. */
+    include?: PublicCategoryInclude[];
+};
+/** One product by `id`, or by what it is called — matched the way a category's name is. */
+export type GetProductParams = ByIdOrName;
+export interface ListProductsParams {
+    /** A category UUID. Mutually exclusive with `categoryName`. */
+    categoryId?: string;
+    /** A category slug. The API's own spelling for what a page may call `categoryUniqueName`. */
+    categoryName?: string;
+    /** Only products filed under no category at all. */
+    categoryEmpty?: boolean;
+    search?: string;
+    /** 1-indexed, as the API counts. */
+    page?: number;
+    limit?: number;
+    tags?: string;
+    /**
+     * How the list is ordered. `custom` — the shop's own arrangement — is the default.
+     *
+     * `popularity` puts RATED products first, best rated first: by the customers' votes while the
+     * shop takes them (stars as the average over the scale, likes as the share of likes; with `up`
+     * voting, liked products first), else by the shop's own RATING setting over its scale. Equal
+     * ratings and unrated products then follow by units sold in paid, non-cancelled orders over the
+     * last `popularityDays`.
+     *
+     * `discount` puts the biggest discount on RIGHT NOW first: what comes off one unit of the
+     * product's own price - its DISCOUNT_RULE while that rule applies, else its DISCOUNT setting -
+     * the biggest percentage first, then the most saved. Products with no discount come last.
+     *
+     * Every order breaks ties by the shop's arrangement, so a shop with no ratings, sales or deals
+     * yet gets its own order back.
+     */
+    sortBy?: ProductSort;
+    /**
+     * Defaults to `DESC` for `popularity` and `discount` (the most of it first) and `ASC` for
+     * everything else. Unrated (popularity) and undiscounted (discount) products stay last either
+     * way.
+     */
+    sortOrder?: "ASC" | "DESC";
+    /** How many days back `popularity` counts sales over: 1–365, 30 when omitted. */
+    popularityDays?: number;
+    /** Optional parts to include. Omitted → all of them; `[]` → none. */
+    include?: PublicProductInclude[];
+}
+/**
+ * When a deal is on, on the shop's clock. A deal with no schedule is on at every hour of the
+ * days it is valid.
+ */
+export interface PublicDealSchedule {
+    /** IANA zone the windows are read in, e.g. `"Pacific/Auckland"`. */
+    timeZone: string;
+    windows: Array<{
+        /** ISO weekdays, 1 = Monday … 7 = Sunday. */
+        days: number[];
+        /** `HH:MM`, inclusive. */
+        from: string;
+        /** `HH:MM`, exclusive. Not after `from`: runs past midnight. */
+        until: string;
+    }>;
+}
+/**
+ * How a combo's `price` is read:
+ *
+ * - `fixed_price`: the combo costs `price`, plus each pick's `surcharge`.
+ * - `percent_off`: the picks at their own prices, `price`% off.
+ * - `amount_off`: the picks at their own prices, `price` off — never below zero.
+ */
+export type ComboPriceKind = "fixed_price" | "percent_off" | "amount_off";
+/** A product variant a combo option may be filled with — when the option leaves it open. */
+export interface PublicComboVariant {
+    id: string;
+    name: string;
+    /** False for a variant not on sale now: show it, but do not let it be picked. */
+    isAvailable: boolean;
+}
+/** One product that may fill a slot. */
+export interface PublicComboSlotOption {
+    productId: string;
+    name: string;
+    /** The one variant this option offers, or null for "any of the product's variants". */
+    variantId: string | null;
+    variantName: string | null;
+    /** When `variantId` is null and the product has variants: the ones to choose from. */
+    variants?: PublicComboVariant[];
+    /** Added to a `fixed_price` combo for this pick, in major units. */
+    surcharge: number;
+}
+/** A place in the combo — "a pizza", "two drinks" — and what may fill it. */
+export interface PublicComboSlot {
+    id: string;
+    name: string;
+    /** How many picks the slot takes. */
+    quantity: number;
+    options: PublicComboSlotOption[];
+}
+/**
+ * A combo on sale now: slots the shopper fills from a list of products, at a price.
+ *
+ * Only combos that are active, inside their dates and inside a weekly window AT THE MOMENT OF
+ * THE REQUEST are listed, and one with a slot no product on sale can fill is left out — so a
+ * page can show everything it is given. Add one to the cart with `addCartItem({ comboId,
+ * picks })`.
+ */
+export interface PublicCombo {
+    id: string;
+    name: string;
+    description?: string;
+    priceKind: ComboPriceKind;
+    /** Read by `priceKind`: the price before surcharges, the percentage off, or the amount off. */
+    price: number;
+    /** The cheapest way to fill it, in major units — for "from 9.90" on a menu. */
+    fromPrice: number;
+    /** ISO timestamp it stops being sold, or null when open-ended. */
+    validUntil: string | null;
+    schedule: PublicDealSchedule | null;
+    /** The categories the shop displays it in — e.g. a lunch combo among the pizzas. */
+    categoryIds: string[];
+    /**
+     * The combo's own pictures, cover first — the deal photographed as a set. Empty when the shop
+     * has none: show the combo by its picks' photos instead.
+     */
+    images: {
+        url: string;
+    }[];
+    slots: PublicComboSlot[];
+}
+export interface ListCombosParams {
+    /** Only the combos the shop displays in this category. */
+    categoryId?: string;
+}
+/**
+ * The ways a discount rule prices the units it applies to:
+ *
+ * - `percent_off`: every unit costs `value`% less.
+ * - `amount_off`: every unit costs `value` less, never below zero.
+ * - `fixed_price`: every unit costs `value`, when that is less than its price.
+ * - `buy_x_get_y`: for every `buyQuantity` bought, the next `getQuantity` cost `value` each
+ *   (`0` is free). The cheapest units of each group are the ones discounted.
+ * - `bundle_price`: every `buyQuantity` units together cost `value`.
+ */
+export type DiscountRuleKind = "percent_off" | "amount_off" | "fixed_price" | "buy_x_get_y" | "bundle_price";
+/**
+ * A discount rule on now — for a page to badge the products it targets ("2 for 1", "-20%").
+ *
+ * For DISPLAY: which rule a cart unit actually takes is decided when the cart is priced, and
+ * the cart's `discounts` say what was taken off.
+ */
+export interface PublicDiscountRule {
+    id: string;
+    name: string;
+    description?: string;
+    kind: DiscountRuleKind;
+    /** A percentage for `percent_off`; money in major units for every other kind. */
+    value: number;
+    buyQuantity: number | null;
+    getQuantity: number | null;
+    validUntil: string | null;
+    schedule: PublicDealSchedule | null;
+    /** What it applies to: these products, and every product in these categories. */
+    productIds: string[];
+    categoryIds: string[];
+}
+/** The orders `getProducts` can list in. */
+export type ProductSort = "custom" | "name" | "price" | "popularity" | "discount";
+/**
+ * A basket, held by the server.
+ *
+ * `cartId` is the CREDENTIAL as well as the identifier — there is no visitor account, so
+ * whoever holds it holds the cart. Keep it out of anything a page renders, and out of a URL a
+ * visitor might share.
+ */
+export interface PublicCart {
+    cartId: string;
+    workspace: Workspace;
+    items: PublicCartItem[];
+    /** Units across every line, for a badge. */
+    count: number;
+    /**
+     * Sum of price x quantity at CURRENT prices — each line's variant price where it has one —
+     * before any discount.
+     *
+     * The server does not know what a site charges for a size or a topping — that lives in
+     * `variant`, which it stores and never reads — so a site with its own options has to total
+     * the lines itself. This is the floor, not the bill.
+     */
+    subtotal: number;
+    /** Everything the shop's deals took off, in major units. */
+    discount: number;
+    /** `subtotal` less `discount`, plus tax when it is added on top — what the server will charge. */
+    total: number;
+    /**
+     * The sales tax in it, in major units: inside `total` when `taxInclusive` (show "incl. 15%
+     * tax"), added to it otherwise. 0 when the shop charges none.
+     */
+    tax: number;
+    /** The shop's tax rate, in percent. 0: no tax. */
+    taxRate: number;
+    /** True: prices include the tax. False: it is added on top of them. */
+    taxInclusive: boolean;
+    /** What the tax is called where the shop trades — GST, VAT, Sales tax. Label the tax line with it. */
+    taxName: string;
+    /** The rules that took money off the cart as a whole, and how much each. */
+    discounts: PublicCartDiscount[];
+    /**
+     * The table booking this basket is ordered for (`setCartBooking`), with what its booking fee
+     * adds to paying it; null for an ordinary basket.
+     */
+    booking: PublicCartBooking | null;
+}
+/** The booking a basket is ordered for, and its fee - see `PublicCart.booking`. */
+export interface PublicCartBooking {
+    bookingId: string;
+    /** The shop's booking fee for this party, in major units; 0 when none is paid with an order. */
+    fee: number;
+    /**
+     * The fee counts towards the order: it is a minimum spend - an order of at least `fee` pays
+     * no fee, a smaller one pays the difference.
+     */
+    feeIsDeposit: boolean;
+    /**
+     * What paying THIS basket adds for the booking, in major units, on top of `total`: the whole
+     * fee for an empty basket, the shortfall or 0 for a deposit, 0 once the fee is paid.
+     */
+    charged: number;
+    /**
+     * Of a deposit, the part the basket covers, in major units - shown as the fee and taken off,
+     * so the fee is seen charged and removed. `charged` + `included` is the whole fee. Absent from
+     * servers before it.
+     */
+    included?: number;
+}
+/** One deal, and what it took off a line or the cart. */
+export interface PublicCartDiscount {
+    ruleId: string;
+    name: string;
+    /** In major units. */
+    amount: number;
+}
+/** One product picked into a combo line. */
+export interface PublicCartComboPick {
+    slotId: string;
+    slotName: string;
+    productId: string;
+    name: string;
+    variantId: string | null;
+    variantName: string | null;
+    /** Added to the combo's price for this pick, in major units. */
+    surcharge: number;
+    /** The site's own configuration for the pick, as on a product line. */
+    variant?: string;
+}
+/** What makes a line a combo: which one, and what fills it. The line's `name` is the combo's. */
+export interface PublicCartCombo {
+    comboId: string;
+    picks: PublicCartComboPick[];
+}
+export interface PublicCartItem {
+    /** Identifies the LINE, which is what quantity changes and removals address. */
+    cartItemId: string;
+    /** The product on a product line. Absent on a combo line — read `combo` there. */
+    productId?: string;
+    /** Present on a combo line: the combo and every pick in it. */
+    combo?: PublicCartCombo;
+    /** What deals took off this line, in major units, and which ones. */
+    discount: number;
+    discounts: PublicCartDiscount[];
+    /** (Price + `addOns`) × quantity less `discount`. */
+    total: number;
+    /** Why the line can no longer be bought (sold out, deal ended) — absent when it can. */
+    unavailable?: string;
+    name: string;
+    /** As it stands now, not as it stood when the line was added. Without the extras. */
+    price?: number;
+    /**
+     * What the chosen extras add to one unit, at the prices in the shop's lists - charged at
+     * checkout, not discounted. Absent when nothing extra was chosen.
+     */
+    addOns?: number;
+    image?: string;
+    quantity: number;
+    /** The product variant this line is, when the product has variants. */
+    variantId: string | null;
+    /** That variant's name in the request language, for the basket row. */
+    variantName: string | null;
+    /** Whatever the site put there. Opaque to the server; parse it back yourself. */
+    variant: string;
+}
+/**
+ * Every cart call carries the id explicitly.
+ *
+ * The server would accept the cookie it set instead, and a browser on the same site would be
+ * fine. A SERVER component would not: it has no cookie jar, and would silently read whichever
+ * cart the process last touched. Passing the id makes the call mean the same thing wherever it
+ * runs.
+ */
+export interface GetCartParams {
+    cartId: string;
+}
+/**
+ * Add a product — or a combo, with what fills it. Exactly one of `productId` and `comboId`.
+ */
+export interface AddCartItemParams extends GetCartParams {
+    productId?: string;
+    /** A combo from `getCombos`; `picks` then fill every one of its slots. */
+    comboId?: string;
+    /** One per unit a slot takes: a slot of `quantity: 2` takes two picks. */
+    picks?: ComboPick[];
+    /** Defaults to 1. Clamped, floored, and rejected if it is not a number. */
+    quantity?: number;
+    /**
+     * Which of the product's variants — `PublicProduct.variants[].id`. Required for a product
+     * that has variants, refused for one that has none. The line is then priced as that variant:
+     * its price, its discount rule.
+     */
+    variantId?: string;
+    /**
+     * The site's own configuration for this line — a size, toppings, whatever it sells.
+     *
+     * Stored verbatim and never parsed by the server, which uses it only to tell two lines of
+     * the same product apart. Send the SAME string for the same configuration or a second Large
+     * opens a second line: serialize it in a stable order, or the key stops matching itself.
+     */
+    variant?: string;
+}
+/** One product filling one place in a combo. */
+export interface ComboPick {
+    /** `PublicComboSlot.id`. */
+    slotId: string;
+    /** One of that slot's `options[].productId`. */
+    productId: string;
+    /**
+     * Which variant: required when the option leaves it open (`variantId: null`) and the
+     * product has variants — one of the option's `variants[].id`.
+     */
+    variantId?: string;
+    /** The site's own configuration for the pick, as on a product line. */
+    variant?: string;
+}
+export interface SetCartItemQuantityParams extends GetCartParams {
+    cartItemId: string;
+    /** Zero removes the line. */
+    quantity: number;
+}
+export interface RemoveCartItemParams extends GetCartParams {
+    cartItemId: string;
+}
+export interface SetCartBookingParams extends GetCartParams {
+    /** The booking (createBooking's id) the basket is ordered for; null lets it go. */
+    bookingId: string | null;
+}
+/**
+ * Start paying for a basket.
+ *
+ * The server builds the order from the cart it holds — every line, at the quantity the
+ * shopper chose, priced from the catalogue now — so a page cannot charge for something that
+ * was never in the basket.
+ */
+/**
+ * How an order reaches the customer. `delivery`: the hosted payment page asks for the address
+ * and prices it by the shop's delivery zones.
+ */
+/** Whether an order names the location it is for - see `SiteInfo.orderLocation`. */
+/** Who sees the site - `getSiteInfo().customerAccess`. */
+export type CustomerAccess = "public" | "signed_in";
+export type OrderLocationMode = "never" | "optional" | "required";
+export type OrderType = "pickup" | "reservation" | "delivery" | "dine_in";
+/** A table a guest is ordering from, by the id on its QR code. */
+export interface PublicDiningTable {
+    tableId: string;
+    label: string;
+    /** How to name it to the guest, in their language: "Table 5". */
+    title: string;
+    /** The restaurant it stands in - null for a shop whose plan names none. */
+    locationId: string | null;
+    /** The way out, in their language, for a code scanned by mistake: "Not at this table?". */
+    leaveLabel: string;
+    /** What to call the table code, in the page's language. */
+    codeLabel: string;
+    /** What to say once the code is accepted. */
+    codeAcceptedLabel: string;
+    /** Whether the shop takes orders from tables. */
+    isOpen: boolean;
+    /** What to tell the guest, in their language: to ask the staff for the table's code. */
+    notice: string | null;
+}
+export interface CreateCheckoutParams extends GetCartParams {
+    /**
+     * Where the receipt goes, and who the shopper is to Stripe for saved cards. Optional: left
+     * out, the checkout page asks for it before taking the payment — so a site needs no form.
+     */
+    customerEmail?: string;
+    /**
+     * A phone to reach the customer about the order. Required for a delivery before it is paid:
+     * left out, the checkout page asks for it. A signed-in customer's own phone is used otherwise.
+     */
+    customerPhone?: string;
+    /** The customer's note for the kitchen or the driver - "no onions", "ring the bell". */
+    notes?: string;
+    /**
+     * Where the checkout page sends the shopper after paying. `{CHECKOUT_ID}` is replaced with
+     * the checkout's id, so a confirmation page can look it up.
+     */
+    successUrl?: string;
+    /** Where the checkout page sends a shopper who backs out — usually the basket. */
+    cancelUrl?: string;
+    /**
+     * The language the shopper is reading the shop in, as an ISO code.
+     *
+     * The payment page is written in it and the product names on the checkout are snapshotted in
+     * it, so a shopper who ordered in Russian pays in Russian. Left out, the language this client
+     * is already reading in is sent — the same one that goes out as `x-language` — which is the
+     * right answer for every site that has a language at all. Pass it only to say something
+     * different from what the page is rendered in.
+     */
+    language?: string;
+    /**
+     * Where the order is picked up or served: one of the shop's active locations, from
+     * `getLocations` - its `number` (`2`, preferred in addresses) or its `id`. Required when the site info says `orderLocation: "required"`; refused when it
+     * names a location that is not the shop's or not on its site.
+     */
+    locationId?: string | number;
+    /**
+     * How the order reaches the customer — one of `getSiteInfo().orderTypes`. Left out: the first
+     * the shop offers, which the hosted payment page lets the shopper change. Refused when the
+     * shop does not offer it.
+     */
+    orderType?: OrderType;
+    /**
+     * When the order should be ready: a time's `at` from `getOrderTimes`. Left out, as soon as
+     * possible. Refused when the shop does not let customers choose a time, or it is not one
+     * offered.
+     */
+    scheduledFor?: string;
+    /**
+     * The table booking this order is for — a guest ordering ahead for the table they booked: the
+     * `id` `createBooking` returned, or a `bookingId` from `getCustomerBookings`. The order becomes
+     * `reservation` at the booking's location unless `orderType` / `locationId` say otherwise, and the
+     * shop sees it on the booking. Refused when the booking is over (finished, cancelled, no-show)
+     * or belongs to another signed-in customer.
+     */
+    bookingId?: string | number;
+    /**
+     * The table a guest is ordering from, by the id on its QR code. The order is then dine-in at
+     * that table, and nothing about it can be changed; the payment page asks for the table's code.
+     */
+    tableId?: string;
+    /** That table's code, if the guest gave it already: the payment page then does not ask. */
+    tableCode?: string;
+    /**
+     * False: the payment page offers no choice of when - `scheduledFor` stands, or as soon as
+     * possible. These go in the checkout, not its address, so a guest cannot change them.
+     */
+    allowTimeChoice?: boolean;
+    /** False: no choice of how the order is received. Needs `orderType`. */
+    allowOrderTypeChoice?: boolean;
+    /** False: no choice of how it is paid. Needs `paymentMethod`. */
+    allowPaymentMethodChoice?: boolean;
+    /** How it is paid: `card` online, or `in_store`. */
+    paymentMethod?: "card" | "in_store";
+    /**
+     * A promo code the customer typed, any case - money off the order after its deals, or free
+     * delivery. Refused with the reason (`code`: `promo_code_unknown`, `promo_code_expired`,
+     * `promo_code_used_up`, `promo_code_minimum`, ...) when it cannot go on this order. The hosted
+     * payment page offers a code field of its own, so a site need not ask.
+     */
+    promoCode?: string;
+    /**
+     * The signed-in customer's token, from `verifySignInCode`, `signInWithGoogle` or `signInWithApple`. The checkout
+     * — and the order it becomes — is then theirs, and their email is used when `customerEmail`
+     * is left out. Left out: a guest checkout, belonging to whoever the email is.
+     */
+    customerToken?: string;
+}
+export type CheckoutStatus = "pending" | "paid" | "failed" | "cancelled";
+/** Which checkout to read, by the id `createCheckout` answered with. */
+export interface GetCheckoutParams {
+    checkoutId: string;
+}
+/** Who is paying, given on the site's own payment page. */
+export interface SetCheckoutEmailParams extends GetCheckoutParams {
+    email: string;
+}
+/**
+ * What Stripe.js needs to take the card IN THE PAGE, rather than on the hosted page.
+ *
+ * Present only while the checkout can still be paid. None of it is a secret a shopper must be
+ * kept from: the publishable key is public by design, and a PaymentIntent's client secret
+ * authorises paying THIS order and nothing else — which is why Stripe's own Elements take it
+ * in the browser. Pass it to a `"use client"` component as props; the card itself is typed
+ * into Stripe's iframe and never touches page code.
+ */
+export interface PublicCheckoutPayment {
+    /** The PLATFORM's publishable key. Public, and safe in a bundle. */
+    publishableKey: string;
+    /**
+     * The shop's own Stripe account, when the charge is made on it.
+     *
+     * Stripe.js has to be loaded with it (`loadStripe(key, { stripeAccount })`) or it looks for
+     * the PaymentIntent on the platform's account, does not find it, and the element never
+     * mounts.
+     */
+    connectedAccountId?: string;
+    /** The PaymentIntent to confirm. */
+    clientSecret: string;
+    /**
+     * Offers the cards this shopper saved at this shop, and offers to save this one.
+     *
+     * Only when the checkout knows who is paying — pass `customerEmail` to `createCheckout`.
+     * Without it the payment is a one-off, which still works.
+     */
+    customerSessionClientSecret?: string;
+    /**
+     * The card is kept for later whatever the shopper says - a booking that needs it, or a shop
+     * that keeps every card (Sales rules → Payment methods → Online payment details). Stripe's
+     * element then shows no "save" box: say on the page that the card is saved. Absent from an
+     * older server: not kept.
+     */
+    storesCard?: boolean;
+}
+/**
+ * A checkout as the page TAKING the payment sees it: the order, and the secrets to charge it.
+ *
+ * Read with `getCheckout`. The shape differs from `createCheckout`'s answer because it answers
+ * a different question — not "where do I send the shopper" but "what am I charging, and with
+ * what" — so it carries the shop's name, the currency and `payment`, and no hosted URL.
+ */
+export interface PublicCheckoutSession {
+    checkoutId: string;
+    status: CheckoutStatus;
+    /** The shop being paid, for the page to name in its own words. */
+    shopName: string;
+    /** Stripe test keys: a test card works and nothing real is charged. */
+    testMode: boolean;
+    /** Null until the shopper is known — no email was given at creation. */
+    customerEmail: string | null;
+    /** Priced by the server from the cart, so a page cannot charge its own totals. */
+    items: {
+        name: string;
+        /** The variant sold, when the product has variants. */
+        variantName?: string;
+        quantity: number;
+        unitPriceCents: number;
+    }[];
+    subtotalCents: number;
+    totalCents: number;
+    /** ISO 4217, lowercase. */
+    currency: string;
+    /** Decimal digits of every `…Cents` amount (ISO 4217): read `totalCents / 10 ** currencyMinorUnit`. */
+    currencyMinorUnit?: number;
+    successUrl?: string;
+    cancelUrl?: string;
+    /**
+     * True: the shop takes orders from signed-in customers only and a guest made this checkout
+     * (before the rule was on) - there is no `payment`; send them back to sign in and check out again.
+     */
+    signInRequired?: boolean;
+    /** Absent once the checkout is paid, cancelled, or otherwise no longer payable. */
+    payment?: PublicCheckoutPayment;
+}
+export interface PublicCheckout {
+    checkoutId: string;
+    /**
+     * The hosted checkout page. Send the shopper's BROWSER here — a redirect from a server
+     * action — and the page takes the payment and returns them to `successUrl`.
+     */
+    checkoutUrl: string;
+    status: CheckoutStatus;
+    /** Null until known — when the site left it to the checkout page, and the shopper has not got there. */
+    customerEmail: string | null;
+    /** In the smallest currency unit. */
+    subtotalCents: number;
+    totalCents: number;
+    /** The sales tax, in the smallest unit — inside `totalCents` when `taxInclusive`. */
+    taxCents: number;
+    taxRate: number;
+    taxInclusive: boolean;
+    /** What the tax is called where the shop trades — GST, VAT, Sales tax. Label the tax line with it. */
+    taxName: string;
+    items: {
+        productId?: string;
+        productNameSnapshot: string;
+        /** The variant sold, when the product has variants. */
+        variantId?: string | null;
+        /** What that variant was called, in the checkout's language. */
+        variantName?: string | null;
+        quantity: number;
+        unitPriceCents: number;
+    }[];
+    createdAt: string;
+}
+/** A time a party can book, on the location's clock. */
+export interface PublicBookingSlot {
+    /** `HH:mm` at the location. */
+    time: string;
+    /** The instant — what `createBooking` takes. */
+    startsAt: string;
+    /** Whether a table that seats the party is free for the whole visit. */
+    available: boolean;
+}
+/** One later time an order can be for: the location's wall clock, and the instant. */
+export interface PublicOrderTime {
+    /** `HH:mm` at the location. */
+    time: string;
+    /** The instant — what `createCheckout` takes as `scheduledFor`. */
+    at: string;
+}
+/**
+ * When an order can be for, on the location's own clock — the same times the hosted payment
+ * page offers and the server accepts.
+ */
+export interface PublicOrderTimes {
+    /** The location's zone; null when it has none — then `days` is empty. */
+    timeZone: string | null;
+    /** Whether "as soon as possible" can be ordered now: the location is open. */
+    asap: boolean;
+    /** The earliest an order can be ready (now plus the takeaway time), ISO 8601. */
+    earliest: string;
+    /**
+     * Later times by day (`date` is `YYYY-MM-DD` at the location) — today only unless the shop
+     * lets customers choose a day. Empty when the shop does not let customers choose a time.
+     */
+    days: {
+        date: string;
+        times: PublicOrderTime[];
+    }[];
+}
+export interface GetOrderTimesParams {
+    /** The order's location, from `getLocations` - its `number` (`2`, preferred in addresses) or its `id`; left out, the shop's only active one. */
+    locationId?: string | number;
+}
+/** The day's times for a party at one location. */
+export interface PublicBookingSlots {
+    locationId: string;
+    date: string;
+    /** The clock the times are on. */
+    timeZone: string;
+    /** How long a booking holds its table — the length asked for, or the shop's default. */
+    durationMinutes: number;
+    /** The shortest reservation the shop takes, in minutes — what a guest may choose from. */
+    minDurationMinutes?: number;
+    /** The longest, in minutes. */
+    maxDurationMinutes?: number;
+    /**
+     * The cancellation notice the guest books under: they may cancel it themselves
+     * (`cancelBooking`) up to this many hours before it starts; 0: up to the start. Say it beside
+     * the booking - "Free cancellation up to 2 hours before".
+     */
+    cancelHours?: number;
+    /**
+     * False: the shop allows no free cancellation - say none; `cancelHours` promises nothing, and
+     * cancelling costs its fee (each booking's `cancelFee`).
+     */
+    freeCancellation?: boolean;
+    /** What booking costs, in minor units of the shop's currency; 0: nothing. Paid online. */
+    bookingFeeCents?: number;
+    /** When it is paid: with the booking, or only for a late cancellation or a no-show. */
+    bookingFeeCharge?: "checkout" | "on_cancel";
+    /** Per booking, or per guest (times the party). */
+    bookingFeePer?: "booking" | "guest";
+    /** From how many guests the fee is asked; a smaller party pays none. */
+    bookingFeeFromParty?: number;
+    /**
+     * The fee counts towards the order (a deposit): with dishes ordered for the booking it is part
+     * of the order's price, not paid on top - say the fee only for a booking with no order.
+     */
+    bookingFeeDeposit?: boolean;
+    /** The smallest and largest party the shop takes online - a bigger one should call. */
+    minPartySize?: number;
+    maxPartySize?: number;
+    /** A whole table, seats at a shared table, or a time only (no table, no plan to show). */
+    mode: "table" | "seat" | "time";
+    /**
+     * What the shop reserves: `specialist` and `custom` book one of `entries`; `table` and `seat`
+     * a table; `time` a time only.
+     */
+    reservationType?: "off" | "table" | "seat" | "specialist" | "time" | "custom";
+    /**
+     * For a `specialist` or `custom` shop, what a guest may pick, in the shop's order - pass one
+     * as `entryId` to see its times and to book it. Empty otherwise.
+     */
+    entries?: PublicBookingEntry[];
+    /** Rooms with bookable tables — what `seating` may name. Empty for time-only. */
+    rooms: string[];
+    /** Every half hour while open; empty when closed that day. */
+    slots: PublicBookingSlot[];
+}
+/** Something a guest books by name - a specialist. */
+export interface PublicBookingEntry {
+    id: string;
+    name: string;
+    /** Its picture, as a URL - a specialist's photo; null when it has none. */
+    image: string | null;
+    /**
+     * The products it can be booked for - a dentist's treatments - while the shop books from an
+     * allowed list (`reservationOrder: "list"`); null: anything the rules allow.
+     */
+    productIds?: string[] | null;
+}
+/** What a guest books: a table, an entry of the shop's list, or a time alone. */
+export type ReservationKind = "table" | "list" | "time";
+export interface GetBookingSlotsParams {
+    /** The location - its `number` (`2`, preferred in addresses) or its `id`. */
+    locationId: string | number;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    partySize: number;
+    /** A room from `rooms`; any when left out. */
+    seating?: string;
+    /** The visitor's IANA zone, for a location that keeps none. */
+    timeZone?: string;
+    /**
+     * One table of the location: each time then says whether THAT table is free and seats the
+     * party — the day of the table the guest picked. Ignored when the shop books a time only.
+     */
+    tableId?: string;
+    /** How long the visit is, in minutes — within the shop's range; its default when left out. */
+    durationMinutes?: number;
+    /** For a `specialist` or `custom` shop: one of `entries` - the times THAT one is free. */
+    entryId?: string;
+    /** Several of `entries` - the times ANY of them is free. Ignored with `entryId`. */
+    entryIds?: string[];
+    /**
+     * What the visit is for - a product (a treatment). With an allowed list only the entries that
+     * offer it count: each time says whether any of them is free.
+     */
+    productId?: string;
+    /** Several services: the times an entry that offers ALL of them is free. */
+    productIds?: string[];
+    /**
+     * What is booked, of the shop's `reservationKinds` (`getSiteInfo`) - `table`, `list` (an entry
+     * of its list: a specialist, a room), `time` alone; the shop's main way when left out.
+     */
+    kind?: ReservationKind;
+}
+/** One thing drawn on the floor plan, in grid units (about a metre each). */
+export interface PublicPlanItem {
+    id: string;
+    kind: "table" | "room" | "wall" | "bar" | "door" | "window" | "plant" | "zone" | "column";
+    label: string;
+    shape: "round" | "rect" | null;
+    seats: number | null;
+    /** Chairs per side of a rectangular table. */
+    chairs: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    } | null;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+}
+/** A table's state at the asked time. */
+export interface PublicPlanTable {
+    id: string;
+    label: string;
+    seats: number;
+    /** The room it stands in. */
+    room: string | null;
+    /** Free at that time, for any party. */
+    available: boolean;
+    /** Free AND seats this party in the wanted room. */
+    fits: boolean;
+}
+/** The location's floor plan at a time, with the best free table for the party. */
+export interface PublicBookingPlan {
+    width: number;
+    height: number;
+    /** Everything to draw, rooms first. */
+    items: PublicPlanItem[];
+    tables: PublicPlanTable[];
+    /** Null when none fits — and always in `time` mode, where no table is chosen. */
+    suggestedTableId: string | null;
+    /**
+     * How the shop takes bookings. `time`: the plan is for looking at — no table fits, none is
+     * suggested, and a booking that names a table or seating is refused.
+     */
+    mode?: "table" | "seat" | "time";
+}
+export interface GetBookingPlanParams {
+    /** The location - its `number` (`2`, preferred in addresses) or its `id`. */
+    locationId: string | number;
+    /** A slot's `startsAt`. */
+    startsAt: string;
+    partySize: number;
+    seating?: string;
+    /** How long the visit is, in minutes; the shop's default when left out. */
+    durationMinutes?: number;
+    /**
+     * What is booked, of the shop's `reservationKinds` (`getSiteInfo`) - `table`, `list` (an entry
+     * of its list: a specialist, a room), `time` alone; the shop's main way when left out.
+     */
+    kind?: ReservationKind;
+}
+export interface CreateBookingParams {
+    /** The location - its `number` (`2`, preferred in addresses) or its `id`. */
+    locationId: string | number;
+    /** A slot's `startsAt`. */
+    startsAt: string;
+    partySize: number;
+    /**
+     * What is booked, of the shop's `reservationKinds` (`getSiteInfo`) - `table`, `list` (an entry
+     * of its list: a specialist, a room), `time` alone; the shop's main way when left out.
+     */
+    kind?: ReservationKind;
+    /**
+     * Who is coming — required for a guest. With a signed-in customer (`customerToken`, or the
+     * cookie through `@estoreclub/client`) each one left out is taken from their account.
+     */
+    guestName?: string;
+    guestPhone?: string;
+    guestEmail?: string;
+    /** Birthday, high chair, allergies… */
+    notes?: string;
+    /** The table the guest picked; the best fit when left out or taken. */
+    tableId?: string;
+    seating?: string;
+    /** How long to hold the table, in minutes — within the shop's range; its default when left out. */
+    durationMinutes?: number;
+    /** The guest asked for a text reminder. */
+    remind?: boolean;
+    timeZone?: string;
+    /** The signed-in customer's token: the booking is then theirs. */
+    customerToken?: string;
+    /** For a `specialist` or `custom` shop: the one to book; the first free when left out. */
+    entryId?: string;
+    /** Without `entryId`: the first free of these is booked. */
+    entryIds?: string[];
+    /**
+     * What the visit is for - one of the shop's products, when its rules let a reservation carry
+     * one (`reservationOrder`). With an allowed list, only an entry that offers it is booked.
+     */
+    productId?: string;
+    /**
+     * The visit's services - the shop's products. Booked with a draft order holding them; with an
+     * allowed list only an entry that offers ALL of them is booked.
+     */
+    productIds?: string[];
+    /** Where the payment page sends the guest back, when the shop requires payment to reserve. */
+    successUrl?: string;
+    cancelUrl?: string;
+    /**
+     * How the guest pays, where the shop offers both (`reservationPayment`): `now`, or `on_accept`
+     * - the card held, charged when the shop accepts. Left out: the shop's way.
+     */
+    payment?: ReservationPaymentTiming;
+}
+/** The ways a booking may be paid when it is made. */
+export interface PublicReservationPayment {
+    /** Paid now - charged at once. */
+    order: boolean;
+    /** The card held now, charged when the shop accepts the booking. */
+    deferred: boolean;
+}
+/** One booking's way of paying: charged now, or held until the shop accepts it. */
+export type ReservationPaymentTiming = "now" | "on_accept";
+/** A booking made from the site — confirmed at once. */
+export interface PublicBooking {
+    id: string;
+    /** The shop's own number for the booking (`12`) - what your links name it by; taken wherever a `bookingId` is. */
+    bookingNumber: number | null;
+    locationId: string;
+    startsAt: string;
+    partySize: number;
+    durationMinutes: number;
+    /** The table held for the party; null for a time-only booking. */
+    tableLabel: string | null;
+    room: string | null;
+    /** The entry booked - a specialist - its name and picture; null otherwise. */
+    entryId?: string | null;
+    entryName?: string | null;
+    entryImage?: string | null;
+    /** What the visit is for - the services booked, in the order asked. */
+    services?: {
+        id: string;
+        name: string;
+    }[];
+    /**
+     * The draft order holding the services, paid later - at the visit, or now when the shop
+     * requires payment to reserve (`payment`). Null when nothing was booked for.
+     */
+    orderId?: string | null;
+    orderNumber?: number | null;
+    /** What it comes to, in major units. */
+    orderTotal?: number | null;
+    /**
+     * For a `pending` booking (the shop requires payment to reserve): where the guest pays - a PATH
+     * on the shop's own site; send them there. The time is held meanwhile and lapses unpaid.
+     */
+    payment?: {
+        checkoutId: string;
+        checkoutUrl: string;
+        /** `now`: charged on the payment page; `on_accept`: only held there. */
+        timing?: ReservationPaymentTiming;
+    } | null;
+    /**
+     * `confirmed`; `pending` while its payment is made; or `requested` - waiting for the shop to
+     * accept it (its time held meanwhile). The guest is emailed the shop's answer.
+     */
+    status: "confirmed" | "pending" | "requested";
+}
+/** A customer of the shop, as the site sees them. */
+export interface PublicCustomer {
+    customerId: string;
+    email: string;
+    name: string | null;
+    phone: string | null;
+    /** `YYYY-MM-DD`. */
+    dateOfBirth: string | null;
+    /**
+     * Their picture, as a URL — Google's profile photo, refreshed on each Google sign-in. Null:
+     * none; draw initials. Load it with `referrerPolicy="no-referrer"`.
+     */
+    avatarUrl: string | null;
+    /**
+     * The language they chose to read the shop in (ISO code), on any of its sites or apps - read
+     * in it once they sign in. Null: never chosen.
+     */
+    language?: string | null;
+    /** When they first signed in. */
+    signedUpAt: string | null;
+    /**
+     * Signed in and holding every detail the shop requires. False: ask for `missingFields`
+     * (with `updateCustomerProfile`) before going on.
+     */
+    onboarded: boolean;
+    /** The required details still missing; empty once onboarded. */
+    /**
+     * The details still to give, then the consents the shop requires and they have not given:
+     * `terms` (show `getTerms()`, send `acceptTerms: true`) and `healthConsent`.
+     */
+    missingFields: (CustomerField | CustomerConsent)[];
+    /**
+     * What those missing details stop until they are given - the shop's rule: `orders` (signed
+     * in, but ordering and booking are refused) or `sign_in` (signed out everywhere but their own
+     * account, so a members-only site stays locked). Null once nothing is missing. Ask for the
+     * details either way; for `sign_in` there is no skipping them.
+     */
+    missingDetailsStop?: "orders" | "sign_in" | null;
+}
+/** A customer detail a shop may require, beyond the email. */
+export type CustomerField = "name" | "phone" | "dateOfBirth";
+/** A consent a shop may require, missing like a detail until it is given. */
+export type CustomerConsent = "terms" | "healthConsent";
+export type CustomerRequiredFields = Record<CustomerField, boolean>;
+/**
+ * What a sign-in (or a refresh) answers with. Keep BOTH tokens where only the site's SERVER can
+ * read them — httpOnly cookies, never browser storage — and pass `token` as `customerToken` to
+ * the calls that take one.
+ */
+export interface PublicCustomerSession {
+    /** Short-lived (15 minutes by default) and not revocable: what the customer's calls carry. */
+    token: string;
+    /**
+     * Trades for a new `token` and a new `refreshToken` (`refreshCustomerToken`) once `token`
+     * lapses. Single use: keep the one each refresh answers with; a spent one stops working.
+     */
+    refreshToken: string;
+    customer: PublicCustomer;
+}
+export interface RefreshCustomerTokenParams {
+    refreshToken: string;
+}
+/** One of the signed-in customer's orders. */
+export interface PublicCustomerOrder {
+    orderId: string;
+    orderNumber: number;
+    /** Its delivery's tracking number (`K7P-QX9-M2T`): with the order's email it opens the order on the tracking page. Null: not a delivery, or the shop does not let guests track. */
+    trackingCode: string | null;
+    paidAt: string;
+    /** Minor units of `currency`. */
+    totalCents: number;
+    /** Refunded so far, minor units — zero for almost every order. */
+    refundedCents: number;
+    currency: string;
+    /** Where it stands: being made / handed over, done, or called off. */
+    status: "open" | "completed" | "cancelled";
+    /** The step the shop has the order at, in the shop's own words. */
+    state: string;
+    orderType: string | null;
+    locationName: string | null;
+    /** Where a delivered order goes, with any flat or gate details; null when it is collected. */
+    deliveryAddress?: string | null;
+    /** How many things were ordered, quantities added up. */
+    itemCount: number;
+    /** The products in it, each once, first ordered first — thumbnails for a list. */
+    productIds: string[];
+    /** How far the shop has got; null once completed or cancelled. */
+    progress: PublicCustomerOrderProgress | null;
+    /** A delivered order's delivery number (`D-17`); null for any other order. */
+    deliveryNumber?: string | null;
+    /** Shipped by a carrier: who has it and where to follow it. Null until the shop ships it. */
+    shipment?: PublicCustomerOrderShipment | null;
+    /**
+     * A delivered order's delivery: `pending`, `ready`, `picked_up` (on its way), `delivered`,
+     * `failed` or `cancelled`; null for any other order. While it is on its way, `progress` ends
+     * with a delivery stage.
+     */
+    deliveryStatus?: "pending" | "ready" | "picked_up" | "delivered" | "failed" | "cancelled" | null;
+}
+/** A parcel handed to a carrier. */
+export interface PublicCustomerOrderShipment {
+    /** Who carries it (`NZ Post`). */
+    carrier: string;
+    trackingNumber: string;
+    /** The carrier's own tracking page; null when the shop gave none. */
+    trackingUrl: string | null;
+    shippedAt: string;
+}
+/**
+ * Find a placed order for a tracking page: `number` - the order's (`1042`, `#1042`) or its
+ * delivery's (`D-17`) - together with the `email` it was placed with; or `checkoutId` alone (the
+ * confirmation link's id). Those are the credential: no customer token is involved.
+ */
+export interface TrackOrderParams {
+    /** The delivery's tracking number (`K7P-QX9-M2T`) - with `email`. */
+    code?: string;
+    /** The email the order was placed with - with `code`. */
+    email?: string;
+    /** The confirmation link's checkout id - enough on its own. */
+    checkoutId?: string;
+}
+/** Where an open order is in the shop's own workflow. */
+export interface PublicCustomerOrderProgress {
+    /** The shop's working states, in its order — the endings ("Delivered") left out. */
+    steps: string[];
+    /** Index into `steps`; -1 before the shop picked it up, `steps.length` once the work is done. */
+    current: number;
+}
+/** One line of a customer's order, as charged. Money in minor units. */
+export interface PublicCustomerOrderLine {
+    /** Null on a combo line, and once the product is deleted. */
+    productId: string | null;
+    variantId: string | null;
+    /** Set on a combo line. */
+    comboId: string | null;
+    /** The site's own configuration of the line, as the cart was sent it — to add it again. */
+    variant: string;
+    name: string;
+    variantName: string | null;
+    /** Size, extras — as the receipt says it. */
+    detail: string;
+    quantity: number;
+    unitPriceCents: number;
+    discountCents: number;
+    /** `unitPrice × quantity − discount`. */
+    totalCents: number;
+}
+/** One of the signed-in customer's orders, in full. */
+export interface PublicCustomerOrderDetail extends PublicCustomerOrder {
+    subtotalCents: number;
+    discountCents: number;
+    taxCents: number;
+    taxName: string;
+    taxInclusive: boolean;
+    paymentMethod: string;
+    /** Who a delivered order is handed to, and the number the driver calls; null when collected. */
+    recipientName?: string | null;
+    recipientPhone?: string | null;
+    readyBy: string | null;
+    /**
+     * When a delivery should be at the door - only while the shop tells its customers when a
+     * delivery comes; null otherwise, and for an order that is not a delivery.
+     */
+    deliverBy?: string | null;
+    scheduledFor: string | null;
+    completedAt: string | null;
+    cancelledAt: string | null;
+    lines: PublicCustomerOrderLine[];
+}
+/** One of the signed-in customer's bookings. */
+export interface PublicCustomerBooking {
+    bookingId: string;
+    /** The booking's own number (`12`) - what your links name it by; taken wherever a `bookingId` is. */
+    bookingNumber: number | null;
+    /** Its location's number (`2`). */
+    locationNumber: number | null;
+    startsAt: string;
+    durationMinutes: number;
+    partySize: number;
+    /** waiting, confirmed, seated, finished, cancelled, no_show. */
+    status: string;
+    locationId: string | null;
+    locationName: string | null;
+    /** The tables held, by their labels; empty for a time-only booking. */
+    tables: string[];
+    /** The entry booked - a specialist - by name, and its picture; null otherwise. */
+    entryName?: string | null;
+    entryImage?: string | null;
+    /** What the visit is for - the product (a treatment), in the shop's language. */
+    productName?: string | null;
+    /** What the customer typed when booking online - never the shop's own notes about them. */
+    notes: string;
+    /**
+     * Until when the customer may still call it off themselves (`cancelBooking`) - the shop's
+     * notice before the start, applied by the server; null: no longer theirs to cancel for free.
+     */
+    cancellableUntil?: string | null;
+    /**
+     * Whether they may call it off now: free until `cancellableUntil`, and after it for
+     * `cancelFee` where the shop charges a late-cancellation fee and the booking was paid.
+     */
+    canCancel?: boolean;
+    /**
+     * What cancelling now costs, in the currency's smallest unit - kept from the booking's payment,
+     * the rest refunded. Null while it is free. Say it before they confirm.
+     */
+    cancelFee?: {
+        feeCents: number;
+        currency: string;
+    } | null;
+    /**
+     * Held while it is paid for (`pending`): the shop's payment page to finish on - a path to
+     * resolve against the page's own address, like `createBooking`'s `payment.checkoutUrl`.
+     */
+    paymentUrl?: string | null;
+    /**
+     * The order attached to it - placed at checkout for the booking (`paid`), or its draft, paid at
+     * the table and changeable with `setCustomerBookingPreorder` until `cancellableUntil` - or null.
+     */
+    preorder?: PublicBookingPreorder | null;
+}
+/** One dish ordered ahead for a booking. Money in minor units. */
+export interface PublicBookingPreorderLine {
+    /** Null once the product is deleted. */
+    productId: string | null;
+    name: string;
+    quantity: number;
+    unitPriceCents: number;
+    /** `unitPrice × quantity − discount`. */
+    totalCents: number;
+}
+/**
+ * The order attached to a booking: placed at checkout for it (`createCheckout` with
+ * `bookingId`; `paid`), or its draft - paid at the table, changeable with
+ * `setCustomerBookingPreorder`.
+ */
+export interface PublicBookingPreorder {
+    orderId: string;
+    orderNumber: number;
+    lines: PublicBookingPreorderLine[];
+    /** Minor units of `currency`. */
+    totalCents: number;
+    currency: string;
+    /** Placed and paid (online or at the counter); false: a draft, paid at the table. */
+    paid: boolean;
+}
+/** Every dish to order ahead for a booking and how many, replacing what was there. */
+export interface SetBookingPreorderParams extends CustomerTokenParams {
+    /** The booking - its `bookingNumber` (`12`) or its `bookingId`. */
+    bookingId: string | number;
+    /** A product of the shop, on sale, 1 to 99 of it; empty: no preorder. At most 50 lines. */
+    lines: {
+        productId: string;
+        quantity: number;
+    }[];
+}
+/** A page of a customer's history. */
+export interface CustomerPage<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        hasNext: boolean;
+    };
+}
+export interface CustomerHistoryParams {
+    page?: number;
+    /** At most 50; 20 by default. */
+    limit?: number;
+}
+export interface CustomerBookingsParams extends CustomerHistoryParams {
+    /** `upcoming` (default): still ahead, soonest first. `past`: over or called off, latest first. */
+    scope?: "upcoming" | "past" | "all";
+}
+/**
+ * The signed-in customer, with their latest five orders and next five bookings — an account
+ * page's first screen. The full lists: `getCustomerOrders`, `getCustomerBookings`.
+ */
+export interface PublicCustomerAccount extends PublicCustomer {
+    orders: PublicCustomerOrder[];
+    bookings: PublicCustomerBooking[];
+}
+export interface RequestSignInCodeParams {
+    email: string;
+}
+export interface VerifySignInCodeParams {
+    email: string;
+    /** The six digits from the email. */
+    code: string;
+}
+export interface SignInWithGoogleParams {
+    /** The ID token (`credential`) Google Identity Services gave the page. */
+    idToken: string;
+}
+export interface SignInWithAppleParams {
+    /** The ID token (`credential`) the platform's Apple sign-in page posted back. */
+    idToken: string;
+    /**
+     * The person's "First Last", which Apple posts beside the token on the FIRST sign-in only -
+     * the token never carries it. Leave it out when there is none.
+     */
+    name?: string | null;
+}
+export interface CustomerTokenParams {
+    /** The token from `verifySignInCode`, `signInWithGoogle` or `signInWithApple`. */
+    customerToken: string;
+}
+/**
+ * A place the signed-in customer has had an order delivered to, or saved themselves. One per
+ * address and details: the same one again only moves `lastUsedAt`.
+ */
+export interface PublicCustomerAddress {
+    customerAddressId: string;
+    /** The address as it was picked - one line. */
+    address: string;
+    /** Flat, floor, gate code - whatever the driver needs on top of the address. */
+    details: string | null;
+    /** Where it is; null for an address kept without a point. */
+    latitude: number | null;
+    longitude: number | null;
+    postcode: string | null;
+    /** ISO 8601. The list is ordered by it, the one used last first. */
+    lastUsedAt: string;
+}
+/**
+ * A card the signed-in customer saved paying at this shop: what it is and when it expires.
+ * Nothing in it can pay - the card stays with Stripe, and `id` is only a handle for removing it.
+ */
+export interface PublicCustomerPaymentMethod {
+    /** A handle for `deleteCustomerPaymentMethod` - not Stripe's id, and of no use to pay with. */
+    id: string;
+    /** Stripe's card brand: `visa`, `mastercard`, `amex`... */
+    brand: string;
+    last4: string;
+    expMonth: number;
+    expYear: number;
+    /** The wallet it was added from (`apple_pay`, `google_pay`), if any. */
+    wallet: string | null;
+    /** An upcoming booking keeps it (a late-cancellation fee): it cannot be removed until then. */
+    inUse: boolean;
+}
+/** An address to save, as a checkout gives one: the address, and its point when known. */
+export interface AddCustomerAddressParams extends CustomerTokenParams {
+    address: string;
+    details?: string | null;
+    latitude?: number | null;
+    longitude?: number | null;
+    postcode?: string | null;
+}
+export interface UpdateCustomerProfileParams extends CustomerTokenParams {
+    name?: string | null;
+    phone?: string | null;
+    /** `YYYY-MM-DD`, in the past. */
+    dateOfBirth?: string | null;
+    /**
+     * True: the customer accepts the shop's terms (`getTerms()`) - kept with its time, from the
+     * first time. Only ever from a box they ticked themselves.
+     */
+    acceptTerms?: boolean;
+    /** True: they consent to the shop keeping health information; false: withdrawn. */
+    healthConsent?: boolean;
+    /**
+     * The language they just chose to read the shop in, an ISO code - kept on their account and
+     * answered as `PublicCustomer.language` wherever they sign in. Null forgets it.
+     */
+    language?: string | null;
+}
+/** Money off for paying one way: an amount in MINOR units of the shop's currency, or a percent. */
+export interface PublicPaymentDiscount {
+    kind: "amount" | "percent";
+    value: number;
+}
+/** The discount for each way of paying, or null for none. */
+export interface PublicPaymentDiscounts {
+    online: PublicPaymentDiscount | null;
+    inStore: PublicPaymentDiscount | null;
+}
+/**
+ * How customers vote, as the shop set it (Sales rules → Social): not at all, a like only (`up` -
+ * no dislikes; its votes read as `like`, with `dislikes` 0), a like or a dislike, or stars.
+ */
+export type ProductVoting = "off" | "up" | "like" | "range";
+/**
+ * The votes on a product, the shop's way: stars (`range` - `average` of up to `max`) or likes
+ * (`likes` and `dislikes`), and the viewer's own.
+ */
+export interface PublicProductRating {
+    method: "like" | "range";
+    /** Average stars, to one decimal; null before anyone rated. */
+    average: number | null;
+    /** Customers who voted on it. */
+    count: number;
+    /** The top of the scale - 1 for likes. */
+    max: number;
+    likes: number;
+    dislikes: number;
+    /** The signed-in customer's own vote - stars, or 1 / -1; null when none. */
+    mine: number | null;
+}
+/**
+ * What a product takes - comments, stars, likes on comments - and what has been said. The
+ * shop turns each on in its product settings; a product that takes none answers all `false`.
+ */
+export interface PublicProductFeedback {
+    allowComments: boolean;
+    allowRating: boolean;
+    allowCommentVotes: boolean;
+    /** How customers vote on this product - `off` when they don't. */
+    productVoting: ProductVoting;
+    /** How customers vote on its comments - `off` when they don't (always, without comments). */
+    commentVoting: ProductVoting;
+    /** How many stars a comment is rated out of, while `commentVoting` is `range`. */
+    commentStars: number;
+    /** Comments and replies, together. */
+    commentCount: number;
+    rating: PublicProductRating;
+    /**
+     * A vote comes with a comment (Sales rules → Social): `rateProduct` is refused
+     * (`vote_needs_comment`) until the customer has a comment of their own on the product - cast
+     * it with the comment instead (`createProductComment`'s `vote`). Deleting their last comment
+     * takes their vote back. Only while comments and product votes are both on.
+     */
+    voteNeedsComment: boolean;
+}
+/** One comment on a product, or a reply to one. Threads are one level deep. */
+export interface PublicProductComment {
+    id: string;
+    /** The root it replies to, or null for a root. */
+    parentId: string | null;
+    body: string;
+    /** ISO timestamp. */
+    createdAt: string;
+    /** Replies under this root (0 on a reply). */
+    replyCount: number;
+    likes: number;
+    dislikes: number;
+    /** Average stars, while comments are voted on with stars; null before anyone rated. */
+    ratingAverage: number | null;
+    ratingCount: number;
+    /**
+     * Who wrote it. `fromShop`: the shop's own reply, written in its admin - `name` is then the
+     * shop's name; mark it as the shop's.
+     */
+    author: {
+        name: string | null;
+        avatarUrl: string | null;
+        fromShop: boolean;
+    };
+    /** The signed-in customer's vote on it: 1 / -1, or stars; 0 for none. */
+    myVote: number;
+    /**
+     * The author's own vote on the product - stars, or 1 / -1 - for a review's stars or thumb
+     * beside the name. Null when they cast none, and always on a reply.
+     */
+    authorVote: number | null;
+    /** Written by the signed-in customer - they may delete it. */
+    mine: boolean;
+}
+/** A page of comments. `total` counts every comment the page is a slice of. */
+export interface PublicProductCommentsPage {
+    data: PublicProductComment[];
+    pagination: {
+        page: number;
+        limit: number;
+        hasNext: boolean;
+    };
+    total: number;
+}
+export interface GetProductFeedbackParams {
+    productId: string;
+    /** A signed-in customer, for their own stars. */
+    customerToken?: string;
+}
+export interface GetProductCommentsParams {
+    productId: string;
+    /** A root comment: its replies, oldest first. Without it, the roots, newest first. */
+    parentId?: string;
+    page?: number;
+    /** Up to 50; 20 by default. */
+    limit?: number;
+    /** A signed-in customer, for `mine` and `myVote`. */
+    customerToken?: string;
+}
+export interface CreateProductCommentParams extends CustomerTokenParams {
+    productId: string;
+    /** Up to 2000 characters. */
+    body: string;
+    /** The comment this replies to - a reply to a reply is filed under the same root. */
+    parentId?: string;
+    /**
+     * The customer's vote on the product, cast with the comment (a review) - the shop's way, as
+     * `RateProductParams.value`. A root comment only; required in practice while
+     * `voteNeedsComment` is on, as `rateProduct` alone is refused then.
+     */
+    vote?: number;
+}
+/** A comment's votes after one was cast. */
+export interface PublicCommentVoteResult {
+    likes: number;
+    dislikes: number;
+    ratingAverage: number | null;
+    ratingCount: number;
+    myVote: number;
+}
+export interface RateProductParams extends CustomerTokenParams {
+    productId: string;
+    /**
+     * The shop's way (`productVoting`): 1 to `rating.max` stars, or 1 like / -1 dislike - a like
+     * (1) only, under `up`.
+     */
+    value: number;
+}
+export interface UnrateProductParams extends CustomerTokenParams {
+    productId: string;
+}
+export interface VoteProductCommentParams extends CustomerTokenParams {
+    productId: string;
+    commentId: string;
+    /** The shop's way (`commentVoting`): 1 / -1, or 1 to `commentStars`; 0 takes it back. */
+    value: number;
+}
+export interface DeleteProductCommentParams extends CustomerTokenParams {
+    productId: string;
+    /** One of the customer's own comments. A root goes with its replies. */
+    commentId: string;
+}