@estoreclub/api 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,166 @@
+import {
+  addCartItem,
+  addCustomerAddress,
+  addCustomerFavourite,
+  cancelCustomerBooking,
+  createBooking,
+  createCart,
+  createCheckout,
+  createProductComment,
+  deleteCustomerAddress,
+  deleteCustomerPaymentMethod,
+  deleteProductComment,
+  destroyCart,
+  getBookingPlan,
+  getBookingSlots,
+  getCart,
+  getCategories,
+  getCategory,
+  getCheckout,
+  getCombos,
+  getCustomerAccount,
+  getCustomerAddresses,
+  getCustomerBookings,
+  getCustomerFavouriteIds,
+  getCustomerFavourites,
+  getCustomerOrder,
+  getCustomerOrders,
+  getCustomerPaymentMethods,
+  getDictionaries,
+  getDictionary,
+  getDiningTable,
+  getDiscountRules,
+  getLocations,
+  getOrderTimes,
+  getProduct,
+  getProductComments,
+  getProductFeedback,
+  getProductSettings,
+  getProducts,
+  getSiteInfo,
+  getTerms,
+  listDictionaries,
+  lookupImages,
+  rateProduct,
+  removeCartItem,
+  removeCustomerFavourite,
+  requestSignInCode,
+  resetSiteData,
+  setCartBooking,
+  setCartItemQuantity,
+  setCheckoutEmail,
+  setCustomerBookingPreorder,
+  signInWithApple,
+  signInWithGoogle,
+  trackOrder,
+  unrateProduct,
+  updateCustomerProfile,
+  verifyDiningTableCode,
+  verifySignInCode,
+  voteProductComment
+} from "./chunks/chunk-ZITPZDI7.js";
+import "./chunks/chunk-DUVULZ6N.js";
+import {
+  createPublicApiClient
+} from "./chunks/chunk-5DN7L6LX.js";
+import {
+  runWithRequestCache
+} from "./chunks/chunk-2BH4QPV2.js";
+import {
+  countryFromHeaders,
+  getVisitorCountryResolver,
+  setVisitorCountryResolver
+} from "./chunks/chunk-2554RPSS.js";
+import {
+  getCompanyApiKey,
+  setCompanyApiKey
+} from "./chunks/chunk-TSERNR4R.js";
+import {
+  getCustomerTokenResolver,
+  setCustomerTokenResolver
+} from "./chunks/chunk-OFFTL6RC.js";
+import {
+  PublicApiError
+} from "./chunks/chunk-GJZ7EZEF.js";
+import {
+  getLanguageResolver,
+  setLanguageResolver
+} from "./chunks/chunk-HFEQWXG6.js";
+import {
+  MAX_LIMIT
+} from "./chunks/chunk-3KEEGSMP.js";
+export {
+  MAX_LIMIT,
+  PublicApiError,
+  addCartItem,
+  addCustomerAddress,
+  addCustomerFavourite,
+  cancelCustomerBooking,
+  countryFromHeaders,
+  createBooking,
+  createCart,
+  createCheckout,
+  createProductComment,
+  createPublicApiClient,
+  deleteCustomerAddress,
+  deleteCustomerPaymentMethod,
+  deleteProductComment,
+  destroyCart,
+  getBookingPlan,
+  getBookingSlots,
+  getCart,
+  getCategories,
+  getCategory,
+  getCheckout,
+  getCombos,
+  getCompanyApiKey,
+  getCustomerAccount,
+  getCustomerAddresses,
+  getCustomerBookings,
+  getCustomerFavouriteIds,
+  getCustomerFavourites,
+  getCustomerOrder,
+  getCustomerOrders,
+  getCustomerPaymentMethods,
+  getCustomerTokenResolver,
+  getDictionaries,
+  getDictionary,
+  getDiningTable,
+  getDiscountRules,
+  getLanguageResolver,
+  getLocations,
+  getOrderTimes,
+  getProduct,
+  getProductComments,
+  getProductFeedback,
+  getProductSettings,
+  getProducts,
+  getSiteInfo,
+  getTerms,
+  getVisitorCountryResolver,
+  listDictionaries,
+  lookupImages,
+  rateProduct,
+  removeCartItem,
+  removeCustomerFavourite,
+  requestSignInCode,
+  resetSiteData,
+  runWithRequestCache,
+  setCartBooking,
+  setCartItemQuantity,
+  setCheckoutEmail,
+  setCompanyApiKey,
+  setCustomerBookingPreorder,
+  setCustomerTokenResolver,
+  setLanguageResolver,
+  setVisitorCountryResolver,
+  signInWithApple,
+  signInWithGoogle,
+  trackOrder,
+  unrateProduct,
+  updateCustomerProfile,
+  verifyDiningTableCode,
+  verifySignInCode,
+  voteProductComment
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/language.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The language the site is being read in, for the calls that answer in one.
+ *
+ * The public API resolves every name, description and dictionary entry into the language named
+ * by the `x-language` header, and falls back to English without it — so a site that never said
+ * which language it was in was an English site, whatever the shop wrote in.
+ *
+ * Which language a visitor is reading is the SITE's knowledge — a cookie, a path segment, a
+ * header of its own — and it is per request, not per process. So the site hands in a resolver,
+ * asked at the moment of each call, the same way the key is supplied: once, where the site sets
+ * itself up, rather than as a parameter every call has to remember.
+ *
+ * The resolver is not asked for the company lookup (`getSiteInfo`), which needs no language,
+ * so it may itself read the company's default language without looping.
+ */
+export type LanguageResolver = () => string | null | undefined | Promise<string | null | undefined>;
+export declare function setLanguageResolver(next: LanguageResolver | null): void;
+/**
+ * The resolver in force, so a caller can override it for one render and put it back.
+ *
+ * The render tier does this: it sets a resolver that returns the request's language, renders, and
+ * restores the site's own resolver in a `finally`. Without the getter there is no way to restore
+ * exactly what was there before.
+ */
+export declare function getLanguageResolver(): LanguageResolver | null;
+/** The language to send, or undefined for the API's default. Never throws. */
+export declare function resolveLanguage(): Promise<string | undefined>;

package/dist/language.js

@@ -0,0 +1,11 @@
+import {
+  getLanguageResolver,
+  resolveLanguage,
+  setLanguageResolver
+} from "./chunks/chunk-HFEQWXG6.js";
+export {
+  getLanguageResolver,
+  resolveLanguage,
+  setLanguageResolver
+};
+//# sourceMappingURL=language.js.map

package/dist/language.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/params.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Turning a caller's parameters into a query string, defensively.
+ *
+ * Written for the worst caller there is: page code inside the sandbox, which can send any
+ * JSON at all. Every value is checked here rather than trusted, because the check that
+ * matters is the one on this side of the boundary.
+ */
+/** The largest page the API will be asked for, whatever a caller requests. */
+export declare const MAX_LIMIT = 200;
+/**
+ * A path segment supplied by a caller goes into a URL, so it is validated rather than
+ * escaped: an id is a slug, a UUID or an entity's number, and anything else is a mistake or an attempt to reach a
+ * different endpoint by writing `../`.
+ */
+export declare function segment(value: unknown, name: string): string;
+/**
+ * A NAME a caller looks something up by — a category, a product, one of the shop's lists.
+ *
+ * `segment` is for ids, which are `[A-Za-z0-9_-]` by construction. A name is not: it is free
+ * text a shop typed, in whatever language it writes in, and "Pizza sizes", "Añadidos" and
+ * "Пиццы" are all ordinary ones. Refusing them is how a page asking for a real category got
+ * "invalid name" thrown at it.
+ *
+ * These names travel in the QUERY STRING, where `URLSearchParams` does the encoding — so this
+ * only has to refuse what is not a name at all: nothing, something absurdly long, or a
+ * control character.
+ */
+export declare function label(value: unknown, name: string): string;
+/**
+ * `{ id }` or `{ name }` as query parameters — exactly one of them.
+ *
+ * Refused here rather than left to the server's 400: a page that passes both has a bug the
+ * server would report as "data unavailable (400)", which reads like an outage.
+ */
+export declare function idOrName(params: unknown): Record<string, string>;
+/**
+ * The `include` parameter: which optional parts of a response to carry.
+ *
+ * `undefined` means EVERY part in `allowed` — the shape a page written before `include`
+ * existed relies on. An empty list means none, and sends nothing (the API's own default).
+ * Anything outside `allowed` is refused rather than dropped, so a typo cannot silently cost
+ * a page its images.
+ */
+export declare function include<T extends string>(value: readonly T[] | undefined, allowed: readonly T[]): Record<string, string>;
+/** Bound the paging so one call cannot ask for an entire catalogue. */
+export declare function paging(params: {
+    page?: unknown;
+    limit?: unknown;
+}): Record<string, string>;
+/** A string parameter, included only when it is one. */
+export declare function text(key: string, value: unknown): Record<string, string>;
+/** One of a fixed set of words, included only when it is one of them. */
+export declare function oneOf(key: string, value: unknown, allowed: readonly string[]): Record<string, string>;
+/** A whole number within bounds, included only when it is one — clamped, not refused. */
+export declare function whole(key: string, value: unknown, min: number, max: number): Record<string, string>;
+/** A boolean parameter, included only when it is explicitly true. */
+export declare function flag(key: string, value: unknown): Record<string, string>;
+export declare function trimSlash(value: string): string;

package/dist/params.js

@@ -0,0 +1,27 @@
+import {
+  MAX_LIMIT,
+  flag,
+  idOrName,
+  include,
+  label,
+  oneOf,
+  paging,
+  segment,
+  text,
+  trimSlash,
+  whole
+} from "./chunks/chunk-3KEEGSMP.js";
+export {
+  MAX_LIMIT,
+  flag,
+  idOrName,
+  include,
+  label,
+  oneOf,
+  paging,
+  segment,
+  text,
+  trimSlash,
+  whole
+};
+//# sourceMappingURL=params.js.map

package/dist/params.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/requestCache.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A per-render dedup cache for GET reads — alive ONLY for the duration of one render.
+ *
+ * `React.cache()` — which the site's data readers rely on to share one fetch across the many
+ * components that need it — does NOTHING under `react-dom/static.prerender` (it is an RSC-only
+ * feature with no cache scope here). Without a replacement, one page render fired the SAME
+ * `getDictionary` / `getSiteInfo` / `getProducts` request dozens of times.
+ *
+ * This is that replacement, at the one place every read passes through. The SSR bootstrap wraps a
+ * render in `runWithRequestCache`, which turns the cache ON for exactly that render and OFF again
+ * when it settles (success OR error). Outside a render — the browser, a standalone script, the
+ * long-lived multi-tenant RPC server — the cache is simply absent (`store === null`), so `memoGet`
+ * is a pure passthrough and no request state is ever held between renders or shared between them.
+ *
+ * SAFETY (why a module-level Map does not leak across tenants or parallel calls):
+ *  - Scope: the Map exists only while a render runs and is dropped in `finally`, so nothing lingers
+ *    after a render and nothing exists when no render is running.
+ *  - Tenant: the memo KEY includes the company key + product-sample dataset + language, not just the
+ *    URL (see `request()` in `client.ts`) — `getSiteInfo` is `/company` for every tenant, so a
+ *    URL-only key WOULD collide. Two tenants can never read each other's entry even if a `store`
+ *    were momentarily shared.
+ *  - Concurrency: the platform renders each page in its own sandbox process (one render at a time)
+ *    and the dev server serialises renders, so the module `store` belongs to one render. Even if two
+ *    renders ever overlapped in one process, `runWithRequestCache` save/restores the previous store
+ *    and the tenant-scoped keys mean the worst case is a few extra fetches — never wrong data.
+ *  - Only reads are memoised (GETs, and the few POSTs that only read - see `READ_POSTS` in
+ *    `client.ts`); mutations never reach here.
+ *  - A failed read IS remembered, for this render only: every component asking again would get
+ *    the same answer - a shop over its daily allowance gets 429 - and each retry is one more
+ *    counted call. The next render asks afresh.
+ *
+ * Deliberately dependency-free (no `async_hooks` — a Node builtin the platform's render sandbox
+ * cannot import).
+ */
+/**
+ * Run one render with GET dedup enabled, then tear the cache down.
+ *
+ * `finally` guarantees the cache is dropped even if the render throws. `previous` is restored
+ * rather than forced to `null` so a nested or overlapping scope leaves things as it found them.
+ */
+export declare function runWithRequestCache<T>(render: () => Promise<T>): Promise<T>;
+/**
+ * Return the memoised result for `key`, or compute and store it. When no render scope is active
+ * (`store === null`), it just runs `compute` — no caching, no state, no staleness.
+ */
+export declare function memoGet<T>(key: string, compute: () => Promise<T>): Promise<T>;

package/dist/requestCache.js

@@ -0,0 +1,9 @@
+import {
+  memoGet,
+  runWithRequestCache
+} from "./chunks/chunk-2BH4QPV2.js";
+export {
+  memoGet,
+  runWithRequestCache
+};
+//# sourceMappingURL=requestCache.js.map

package/dist/requestCache.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/siteData.d.ts

@@ -0,0 +1,237 @@
+import type { CreateBookingParams, CustomerTokenParams, SetBookingPreorderParams, CustomerHistoryParams, CustomerBookingsParams, AddCustomerAddressParams, CreateProductCommentParams, DeleteProductCommentParams, GetProductCommentsParams, GetProductFeedbackParams, RateProductParams, UnrateProductParams, VoteProductCommentParams, GetBookingPlanParams, GetBookingSlotsParams, GetOrderTimesParams, GetCategoryParams, GetDictionaryParams, GetProductParams, ListCategoriesParams, ListCombosParams, ListProductsParams, RequestSignInCodeParams, SignInWithAppleParams, SignInWithGoogleParams, UpdateCustomerProfileParams, VerifySignInCodeParams } from "./types";
+/**
+ * Every export below is `async`, and that is load-bearing rather than stylistic.
+ *
+ * A page handles an unavailable call with `.catch()` or a rejection handler. If a missing
+ * environment variable were THROWN synchronously, it would throw before the caller had a
+ * handler attached, and a page's `.catch()` would never run.
+ */
+export declare function getSiteInfo(): Promise<import("./types").PublicSiteInfo>;
+/** Categories. Every optional part (`include`) unless the page narrows it. */
+export declare function getCategories(params?: ListCategoriesParams): Promise<import("./types").PublicCategory[]>;
+/** One category by `{ id }` or `{ name }`. */
+export declare function getCategory(params: GetCategoryParams): Promise<import("./types").PublicCategory>;
+/** One product by `{ id }` or `{ name }` — see `getCategory` for how a name is matched. */
+export declare function getProduct(params: GetProductParams): Promise<import("./types").PublicProduct>;
+/** The shop's locations, in its order — for a "find us" list or a map. */
+export declare function getLocations(): Promise<import("./types").PublicStoreLocation[]>;
+/** A table a guest is ordering from, by the id on its QR code. */
+export declare function getDiningTable(params: {
+    tableId: string;
+}): Promise<import("./types").PublicDiningTable>;
+/** Checks the code staff gave a guest at this table; rejects a wrong one. Books nothing. */
+export declare function verifyDiningTableCode(params: {
+    tableId: string;
+    code: string;
+}): Promise<void>;
+/** The shop's terms and privacy policy: whether they must be accepted, and the text (Markdown). */
+export declare function getTerms(params?: {
+    language?: string;
+}): Promise<import("./types").PublicTerms>;
+/** When an order can be for: now, and the later times on the location's clock. */
+export declare function getOrderTimes(params?: GetOrderTimesParams): Promise<import("./types").PublicOrderTimes>;
+/** The times a party can book on a day at a location, each free or full. */
+export declare function getBookingSlots(params: GetBookingSlotsParams): Promise<import("./types").PublicBookingSlots>;
+/** The location's floor plan at a time, which tables are free, and the best fit. */
+export declare function getBookingPlan(params: GetBookingPlanParams): Promise<import("./types").PublicBookingPlan>;
+/** Book a table — confirmed at once; 409 when none is free any more. */
+export declare function createBooking(params: CreateBookingParams): Promise<import("./types").PublicBooking>;
+/**
+ * Signing a customer in — the ways `getSiteInfo().customerSignInMethods` turns on.
+ *
+ * An emailed code (`requestSignInCode`, then `verifySignInCode`), Google (`signInWithGoogle`) or
+ * Apple (`signInWithApple`) answers with a `token`. Keep it in an httpOnly cookie set by the
+ * site's SERVER — never in page script — and pass it as `customerToken` to `createCheckout`,
+ * `createBooking` and the account calls: what is made with it belongs to the customer.
+ */
+export declare function requestSignInCode(params: RequestSignInCodeParams): Promise<{
+    expiresIn: number;
+}>;
+export declare function verifySignInCode(params: VerifySignInCodeParams): Promise<import("./types").PublicCustomerSession>;
+export declare function signInWithGoogle(params: SignInWithGoogleParams): Promise<import("./types").PublicCustomerSession>;
+export declare function signInWithApple(params: SignInWithAppleParams): Promise<import("./types").PublicCustomerSession>;
+/** The signed-in customer, with their recent orders and bookings. */
+export declare function getCustomerAccount(params: CustomerTokenParams): Promise<import("./types").PublicCustomerAccount>;
+/** The signed-in customer's orders on this site, newest first. */
+export declare function getCustomerOrders(params: CustomerTokenParams & CustomerHistoryParams): Promise<import("./types").CustomerPage<import("./types").PublicCustomerOrder>>;
+/** One of their orders, with its lines. */
+export declare function getCustomerOrder(params: CustomerTokenParams & {
+    orderId: string;
+}): Promise<import("./types").PublicCustomerOrderDetail>;
+/** Their bookings — upcoming by default. */
+export declare function getCustomerBookings(params: CustomerTokenParams & CustomerBookingsParams): Promise<import("./types").CustomerPage<import("./types").PublicCustomerBooking>>;
+/** Calls off one of their bookings, while it is still ahead. */
+export declare function cancelCustomerBooking(params: CustomerTokenParams & {
+    bookingId: string;
+}): Promise<import("./types").PublicCustomerBooking>;
+/** Sets the dishes they order ahead for one of their bookings, replacing what was there. */
+export declare function setCustomerBookingPreorder(params: SetBookingPreorderParams): Promise<{
+    preorder: import("./types").PublicBookingPreorder | null;
+}>;
+/** The places they have had orders delivered to, or saved - the one used last first. */
+export declare function getCustomerAddresses(params: CustomerTokenParams): Promise<{
+    data: import("./types").PublicCustomerAddress[];
+}>;
+/** Saves an address for them. */
+export declare function addCustomerAddress(params: AddCustomerAddressParams): Promise<import("./types").PublicCustomerAddress>;
+/** Forgets one of their addresses. */
+export declare function deleteCustomerAddress(params: CustomerTokenParams & {
+    customerAddressId: string;
+}): Promise<void>;
+/** The cards they saved paying here - nothing that can pay. */
+export declare function getCustomerPaymentMethods(params: CustomerTokenParams): Promise<{
+    data: import("./types").PublicCustomerPaymentMethod[];
+}>;
+/** Removes one of their saved cards; refused for one an upcoming booking keeps. */
+export declare function deleteCustomerPaymentMethod(params: CustomerTokenParams & {
+    paymentMethodId: string;
+}): Promise<void>;
+/** Their favourite products, as `getProducts` lists them - limited to the ones they added. */
+export declare function getCustomerFavourites(params: CustomerTokenParams & ListProductsParams): Promise<import("./types").Paginated<import("./types").PublicProduct>>;
+/** Just their favourites' ids, newest first - to fill in the hearts on a listing. */
+export declare function getCustomerFavouriteIds(params: CustomerTokenParams): Promise<{
+    productIds: string[];
+}>;
+/** Adds a product to their favourites; one already there stays once. */
+export declare function addCustomerFavourite(params: CustomerTokenParams & {
+    productId: string;
+}): Promise<void>;
+/** Takes a product out of their favourites; one not there is no error. */
+export declare function removeCustomerFavourite(params: CustomerTokenParams & {
+    productId: string;
+}): Promise<void>;
+/** Changes the signed-in customer's name or phone. */
+export declare function updateCustomerProfile(params: UpdateCustomerProfileParams): Promise<import("./types").PublicCustomer>;
+/**
+ * What customers say about a product — only what the shop turned on for it
+ * (`getProductFeedback`). Anyone may read; a comment needs a signed-in customer's token.
+ */
+export declare function getProductFeedback(params: GetProductFeedbackParams): Promise<import("./types").PublicProductFeedback>;
+/** A product's comments, newest first — or, with `parentId`, one root's replies. */
+export declare function getProductComments(params: GetProductCommentsParams): Promise<import("./types").PublicProductCommentsPage>;
+/** Comment on a product as the signed-in customer, or reply with `parentId`. */
+export declare function createProductComment(params: CreateProductCommentParams): Promise<import("./types").PublicProductComment>;
+/** Remove one of the signed-in customer's own comments. */
+export declare function deleteProductComment(params: DeleteProductCommentParams): Promise<void>;
+/** The signed-in customer's vote on a product, the shop's way - stars or a like. */
+export declare function rateProduct(params: RateProductParams): Promise<import("./types").PublicProductRating>;
+/** Take the signed-in customer's vote on a product back. */
+export declare function unrateProduct(params: UnrateProductParams): Promise<import("./types").PublicProductRating>;
+/** The signed-in customer's vote on a comment; 0 takes it back. */
+export declare function voteProductComment(params: VoteProductCommentParams): Promise<import("./types").PublicCommentVoteResult>;
+/**
+ * The shop's settings catalogue: which fields it keeps on a product, what each holds, which it
+ * shows. `{ tagsOnly: true }` for just the yes/no fields `getProducts({ tags })` filters on.
+ */
+export declare function getProductSettings(params?: {
+    tagsOnly?: boolean;
+}): Promise<import("./types").PublicProductSettingDefinition[]>;
+/** The combos on sale now, with their slots — optionally only those shown in one category. */
+export declare function getCombos(params?: ListCombosParams): Promise<import("./types").PublicCombo[]>;
+/** The discount rules on now, for badging the products they target. */
+export declare function getDiscountRules(): Promise<import("./types").PublicDiscountRule[]>;
+/** Every list the shop can read, with columns but no entries. */
+export declare function listDictionaries(): Promise<import("./types").PublicDictionarySummary[]>;
+/** One list, with its entries, by `{ identifier }` — or by `{ id }` / `{ name }`. */
+export declare function getDictionary(params: GetDictionaryParams): Promise<import("./types").PublicDictionary>;
+/** Several lists in one request, by identifier — the batch form of `getDictionary`. */
+export declare function getDictionaries(params: {
+    identifiers: string[];
+}): Promise<import("./types").PublicDictionary[]>;
+/**
+ * Size and resized copies of pictures held only as URLs, for `Image` — see the client's
+ * `lookupImages`.
+ */
+export declare function lookupImages(params: {
+    urls: string[];
+}): Promise<import("./types").PublicImage[]>;
+/** Products, paginated. Every optional part (`include`) unless the page narrows it. */
+export declare function getProducts(params?: ListProductsParams): Promise<import("./types").Paginated<import("./types").PublicProduct>>;
+/**
+ * The cart, through the same environment-configured client.
+ *
+ * `createCart()` first; everything after it needs the id it returns. That id is the CREDENTIAL
+ * for the cart — there is no visitor account — so it belongs in a cookie or in storage the
+ * page controls, never in a URL a visitor might share and never in anything rendered.
+ *
+ * The server also sets it as a cookie, so a browser calling from the same site can rely on
+ * that. This client passes it explicitly anyway: a server component has no cookie jar, and an
+ * explicit id cannot be quietly swapped for whatever the jar last held.
+ */
+export declare function createCart(): Promise<import("./types").PublicCart>;
+export declare function getCart(params: {
+    cartId: string;
+}): Promise<import("./types").PublicCart>;
+export declare function addCartItem(params: {
+    cartId: string;
+    productId: string;
+    quantity?: number;
+    variantId?: string;
+    variant?: string;
+}): Promise<import("./types").PublicCart>;
+export declare function setCartItemQuantity(params: {
+    cartId: string;
+    cartItemId: string;
+    quantity: number;
+}): Promise<import("./types").PublicCart>;
+export declare function removeCartItem(params: {
+    cartId: string;
+    cartItemId: string;
+}): Promise<import("./types").PublicCart>;
+export declare function setCartBooking(params: {
+    cartId: string;
+    bookingId: string | null;
+}): Promise<import("./types").PublicCart>;
+export declare function destroyCart(params: {
+    cartId: string;
+}): Promise<void>;
+/**
+ * Read a checkout: the order as it will be charged, and — while it can still be paid — the
+ * Stripe secrets to charge it with.
+ *
+ * This is what a site's OWN checkout page uses instead of sending the shopper to the hosted
+ * one: read it in a server component, pass `payment` down to a `"use client"` component, and
+ * mount Stripe's `<Elements>` / `<PaymentElement>` on it. The card is typed into Stripe's
+ * iframe; page code never sees it. Read it again when the shopper comes back from payment —
+ * `status` is `paid`, `failed` or still `pending` while the bank confirms.
+ */
+export declare function getCheckout(params: {
+    checkoutId: string;
+}): Promise<import("./types").PublicCheckoutSession>;
+/**
+ * Find a placed order for the shop's tracking page - no sign-in: `code`, its delivery's tracking
+ * number (`K7P-QX9-M2T`, in the order's emails and on the customer's order), with the order's
+ * `email` - while the shop allows it (`getSiteInfo().publicOrderTracking`); or `checkoutId` alone
+ * (the confirmation link's). Answers as `getCustomerOrder` does, `shipment` set once a carrier
+ * has the parcel. Any mismatch rejects with a 404 (`order_track_not_found`).
+ */
+export declare function trackOrder(params: {
+    code?: string;
+    email?: string;
+    checkoutId?: string;
+}): Promise<import("./types").PublicCustomerOrderDetail>;
+/**
+ * Record who is paying, from the site's own payment page. Answers with the checkout as
+ * `getCheckout` does, now offering the cards that shopper saved at this shop.
+ */
+export declare function setCheckoutEmail(params: {
+    checkoutId: string;
+    email: string;
+}): Promise<import("./types").PublicCheckoutSession>;
+/**
+ * Pay for the basket: creates a checkout from the cart and answers with `checkoutUrl`, the
+ * hosted page the shopper's browser should be sent to — or, with `getCheckout`, the id of a
+ * checkout the site takes the payment for itself.
+ *
+ * Return that address from the server action and leave for it in the client —
+ * `window.location.assign(checkoutUrl)`. NOT `redirect()`: the payment page is a separate app
+ * under `/c/` on the same host, and a router navigation would ask this site to render it.
+ */
+export declare function createCheckout(params: {
+    cartId: string;
+    customerEmail?: string;
+    successUrl?: string;
+    cancelUrl?: string;
+}): Promise<import("./types").PublicCheckout>;
+/** Drop the cached client. For tests, and for a process that changes its environment. */
+export declare function resetSiteData(): void;