@growupsell/commerce 0.0.0-stage → 1.0.0-alpha.2

package/dist/client-D4JNDM6j.d.ts

@@ -0,0 +1,1900 @@
+import { C as Cart, l as OrderType, d as CartTotals, U as TaxDetails, j as DeliveryEstimate, g as CategoryTree, f as Category, B as Brand, e as CatalogSettings, x as ProductSection, p as ProductBlock, y as ProductSectionItem, w as ProductSearchOptions, P as Page, t as ProductListItem, u as ProductOverview, q as ProductDetail, r as ProductFilterConfig, V as VariantGroup, S as SearchSuggestion, O as Offer, J as PromoCode, G as GiftCard, Q as RewardPointSettings, L as ReviewListItem, N as ReviewSummary, K as ReviewEligibility, R as Review, E as ProductSku, i as CustomerProfile, h as CheckoutSettings, o as PlaceOrderResult, A as AdvanceOrder, n as PendingPayment, m as PaymentMethodType } from './checkout-CwpFl6qt.js';
+
+/** The editor the merchant wrote the post with; decides how `body` sections are styled. */
+type BlogEditor = 'quill' | 'ckeditor' | 'froala';
+interface BlogCategory {
+    id: number;
+    name: string | null;
+    slug: string;
+    image: string | null;
+    seoDescription: string | null;
+}
+/** The staff member who wrote the post. Their email is never exposed. */
+interface BlogAuthor {
+    id: number;
+    name: string | null;
+    photo: string | null;
+}
+interface BlogPostSummary {
+    id: number;
+    slug: string;
+    title: string;
+    shortDescription: string | null;
+    image: string | null;
+    category: BlogCategory | null;
+    tags: string[];
+    /** Null when the author's account was deleted. */
+    author: BlogAuthor | null;
+    /** The merchant panel has no publish switch yet, so this is false for most posts (W29). */
+    isPublished: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface BlogPost extends BlogPostSummary {
+    /** HTML sections, in order. Raw merchant HTML: sanitise before rendering. */
+    body: string[];
+    editor: BlogEditor;
+}
+
+/**
+ * Structural types for the HTTP layer. `commerce` has no DOM or Node types (ADR-009), so the
+ * parts of `fetch` it uses are described here. Any standard `fetch` satisfies `FetchLike`.
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** Anything with `append`, e.g. the platform's `FormData` (React Native's included). */
+interface FormDataLike {
+    append(name: string, value: unknown, fileName?: string): void;
+}
+interface FetchInitLike {
+    method: HttpMethod;
+    headers: Record<string, string>;
+    body?: string | FormDataLike;
+    /** An `AbortSignal` when the runtime has `AbortController`. */
+    signal?: unknown;
+}
+interface FetchResponseLike {
+    readonly ok: boolean;
+    readonly status: number;
+    text(): Promise<string>;
+    /** Read for the content type of binary responses. Optional, so older custom fetches fit. */
+    readonly headers?: {
+        get(name: string): string | null;
+    };
+    /** Needed only for `responseType: 'binary'` (PDF downloads). */
+    arrayBuffer?(): Promise<ArrayBuffer>;
+}
+/** What a request with `responseType: 'binary'` resolves with. */
+interface BinaryResponse {
+    /** The response's `content-type`, e.g. `application/pdf`; `null` when unknown. */
+    contentType: string | null;
+    data: ArrayBuffer;
+}
+/** What the client calls. Write custom fetch functions (logging, guards, tests) to this type. */
+type FetchLike = (url: string, init: FetchInitLike) => Promise<FetchResponseLike>;
+/**
+ * What the `fetch` option accepts: `FetchLike`, or the platform's own `fetch` (browser,
+ * React Native, Node) without a cast. The platform's `RequestInit` type is stricter than
+ * `FetchInitLike` (it needs DOM types `commerce` cannot use), so `init` is typed `never`
+ * here, which every fetch implementation accepts. The client always passes a `FetchInitLike`.
+ * Proven by a type test in tests/http/client.test.ts.
+ */
+type AnyFetch = (url: string, init: never) => Promise<FetchResponseLike>;
+/**
+ * Who the request is for. Read before every request, so tokens can change and can come from
+ * async storage (Expo SecureStore).
+ */
+interface Credentials {
+    /** Sent as the `business` header. */
+    businessId?: number | string | null;
+    /** Logged-in customer: `x-customer-token`. */
+    customerToken?: string | null;
+    /** Guest or order session: `x-session-token`. */
+    sessionToken?: string | null;
+    /** Merchant: `Authorization: Token …`, only on requests made with `merchant: true`. */
+    merchantToken?: string | null;
+}
+interface UnauthorizedEvent {
+    /**
+     * Which token the backend rejected. `session`: the guest session (`x-session-token`) is
+     * unknown to the backend; drop it and create a new one with `session.create()`.
+     */
+    kind: 'customer' | 'merchant' | 'session';
+    /**
+     * The rejected token, so a holder of several logins can tell whether the current one expired
+     * or a request sent with an older one came back late. Compare it and drop it: never persist,
+     * log or send it anywhere.
+     */
+    token: string;
+}
+interface ClientOptions {
+    /** Backend base URL, e.g. `https://api.example.com`. Required: no default backend. */
+    baseURL: string;
+    credentials?: () => Credentials | Promise<Credentials>;
+    /**
+     * Called once per rejected token (never for requests that sent no token). The app decides
+     * what to do: reload on web, go to the login screen on mobile.
+     */
+    onUnauthorized?: (event: UnauthorizedEvent) => void;
+    /** Defaults to the global `fetch`. Inject one to add logging, guards or a test double. */
+    fetch?: AnyFetch;
+    /** Abort requests slower than this. Default 15000 ms. */
+    timeoutMs?: number;
+}
+type QueryValue = string | number | boolean | null | undefined | ReadonlyArray<string | number | boolean>;
+type Query = Record<string, QueryValue>;
+interface RequestOptions {
+    query?: Query;
+    /** Sent as JSON. */
+    json?: unknown;
+    /** Sent as multipart form data (file uploads). */
+    formData?: FormDataLike;
+    /** Merchant request: sends the merchant token, and is refused without one. */
+    merchant?: boolean;
+    /**
+     * Leave out the customer token. For public endpoints (catalog, policies): the backend
+     * rejects any request carrying an expired token, so a lapsed login must not break browsing.
+     */
+    anonymous?: boolean;
+    /**
+     * The endpoint resolves the business from the `business` header and fails without it.
+     * The client then refuses to send the request without `credentials().businessId`.
+     */
+    business?: 'required';
+    /**
+     * The endpoint behaves differently without a guest session (`x-session-token`), e.g. the
+     * product listing then includes drafts. The client refuses the request without one.
+     * `omit`: never send the session token, e.g. when creating a new session to replace it.
+     */
+    session?: 'required' | 'omit';
+    /**
+     * Only for a logged-in customer (wishlist, own reviews, orders). The client refuses the
+     * request without `credentials().customerToken`.
+     */
+    customer?: 'required';
+    /**
+     * Works for a logged-in customer or a guest (cart, offers, promo codes): the backend finds
+     * the shopper by `x-customer-token` or `x-session-token`. The client refuses the request when
+     * it would send neither (a customer token left out by `anonymous` does not count).
+     */
+    customerOrSession?: 'required';
+    /** Abort this request after this many ms instead of `ClientOptions.timeoutMs`. */
+    timeoutMs?: number;
+    /**
+     * `'binary'` resolves a successful response as a `BinaryResponse` (PDF downloads) instead of
+     * parsing JSON. Error responses are still read as text and thrown as `GrowupsellApiError`.
+     * Default `'json'`.
+     */
+    responseType?: 'json' | 'binary';
+}
+/**
+ * Low-level request. Domain modules (business, product, cart…) are built on it; prefer those.
+ * Resolves with the parsed JSON body, or `undefined` for an empty response.
+ */
+type RequestFn = <T = unknown>(method: HttpMethod, path: string, options?: RequestOptions) => Promise<T>;
+
+interface BlogApi {
+    /** Newest first; all of the business's posts (the backend does not page this list). */
+    list(options?: {
+        categorySlug?: string;
+    }): Promise<BlogPostSummary[]>;
+    /** Throws GrowupsellApiError with status 404 for an unknown slug. */
+    get(slug: string): Promise<BlogPost>;
+    /** Merchant (theme edit): replaces the post's HTML sections. */
+    updateBody(slug: string, body: string[]): Promise<void>;
+}
+
+/**
+ * Business domain types: camelCase, no backend quirks (empty strings become null).
+ * Built from wire responses in http/business.ts.
+ */
+/** A merchant business on the Growupsell platform: what `/business/detail/{domain}` resolves. */
+interface Business {
+    id: number;
+    name: string | null;
+    description: string | null;
+    legalName: string | null;
+    gstNumber: string | null;
+    panNumber: string | null;
+    isTemplate: boolean;
+    /** `type` is the kind of business, e.g. `retail`, `restaurant`, `services`. */
+    category: {
+        id: number;
+        name: string;
+        type: string;
+    } | null;
+    legalForm: {
+        id: number;
+        name: string;
+    } | null;
+    /**
+     * Platform features enabled for this business, e.g. `ecommerce`, `giftcard`, `blog`,
+     * `deals-discount`. Use them to show or hide functionality.
+     */
+    features: string[];
+    /** Google Tag Manager container to load, or null when tag tracking is off. */
+    googleTagManagerId: string | null;
+    /** ISO 8601. */
+    createdAt: string;
+    /** ISO 8601. */
+    updatedAt: string;
+}
+interface Currency {
+    /** ISO 4217, e.g. `INR`. */
+    code: string;
+    /** e.g. `₹`. */
+    symbol: string;
+}
+interface BusinessSettings {
+    currency: Currency | null;
+    domain: string | null;
+}
+interface BusinessMedia {
+    logoSquare: string | null;
+    logoRectangle: string | null;
+}
+interface SocialLinks {
+    facebook: string | null;
+    instagram: string | null;
+    twitter: string | null;
+    telegram: string | null;
+    whatsapp: string | null;
+    linkedin: string | null;
+}
+/** A way to pay by direct bank or UPI transfer, shown at checkout. */
+interface BankTransferOption {
+    id: number;
+    type: string | null;
+    description: string | null;
+    /** e.g. a QR code or bank logo. */
+    photo: string | null;
+    paymentMethodId: number | null;
+}
+/**
+ * The storefront's look, and the id its theme content is stored under. One per business,
+ * created by the backend on first read.
+ */
+interface ThemeSettings {
+    /**
+     * The theme settings id. Pass it as `themeId` to `client.themeContent`: theme content
+     * belongs to this row, not to `websiteThemeId`.
+     */
+    id: number;
+    /** CSS colour, e.g. `#00484C`. The backend's default is `#CCC`. */
+    primaryColor: string;
+    accentColor: string | null;
+    /** A font name chosen by the storefront, e.g. `poppins`; the backend stores it as given. */
+    fontFamily: string | null;
+    /** The platform theme (template) chosen for the website, if any. Not a theme content id. */
+    websiteThemeId: number | null;
+    /** The platform theme (template) chosen for the mobile app, if any. */
+    appThemeId: number | null;
+}
+/** Merchant: the theme settings fields to change. Fields left out keep their value. */
+interface ThemeSettingsUpdate {
+    /** At most 8 characters, e.g. `#00484C`. Cannot be cleared. */
+    primaryColor?: string;
+    /** At most 8 characters; null clears it. */
+    accentColor?: string | null;
+    /** At most 256 characters; null clears it. */
+    fontFamily?: string | null;
+    websiteThemeId?: number | null;
+    appThemeId?: number | null;
+}
+
+interface BusinessApi {
+    /**
+     * The business a storefront domain belongs to. The backend ignores a `:port` and maps
+     * `localhost` / `127.0.0.1` to its development business. Call this first: its `id` is the
+     * `businessId` every other business-scoped request needs.
+     */
+    detail(domain: string): Promise<Business>;
+    /** Currency and primary domain. */
+    settings(): Promise<BusinessSettings>;
+    /** Logos. */
+    media(): Promise<BusinessMedia>;
+    socialLinks(): Promise<SocialLinks>;
+    /** Direct bank / UPI transfer options offered at checkout (deleted ones excluded). */
+    bankTransferOptions(): Promise<BankTransferOption[]>;
+    /**
+     * Colours and font, and the theme settings `id` that `client.themeContent` takes as
+     * `themeId`. Every storefront page needs it. Public.
+     */
+    themeSettings(): Promise<ThemeSettings>;
+    /**
+     * Merchant (manager role): changes the given fields of the merchant's own theme settings and
+     * returns the result.
+     */
+    updateThemeSettings(changes: ThemeSettingsUpdate): Promise<ThemeSettings>;
+}
+
+interface CartAddressesInput {
+    /** One of the customer's own addresses. */
+    shippingAddressId?: number;
+    billingAddressId?: number;
+}
+interface AddCartItemInput {
+    skuId: number;
+    /** A whole number, 1 or more. */
+    quantity: number;
+    /** Answers to the product's custom fields (e.g. a ring size). */
+    customData?: Record<string, unknown>;
+}
+/**
+ * The shopper's cart. The backend finds it from the login (`customerToken`) or, for a guest,
+ * from the session (`sessionToken`) plus the business; it calculates every total on every
+ * change, so refetch the cart with `get()` after a change instead of adjusting totals locally.
+ */
+interface CartApi {
+    /**
+     * The cart, with its lines and the backend's totals. Creates the cart on first call (the
+     * backend does): call once per screen, not in a loop.
+     */
+    get(): Promise<Cart>;
+    /**
+     * Adds a SKU (pick the variant first). Adding a SKU already in the cart adds the quantity to
+     * its line, so a repeated request adds twice: disable the button while one is pending.
+     * Made-to-order advance products are not added to the cart: use
+     * `checkout.createAdvanceOrder()`.
+     */
+    addItem(input: AddCartItemInput): Promise<{
+        lineId: number;
+    }>;
+    /** Sets a line's quantity (`CartLine.id`); 0 removes the line. Safe to repeat. */
+    setQuantity(lineId: number, quantity: number): Promise<void>;
+    /** Removes a line (`CartLine.id`). */
+    removeItem(lineId: number): Promise<void>;
+    /**
+     * Switches between online payment (`delivery`) and cash on delivery (`cod`); the backend
+     * recalculates the delivery charge. Offers apply to `delivery` carts only.
+     */
+    setOrderType(type: OrderType): Promise<CartTotals>;
+    /**
+     * Sets the shipping and/or billing address: ids of the logged-in customer's own addresses
+     * (another customer's address is a 404). Needs a customer login: guests cannot set addresses.
+     */
+    setAddresses(input: CartAddressesInput): Promise<{
+        shippingAddressId: number | null;
+        billingAddressId: number | null;
+    }>;
+    /**
+     * Applies an offer by id (`Offer.id`, from `promotions.eligibleOffers()`), or removes it with
+     * `null`. Clears any promo code: offers and promo codes do not combine. Refetch the cart for
+     * the new totals.
+     */
+    applyOffer(offerId: number | null): Promise<void>;
+    /**
+     * Applies a promo code by id (`PromoCode.id`, from `promotions.promoCode(code)`), or removes
+     * it with `null`. Clears any offer. Expired or already redeemed codes are refused (400 with
+     * the backend's message). Refetch the cart for the new totals.
+     */
+    applyPromoCode(promoCodeId: number | null): Promise<void>;
+    /**
+     * Business tax details for the invoice (legal name, GSTIN). Creates or replaces them, so it
+     * is safe to repeat. The backend requires a guest session token here, even for customers.
+     */
+    setTaxDetails(input: TaxDetails): Promise<TaxDetails>;
+    /**
+     * A delivery partner's quote for the cart (`Cart.id`). Only meaningful when
+     * `cart.deliveryChargeType === 'as_per_delivery_partner'` (otherwise a 400). Without a
+     * pincode the backend uses the cart's shipping address. The backend stores the quote in the
+     * cart's totals, so refetch the cart afterwards. Slow: the backend asks the partner.
+     */
+    deliveryEstimate(cartId: number, options?: {
+        pincode?: string;
+    }): Promise<DeliveryEstimate>;
+}
+
+interface CatalogApi {
+    /**
+     * Top-level categories with their sub-categories. With `search`, the categories whose name
+     * or description match; when only sub-categories match, their parents with just those
+     * sub-categories.
+     */
+    categories(options?: {
+        search?: string;
+    }): Promise<CategoryTree[]>;
+    /** One category, without sub-categories. */
+    category(id: number): Promise<Category>;
+    /** Several categories by id, without sub-categories. An empty list resolves to `[]`. */
+    categoriesByIds(ids: readonly number[]): Promise<Category[]>;
+    /** Brands; with `categoryIds`, those with products in these categories or their sub-categories. */
+    brands(options?: {
+        categoryIds?: readonly number[];
+    }): Promise<Brand[]>;
+    /** Which catalog features the merchant has switched on. */
+    settings(): Promise<CatalogSettings>;
+}
+
+/** The store's frequently asked questions. Built from wire responses in http/faq.ts. */
+interface Faq {
+    id: number;
+    /** The backend allows an empty question or answer; both are null when empty. */
+    question: string | null;
+    /** HTML written by the merchant. */
+    answer: string | null;
+    /** Position in the list, ascending. Not contiguous: gaps are normal. */
+    displayOrder: number;
+}
+
+/**
+ * Store policies and terms (privacy policy, terms of use, refunds, shipping, warranty), each a
+ * list of headed sections. Built from wire responses in http/policies.ts.
+ */
+type PolicyType = 'privacy' | 'terms-of-use' | 'cancellation-refund' | 'shipping' | 'warranty';
+/** One headed section of a policy page. */
+interface Policy {
+    id: number;
+    type: PolicyType;
+    heading: string;
+    /** HTML written by the merchant; null when empty. */
+    description: string | null;
+    /** Position within its type, ascending. Not contiguous: gaps are normal. */
+    displayOrder: number;
+}
+
+/** What a merchant writes for one policy section. */
+interface PolicyInput {
+    type: PolicyType;
+    heading: string;
+    /** HTML. */
+    description?: string | null;
+}
+/** Move a row one place towards the top (`up`) or the bottom (`down`) of its list. */
+type MoveDirection = 'up' | 'down';
+interface PoliciesApi {
+    /** Every policy section, or one type's, in display order. Public. */
+    list(options?: {
+        type?: PolicyType;
+    }): Promise<Policy[]>;
+    /** Merchant: adds a section at the end of its type. */
+    create(input: PolicyInput): Promise<Policy>;
+    /**
+     * Merchant: adds several sections at once, in order (e.g. a default policy set). They are
+     * numbered after the last section of the first input's type. An empty list sends nothing.
+     */
+    createMany(inputs: readonly PolicyInput[]): Promise<Policy[]>;
+    /** Merchant: changes only the given fields. */
+    update(id: number, changes: Partial<PolicyInput>): Promise<Policy>;
+    /**
+     * Merchant: swaps the section with its neighbour of the same type. Rejects with a 400
+     * `GrowupsellApiError` when it is already first (`up`) or last (`down`).
+     */
+    move(id: number, direction: MoveDirection): Promise<void>;
+    /** Merchant: deletes the section for good. */
+    remove(id: number): Promise<void>;
+}
+
+/** What a merchant writes for one question. */
+interface FaqInput {
+    question: string;
+    /** HTML. */
+    answer: string;
+}
+interface FaqApi {
+    /** The questions in display order. Public. */
+    list(): Promise<Faq[]>;
+    /** Merchant (manager role): adds a question at the end. */
+    create(input: FaqInput): Promise<Faq>;
+    /** Merchant: changes only the given fields. */
+    update(id: number, changes: Partial<FaqInput>): Promise<Faq>;
+    /**
+     * Merchant: swaps the question with its neighbour. Rejects with a 400 `GrowupsellApiError`
+     * when it is already first (`up`) or last (`down`).
+     */
+    move(id: number, direction: MoveDirection): Promise<void>;
+    /** Merchant: removes the question from the list. */
+    remove(id: number): Promise<void>;
+}
+
+type FormFieldType = 'text' | 'boolean' | 'date' | 'number' | 'email' | 'phone' | 'select' | 'radio' | 'image' | 'file';
+interface FormFieldOption {
+    label: string;
+    value: string;
+}
+interface FormField {
+    /** The key to submit the value under. */
+    name: string;
+    type: FormFieldType;
+    required: boolean;
+    /** The merchant's label, or the name with `_` turned into spaces. */
+    label: string;
+    /** Only for `select` and `radio`; otherwise empty. */
+    options: FormFieldOption[];
+}
+/** A merchant-built form, as a shopper fills it in. */
+interface PublicForm {
+    id: number;
+    slug: string;
+    name: string;
+    description: string | null;
+    /** What to show after a successful submit; null means the app's default. */
+    successMessage: string | null;
+    fields: FormField[];
+}
+/** A form for the merchant to pick (e.g. for a banner button). */
+interface FormSummary {
+    id: number;
+    name: string;
+    slug: string;
+}
+/**
+ * A submitted value. `image` / `file` fields take a URL string: upload the file first. Guests
+ * cannot fill them today, because the only upload endpoint needs a customer login (ADR-023).
+ */
+type FormValue = string | number | boolean | null;
+
+interface FormsApi {
+    /** An active form. Throws GrowupsellApiError 404 when it does not exist or is inactive. */
+    get(slug: string): Promise<PublicForm>;
+    /**
+     * Submits the values, keyed by field name. A logged-in customer is attributed automatically.
+     * Rejected values come back in the error's `fieldErrors.data`. `image` / `file` fields take a
+     * URL string.
+     */
+    submit(slug: string, values: Record<string, FormValue>): Promise<void>;
+    /** Merchant (theme edit): active forms to pick from, newest first. */
+    listForMerchant(): Promise<FormSummary[]>;
+}
+
+/** A contact-us message. */
+interface InquiryInput {
+    subject: string;
+    message: string;
+    /** For guests; a logged-in customer is attributed automatically. */
+    name?: string;
+    email?: string;
+    /** International format, e.g. "+919876543210" (the backend rejects other formats). */
+    phone?: string;
+}
+interface HelpdeskApi {
+    /**
+     * Sends a contact-us inquiry; the business may email an acknowledgement to `email`.
+     * Rejected values come back in the error's `fieldErrors` (e.g. `phone_number`).
+     */
+    createInquiry(input: InquiryInput): Promise<void>;
+}
+
+/** Email newsletter sign-up (backend `/subscribers/`). */
+interface NewsletterApi {
+    /**
+     * Emails a one-time code to confirm the address (again, if one is pending). An address that
+     * is already subscribed rejects with a 400 `GrowupsellApiError` ("This email is already
+     * subscribed.").
+     */
+    subscribe(email: string): Promise<void>;
+    /**
+     * Confirms the address with the emailed code. A wrong code comes back in `fieldErrors.otp`;
+     * an address that never signed up is a 500 from the backend today (C21).
+     */
+    verify(email: string, otp: string): Promise<void>;
+}
+
+/**
+ * A browser's web push subscription as plain data: what `PushSubscription.toJSON()` returns,
+ * so `client.push.subscribe(subscription.toJSON())` type-checks. `commerce` has no DOM types,
+ * so this mirrors the DOM's `PushSubscriptionJSON` (every field optional there too). The
+ * library refuses one without `endpoint`, `keys.p256dh` or `keys.auth` before sending.
+ */
+interface PushSubscriptionJson {
+    endpoint?: string;
+    expirationTime?: number | null;
+    keys?: Record<string, string>;
+}
+
+/**
+ * Web push subscriptions (backend `/subscribers/push/…`). The app does the browser work
+ * (permission, service worker, `pushManager.subscribe` with the VAPID key) and passes
+ * `PushSubscription.toJSON()` in; the library never touches platform APIs.
+ */
+interface PushApi {
+    /**
+     * The server's VAPID public key (base64url), for `pushManager.subscribe`'s
+     * `applicationServerKey`. Null when the backend has none configured.
+     */
+    vapidPublicKey(): Promise<string | null>;
+    /**
+     * Registers the browser's subscription for the business. When a customer is logged in, the
+     * backend links it to the customer (one subscription per customer: a new browser replaces the
+     * old one). Safe to repeat: an existing subscription is updated. Rejects without a request
+     * (`TypeError`) when `endpoint`, `keys.p256dh` or `keys.auth` is missing.
+     */
+    subscribe(subscription: PushSubscriptionJson): Promise<void>;
+    /**
+     * Switches the subscription off for the business. Resolves also when the backend had no such
+     * subscription. Call it before `PushSubscription.unsubscribe()` in the browser. Rejects
+     * without a request (`TypeError`) like `subscribe`.
+     */
+    unsubscribe(subscription: PushSubscriptionJson): Promise<void>;
+}
+
+/** The merchant's chat button. WhatsApp is the only channel the backend offers. */
+interface LiveSupportWidget {
+    channel: 'whatsapp';
+    /** As the merchant typed it, e.g. "919876543210" (country code, no `+`). */
+    whatsappNumber: string;
+}
+
+interface LiveSupportApi {
+    /** The chat button to show, or null when the merchant turned it off or never set a number. */
+    widget(): Promise<LiveSupportWidget | null>;
+}
+
+/**
+ * Who sees a new or changed section item:
+ * - `'all'`: every variant.
+ * - `{ variantIds }`: one SKU, named by its variant options (one per variant type, e.g.
+ *   `[128 GB, Blue]`). The backend answers 400 if they are not a whole SKU.
+ * - `{ variantId }`: every SKU with this variant option.
+ */
+type ProductSectionItemTargetInput = 'all' | {
+    variantIds: readonly number[];
+} | {
+    variantId: number;
+};
+interface ProductPageApi {
+    /** The product's sections with their items. Public. */
+    sections(productId: number): Promise<ProductSection[]>;
+    /** The product's slug-keyed blocks (e.g. `hero`, `showcase`), in display order. Public. */
+    blocks(productId: number, options?: {
+        slug?: string;
+    }): Promise<ProductBlock[]>;
+    /** Adds an empty section to the product. */
+    createSection(input: {
+        productId: number;
+        title: string;
+    }): Promise<ProductSection>;
+    /** Deletes a section and its items. */
+    deleteSection(id: number): Promise<void>;
+    /** Adds an item at the end of a section. `target` defaults to `'all'`. */
+    addSectionItem(input: {
+        sectionId: number;
+        data: unknown;
+        target?: ProductSectionItemTargetInput;
+    }): Promise<ProductSectionItem>;
+    /**
+     * Changes an item's data and/or target (left out: unchanged). `sectionId` is the item's
+     * section: the backend requires it on every update.
+     */
+    updateSectionItem(id: number, input: {
+        sectionId: number;
+        data?: unknown;
+        target?: ProductSectionItemTargetInput;
+    }): Promise<ProductSectionItem>;
+    /**
+     * Swaps the item with its neighbour. Rejects with a 400 when it is already first (`up`) or
+     * last (`down`).
+     */
+    moveSectionItem(id: number, direction: 'up' | 'down'): Promise<void>;
+    deleteSectionItem(id: number): Promise<void>;
+    /** Adds a block. See `ProductBlock` for the checks the backend makes on `hero`/`showcase`. */
+    createBlock(input: {
+        productId: number;
+        slug: string;
+        data: unknown;
+    }): Promise<ProductBlock>;
+    updateBlock(id: number, input: {
+        slug?: string;
+        data?: unknown;
+    }): Promise<ProductBlock>;
+    deleteBlock(id: number): Promise<void>;
+}
+
+interface ProductsApi {
+    /**
+     * The product listing: one item per sellable SKU, only products available on the website.
+     * Needs a guest session: without one the backend also returns drafts and hidden products.
+     */
+    search(options?: ProductSearchOptions): Promise<Page<ProductListItem>>;
+    /** Products (not SKUs), e.g. for home-page sliders. Only available products. */
+    list(options?: {
+        ids?: readonly number[];
+        categoryIds?: readonly number[];
+        limit?: number;
+        offset?: number;
+    }): Promise<Page<ProductOverview>>;
+    detail(id: number): Promise<ProductDetail>;
+    /** Price range and specification filters, for the business or one category. */
+    filterConfig(options?: {
+        categoryId?: number;
+    }): Promise<ProductFilterConfig>;
+    /** Variant groups available in these categories (and their sub-categories), for filters. */
+    variantFilters(categoryIds: readonly number[]): Promise<VariantGroup[]>;
+    /** Quick search suggestions (products and categories) for a search box. */
+    suggestions(query: string): Promise<SearchSuggestion[]>;
+}
+
+interface PromotionsApi {
+    /**
+     * One page of the business's offers. Includes expired and inactive offers, with their coupon
+     * codes: for the merchant's theme editor, not for shoppers (use `eligibleOffers()`).
+     */
+    offers(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Page<Offer>>;
+    /**
+     * The offers the shopper's cart qualifies for now. Empty for a cash-on-delivery cart (the
+     * backend only offers them on `delivery` carts). Apply one with `cart.applyOffer(id)`.
+     */
+    eligibleOffers(): Promise<Offer[]>;
+    /**
+     * Looks a promo code up (trimmed, upper-cased: codes are stored upper-case). `null` for an
+     * unknown or blank code. Check `status` before applying it with `cart.applyPromoCode(id)`.
+     */
+    promoCode(code: string): Promise<PromoCode | null>;
+    /**
+     * Checks a gift card's code and PIN. Rejects with a 400 and a field error (`code` or `pin`)
+     * when the card is unknown, the PIN is wrong, or the card is used up or expired. The PIN is
+     * not kept in the result; pass the card's `id` to checkout.
+     */
+    validateGiftCard(input: {
+        code: string;
+        pin: string;
+    }): Promise<GiftCard>;
+    /** The business's reward point configuration. */
+    rewardPointSettings(): Promise<RewardPointSettings>;
+}
+
+/**
+ * A file to upload, passed through to the platform's `FormData` untouched: a `File` or `Blob`
+ * on the web, `{ uri, name, type }` in React Native.
+ */
+type UploadFile = unknown;
+
+/**
+ * A photo to attach: a `File` or `Blob` on the web, `{ uri, name, type }` in React Native.
+ * Sent as multipart form data with the platform's `FormData`.
+ */
+type ReviewPhoto = UploadFile;
+interface CreateReviewInput {
+    /**
+     * The logged-in customer's id. The backend takes the author from the request body, not from
+     * the login, so it must be sent.
+     */
+    customerId: number;
+    productId: number;
+    /** From `eligibility()`: the ordered item the review is for. */
+    orderProductId?: number;
+    title: string;
+    message?: string;
+    /** 1 to 5, in steps of 0.5. */
+    rating: number;
+    photo?: ReviewPhoto;
+}
+interface UpdateReviewInput {
+    title?: string;
+    message?: string;
+    rating?: number;
+    /** Replaces the photo. */
+    photo?: ReviewPhoto;
+}
+interface ReviewsApi {
+    /** A product's published reviews (all of them: the backend does not page this list). */
+    forProduct(productId: number): Promise<ReviewListItem[]>;
+    /** The business's reviews, newest first, e.g. for a home-page slider. */
+    latest(options?: {
+        /** Only ratings above this, e.g. 3 for 3.5 and up. */
+        minRating?: number;
+        /** Matches the title, the message and the customer's name. */
+        search?: string;
+        /** Default 20. */
+        limit?: number;
+        offset?: number;
+    }): Promise<Page<ReviewListItem>>;
+    /** Review count, average rating and the number of reviews per star. */
+    summary(productId: number): Promise<ReviewSummary>;
+    /**
+     * Whether the logged-in customer may review a product: they ordered it and have not reviewed
+     * it yet. The backend does not enforce this on `create()`: check it first.
+     */
+    eligibility(productId: number): Promise<ReviewEligibility>;
+    create(input: CreateReviewInput): Promise<Review>;
+    /** Changes the customer's own review; only the given fields change. */
+    update(reviewId: number, changes: UpdateReviewInput): Promise<Review>;
+    /** Deletes the customer's own review. */
+    remove(reviewId: number): Promise<void>;
+}
+
+/** Wishlist domain types. Built from wire responses in http/wishlist.ts. */
+
+/** A saved SKU in the logged-in customer's wishlist. */
+interface WishlistItem {
+    /** The wishlist entry id: pass it to `wishlist.remove()`. */
+    id: number;
+    /** Product name with the SKU's variants, e.g. "Iphone 15 (128 GB, Blue)". */
+    name: string;
+    photo: string | null;
+    productId: number;
+    productSlug: string;
+    /** Null only for old entries saved without a SKU; those cannot be added to the cart. */
+    sku: ProductSku | null;
+    /**
+     * False when the product or SKU was deleted, deactivated or set back to draft since it was
+     * saved (the backend still lists those). Do not offer "move to cart" then.
+     */
+    available: boolean;
+    /** `none` for stocked goods; custom modes are made to order. */
+    fulfillmentMode: string;
+    /** Advance payment required for made-to-order products. */
+    advanceAmount: number | null;
+    hasDigitalDelivery: boolean;
+}
+
+interface WishlistApi {
+    /** The logged-in customer's saved SKUs. */
+    list(): Promise<WishlistItem[]>;
+    /**
+     * Saves a SKU (not a product: pick the variant first). Rejects with a 400 when the SKU is
+     * already saved.
+     */
+    add(skuId: number): Promise<{
+        id: number;
+        productId: number;
+    }>;
+    /** Removes an entry by its wishlist id (`WishlistItem.id`), not by SKU. */
+    remove(wishlistId: number): Promise<void>;
+}
+
+/**
+ * Theme content: the merchant's free-form JSON document for each storefront section (header,
+ * footer, home, announcement…), and images uploaded for it. Built in http/theme-content.ts.
+ */
+/** Which app the content was saved from. Always passed in by the app, never guessed (ADR-009). */
+type ContentPlatform = 'website' | 'app';
+/**
+ * One section's document. Its shape is decided by the storefront that wrote it, not by the
+ * backend, so `data` is typed by the caller (`unknown` by default): validate it before use.
+ */
+interface ThemeContent<T = unknown> {
+    id: number;
+    /** The business's theme settings id the content belongs to. */
+    themeId: number;
+    /** The section, e.g. `header`, `footer`, `home`, `announcement`. */
+    slug: string;
+    /**
+     * The platform of the last save. A label only: website and app share one document per slug,
+     * so saving from one replaces what the other saved.
+     */
+    platform: ContentPlatform;
+    data: T;
+}
+/** What an uploaded image is for. */
+type ContentImageUsage = 'banner' | 'slider' | 'header-logo' | 'footer-logo' | 'other';
+interface ContentImage {
+    id: number;
+    /** Public URL of the stored file, to put into a theme content document. */
+    url: string;
+    usage: ContentImageUsage | null;
+}
+
+/** An image to upload for theme content. */
+interface ContentImageUpload {
+    /** An empty form from the platform (`new FormData()`); the library fills it in. */
+    form: FormDataLike;
+    /** The file: a `Blob`/`File` on the web, `{uri, name, type}` in React Native. */
+    file: unknown;
+    /** Its name with extension (the backend checks it): jpg, jpeg, png, webp, avif, pdf, mp4, mov, mkv. */
+    fileName?: string;
+    usage?: ContentImageUsage;
+}
+interface ThemeContentApi {
+    /**
+     * One section's document, or null if it was never saved. Public.
+     * @param themeId The business's theme settings id (`ThemeSetting.id`).
+     * @param slug The section, e.g. `header`, `footer`, `home`.
+     */
+    get<T = unknown>(themeId: number, slug: string): Promise<ThemeContent<T> | null>;
+    /**
+     * Several sections in one request: one entry per requested slug, in the same order, null
+     * for a section never saved (a slug asked twice is answered twice). No slugs: `[]` without a
+     * request. Public.
+     * @param themeId The business's theme settings id (`ThemeSetting.id`).
+     * @param slugs e.g. `['header', 'footer', 'announcement']`. A slug cannot contain a comma.
+     * @example const [header, footer] = await client.themeContent.getMany(id, ['header', 'footer']);
+     */
+    getMany<T = unknown, const S extends readonly string[] = readonly string[]>(themeId: number, slugs: S): Promise<{
+        -readonly [K in keyof S]: ThemeContent<T> | null;
+    }>;
+    /**
+     * Merchant: saves a section's whole document, creating it on first save. `platform` must be
+     * passed in by the app; it is not guessed (ADR-009).
+     */
+    update<T>(themeId: number, slug: string, content: {
+        platform: ContentPlatform;
+        data: T;
+    }): Promise<ThemeContent<T>>;
+    /** Merchant (manager role): uploads an image or video to use in theme content. */
+    uploadImage(upload: ContentImageUpload): Promise<ContentImage>;
+}
+
+/**
+ * Custom pages: storefront pages the merchant builds from sections (e.g. `/about-us`), with an
+ * optional hero at the top. Built in http/customPages.ts.
+ */
+/**
+ * The hero at the top of a page. `type` names the storefront component that renders it (e.g.
+ * `slider`, `banner`); `data` is that component's free-form settings, written by the storefront
+ * editor and not checked by the backend: validate it before use. A slider's `data` is its list
+ * of slides.
+ */
+interface CustomPageHero {
+    type: string;
+    data: unknown;
+}
+/**
+ * One section of a page, exactly as the storefront editor saved it. The backend stores any JSON
+ * object here; the editor writes `slug` (which component renders it) and `content` (its
+ * settings), sometimes with more keys. Keep unknown keys when saving it back.
+ */
+type CustomPageSection = Record<string, unknown>;
+/** An active page, as a shopper sees it. */
+interface CustomPage {
+    /** Pass to `customPages.content()` / `updateContent()` to edit it. */
+    id: number;
+    title: string;
+    /** Path without leading or trailing slash, e.g. `about-us` or `company/team`. */
+    path: string;
+    seoTitle: string | null;
+    seoDescription: string | null;
+    seoKeywords: string[];
+    hero: CustomPageHero | null;
+    /** In display order. */
+    sections: CustomPageSection[];
+}
+/** A page's editable document (merchant). */
+interface CustomPageContent {
+    id: number;
+    pageId: number;
+    hero: CustomPageHero | null;
+    sections: CustomPageSection[];
+    createdAt: string;
+    updatedAt: string;
+}
+
+/** A page's whole editable document, as saved by `customPages.updateContent()`. */
+interface CustomPageContentInput {
+    /** In display order. Saved as given; unknown keys are kept. */
+    sections: CustomPageSection[];
+    /** `null` removes the hero. */
+    hero: CustomPageHero | null;
+}
+interface CustomPagesApi {
+    /**
+     * The business's active page at a storefront path (`about-us`, `/company/team/`), or null when
+     * there is none (unknown path or inactive page). Public. Paths are case-sensitive; slashes
+     * around and between segments are ignored, as the backend does.
+     */
+    byPath(path: string): Promise<CustomPage | null>;
+    /**
+     * Merchant (manager role): a page's editable document, inactive pages included. The backend
+     * creates an empty document the first time a page is opened.
+     */
+    content(pageId: number): Promise<CustomPageContent>;
+    /**
+     * Merchant (manager role): saves a page's sections and hero together and returns the stored
+     * document. Both are always sent: saving one alone could drop a hero that an older editor
+     * kept among the sections.
+     */
+    updateContent(pageId: number, input: CustomPageContentInput): Promise<CustomPageContent>;
+}
+
+/** Guest session domain types. Built from wire responses in http/session.ts. */
+/**
+ * A guest session: identifies a shopper who is not logged in (guest cart) and is sent with
+ * login so the guest cart moves to the customer. Store `token` and return it from
+ * `credentials().sessionToken`.
+ */
+interface GuestSession {
+    id: number;
+    token: string;
+}
+
+interface SessionApi {
+    /**
+     * Starts a new guest session. Call it when no session is stored, and again when the client
+     * reports `onUnauthorized({ kind: 'session', token })`. The library stores nothing: keep the token
+     * and return it from `credentials().sessionToken`. There is no logout endpoint.
+     */
+    create(): Promise<GuestSession>;
+}
+
+/** Lookup domain types (address form). Built from wire responses in http/lookup.ts. */
+interface Country {
+    /** ISO 3166-1 alpha-2, e.g. "IN". Send it as an address's `country`. */
+    code: string;
+    name: string;
+}
+interface CountryState {
+    /** Send it as an address's `state`. */
+    id: number;
+    name: string;
+    /** e.g. "GJ". */
+    shortName: string;
+    /** The Indian GST state code, e.g. "24"; a string, keep leading zeros. */
+    code: string;
+    /** Country code, e.g. "IN". */
+    country: string | null;
+}
+
+interface LookupApi {
+    /** All countries, or those whose code or name contains `search` (case-insensitive). */
+    countries(search?: string): Promise<Country[]>;
+    /**
+     * The states of a country (`Country.code`). `[]` for a country without states; an unknown
+     * code rejects with a 400 on `country`.
+     */
+    states(countryCode: string): Promise<CountryState[]>;
+}
+
+/** Sign-up and login domain types. Built from wire responses in http/auth.ts. */
+
+/**
+ * How the business lets customers sign up and log in. Only what a storefront's auth forms read
+ * (ADR-023): the per-business dynamic fields are not exposed yet (ADR-018).
+ */
+interface CustomerSettings {
+    /** Whether the login username is a phone number, an email, or either; also where OTPs go. */
+    authType: 'phone' | 'email' | 'both';
+    /** Offer "sign up as a business" (business name and tax number). */
+    allowBusinessSignup: boolean;
+    /** Sign-up and first login need an OTP before the customer is signed in. */
+    requireVerification: boolean;
+    lastNameRequired: boolean;
+}
+/** A signed-in customer. Store `token` and return it from `credentials().customerToken`. */
+interface SignedInCustomer {
+    customer: CustomerProfile;
+    /** The customer login (`x-customer-token`). Valid for 24 hours; there is no refresh. */
+    token: string;
+    /** Available reward points, or null when the customer has none on record. */
+    rewardPoints: number | null;
+}
+/**
+ * The result of `auth.login()` and `auth.register()` (ADR-023). `verification-required`: the
+ * account is not verified yet and the backend has sent an OTP; ask for it and call
+ * `auth.verifyOtp({ customerId, otp })`. No token is given out for an unverified account.
+ */
+type AuthResult = {
+    status: 'signed-in';
+    session: SignedInCustomer;
+} | {
+    status: 'verification-required';
+    customerId: number;
+    /**
+     * Where the OTP was sent, to show the shopper and to pass to `auth.sendOtp()` for a new
+     * code: the username entered at login; the phone (else the email) at sign-up.
+     */
+    contact: string | null;
+};
+
+interface LoginInput {
+    /** A phone number in E.164 (`+919876543210`) or an email, as `settings().authType` allows. */
+    username: string;
+    password: string;
+}
+interface VerifyOtpInput {
+    /** `customerId` from a `verification-required` result. */
+    customerId: number;
+    otp: string;
+}
+/**
+ * Signed-out customer flows: settings, sign-up, login, OTP and password reset. The library
+ * stores nothing (ADR-015): keep the token a signed-in result returns. There is no logout
+ * endpoint; logging out is forgetting the token.
+ */
+interface AuthApi {
+    /** How this business lets customers sign up and log in. */
+    settings(): Promise<CustomerSettings>;
+    /**
+     * Logs in. Needs a guest session (`session.create()`): the backend moves the guest cart to
+     * the customer. An unverified account gets `verification-required` (an OTP was sent).
+     */
+    login(input: LoginInput): Promise<AuthResult>;
+    /** Verifies the account with the OTP and signs the customer in. */
+    verifyOtp(input: VerifyOtpInput): Promise<SignedInCustomer>;
+    /**
+     * Signs up. Needs a guest session, like `login()`. When the business requires verification
+     * the result is `verification-required` and an OTP was sent; otherwise `signed-in`.
+     */
+    register(input: RegisterInput): Promise<AuthResult>;
+    /** Sends an OTP to the account's phone or email: for verification and forgotten passwords. */
+    sendOtp(username: string): Promise<{
+        message: string;
+    }>;
+    /** Sets a new password with an OTP from `sendOtp()`. */
+    resetPassword(input: ResetPasswordInput): Promise<{
+        message: string;
+    }>;
+}
+interface RegisterInput {
+    /** Required when `settings().authType` is `email`. */
+    email?: string;
+    /** E.164. Required when `settings().authType` is `phone`. */
+    phone?: string;
+    /** At least 8 characters; the backend also applies Django's password rules. */
+    password: string;
+    type: 'individual' | 'business';
+    /** Required for `individual`. */
+    firstName?: string;
+    /** Required for `individual`. */
+    lastName?: string;
+    /** Required for `business`. */
+    businessName?: string;
+    /** Required for `business`. */
+    taxNumber?: string;
+    referralCode?: string;
+}
+interface ResetPasswordInput {
+    username: string;
+    otp: string;
+    newPassword: string;
+    confirmPassword: string;
+}
+
+/** Only the given keys are sent; `null` clears a field. */
+interface UpdateProfileInput {
+    firstName?: string | null;
+    lastName?: string | null;
+    businessName?: string | null;
+    taxNumber?: string | null;
+}
+interface ChangePasswordInput {
+    oldPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}
+interface ConfirmEmailChangeInput {
+    /** The new email, as sent to `requestEmailChange()`. */
+    email: string;
+    otp: string;
+}
+interface ConfirmPhoneChangeInput {
+    /** The new phone, as sent to `requestPhoneChange()`. */
+    phone: string;
+    otp: string;
+}
+/** The logged-in customer's own account (ADR-023: signed-out flows are in `client.auth`). */
+interface CustomerApi {
+    /** Changes the name, business name or tax number. `id` is `CustomerProfile.id`. */
+    updateProfile(id: number, input: UpdateProfileInput): Promise<CustomerProfile>;
+    changePassword(input: ChangePasswordInput): Promise<{
+        message: string;
+    }>;
+    /** Sends an OTP to the new email; confirm with `confirmEmailChange()`. */
+    requestEmailChange(email: string): Promise<void>;
+    confirmEmailChange(input: ConfirmEmailChangeInput): Promise<{
+        message: string;
+        newEmail: string;
+    }>;
+    /** Sends an OTP to the new phone (E.164); confirm with `confirmPhoneChange()`. */
+    requestPhoneChange(phone: string): Promise<void>;
+    confirmPhoneChange(input: ConfirmPhoneChangeInput): Promise<{
+        message: string;
+        newPhone: string;
+    }>;
+}
+
+/** Customer address domain types. Built from wire responses in http/addresses.ts. */
+/** A saved address of the logged-in customer. */
+interface Address {
+    /**
+     * The address id. It can change: editing an address an order already used replaces it with
+     * a copy under a new id, so keep the id `addresses.update()` returns.
+     */
+    id: number;
+    addressLine1: string;
+    addressLine2: string;
+    postalCode: string | null;
+    city: string;
+    /** Free text set by the storefront, e.g. "home" or "work". */
+    type: string;
+    /** Country code (`Country.code`). */
+    country: string | null;
+    /** State id (`CountryState.id`). */
+    state: number | null;
+    stateName: string | null;
+    landmark: string;
+    contactNo: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    isDefault: boolean;
+    /** True when an order used it (then editing creates a copy); null when unknown. */
+    isUsed: boolean | null;
+}
+/** What `addresses.create()` and `addresses.update()` send. */
+interface AddressInput {
+    addressLine1: string;
+    addressLine2: string;
+    /** At most 6 characters (the backend's limit). */
+    postalCode?: string;
+    city: string;
+    type: string;
+    landmark: string;
+    country?: string | null;
+    state?: number | null;
+    /** E.164. */
+    contactNo?: string | null;
+    latitude?: number | null;
+    longitude?: number | null;
+    /** Make this the default address (the previous default is unset). Default false. */
+    isDefault?: boolean;
+}
+
+interface AddressesApi {
+    /** The logged-in customer's addresses, oldest first. */
+    list(): Promise<Address[]>;
+    create(input: AddressInput): Promise<Address>;
+    /**
+     * Replaces an address. Use the returned address's id from then on: an address an order
+     * already used is kept for that order, and the edit is saved as a copy with a new id.
+     */
+    update(id: number, input: AddressInput): Promise<Address>;
+    /** Deletes an address (kept hidden for orders that used it). */
+    remove(id: number): Promise<void>;
+}
+
+interface PlaceOrderOptions {
+    /**
+     * Gift cards to spend, by id (from `promotions.validateGiftCard()`), in this order. Not
+     * allowed for cash on delivery.
+     */
+    giftCardIds?: readonly number[];
+    /** Spend the customer's reward points. Not allowed for cash on delivery. */
+    useRewardPoints?: boolean;
+}
+/** A made-to-order product, ordered on its own (one unit) with an advance payment. */
+interface CreateAdvanceOrderInput {
+    productId: number;
+    /** The variant, when the product has several. */
+    skuId?: number;
+    /** The product's custom fields, as configured by the merchant. */
+    customData?: Record<string, unknown>;
+    /** One of the customer's addresses. */
+    shippingAddressId: number;
+    /** Defaults to the shipping address. */
+    billingAddressId?: number;
+    /** Default `delivery`. */
+    type?: OrderType;
+}
+interface CheckoutApi {
+    /** The business's order settings: cash on delivery, cancellation, quantity limits. */
+    settings(): Promise<CheckoutSettings>;
+    /**
+     * Places the order for the cart `cartId`: spends the gift cards and reward points, creates
+     * the payment and takes the cart out of `cart` status. Needs a logged-in customer.
+     *
+     * - `placed`: nothing left to pay online (cash on delivery, or fully covered by gift cards
+     *   or points).
+     * - `payment-required`: run the payment SDK for `payment.method`, then confirm through
+     *   `client.payments`.
+     *
+     * Gift cards and reward points cannot be combined (the backend over-charges the gift cards
+     * when both are used): this rejects before sending.
+     *
+     * One request per cart at a time: calling again for the same cart while a request is in
+     * flight returns the same promise (a double tap places one order; the first call's options
+     * win). Waits up to 60 s, because the backend books shipments before it answers.
+     *
+     * **Never retried**, by the library or by you: the backend does not detect a repeated
+     * request. After a timeout or network error, read `client.orders.detail(cartId)`: a status
+     * other than `cart` means the order was placed.
+     */
+    placeOrder(cartId: number, options?: PlaceOrderOptions): Promise<PlaceOrderResult>;
+    /**
+     * Creates the order for a made-to-order product and its advance payment in one step, outside
+     * the cart. The advance amount is the product's, set by the merchant: it is never sent. Pay
+     * `payment` like a `payment-required` result of `placeOrder`. Needs a logged-in customer.
+     * Not idempotent: each call creates an order.
+     */
+    createAdvanceOrder(input: CreateAdvanceOrderInput): Promise<AdvanceOrder>;
+}
+
+/**
+ * What the backend reported after a payment confirmation. A hint only: read the order for the
+ * real payment status.
+ */
+interface PaymentConfirmation {
+    status: 'paid' | 'unpaid';
+}
+
+/** What Razorpay Checkout's `handler` receives on success. */
+interface RazorpayResult {
+    razorpayPaymentId: string;
+    razorpayOrderId: string;
+    razorpaySignature: string;
+}
+/**
+ * Confirms a payment after the provider's SDK or page finished (the `payment` of a
+ * `payment-required` result). The backend's answer is only a hint: Razorpay's endpoint says
+ * success even when the capture failed, and Stripe's does not check that the intent belongs to
+ * the order. **Read `client.orders.detail(orderId)` afterwards for the real payment status.**
+ *
+ * One request per payment at a time: calling again for the same payment while a confirmation
+ * is in flight (a page refresh, a double tap) returns the same promise.
+ */
+interface PaymentsApi {
+    /** After the PhonePe redirect (`/payment-redirect?payment_id=…`): asks PhonePe for the status. */
+    confirmPhonePe(paymentId: number): Promise<PaymentConfirmation>;
+    /**
+     * After Stripe Elements' `confirmPayment`. Sends the pending payment's own PaymentIntent, so
+     * an app cannot confirm with another intent. A failed verification is `unpaid`, not an
+     * error. Rejects with a `TypeError`, without a request, when `providerOrderId` is missing.
+     */
+    confirmStripe(payment: Pick<PendingPayment, 'id' | 'providerOrderId'>): Promise<PaymentConfirmation>;
+    /** After Razorpay Checkout succeeded: passes Razorpay's result to the backend. */
+    confirmRazorpay(payment: Pick<PendingPayment, 'id'>, result: RazorpayResult): Promise<void>;
+    /**
+     * Direct (bank) transfer: uploads the customer's screenshot of the transfer. The payment
+     * becomes `unverified` until the merchant checks it. Needs a logged-in customer.
+     * `screenshot`: a `File` or `Blob` on the web, `{ uri, name, type }` in React Native.
+     */
+    submitTransferProof(paymentId: number, screenshot: UploadFile): Promise<void>;
+}
+
+/** A file uploaded for a custom-manufacturing form field. */
+interface UploadedFile {
+    id: number;
+    /** Put this in the field's value. */
+    url: string;
+}
+
+interface CustomManufacturingApi {
+    /**
+     * Uploads a file for an image/file field of a custom-manufacturing form; put `url` in the
+     * field's value. `file` is a `File` or `Blob` on the web, `{ uri, name, type }` in React
+     * Native. Needs a logged-in customer.
+     */
+    uploadFile(file: UploadFile, fileName?: string): Promise<UploadedFile>;
+}
+
+/** A customer's product subscription (regular deliveries of one or more SKUs). */
+type SubscriptionStatus = 'created' | 'accepted' | 'paid' | 'in-progress' | 'hold' | 'completed' | 'cancelled' | 'declined';
+type SubscriptionInterval = 'daily' | 'alternate-day' | 'weekly' | 'monthly';
+type Weekday = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+interface Subscription {
+    id: number;
+    /** e.g. "SUB-0001"; null until the backend assigns it. */
+    number: string | null;
+    status: SubscriptionStatus;
+    interval: SubscriptionInterval | null;
+    /** ISO dates (YYYY-MM-DD). */
+    startDate: string | null;
+    endDate: string | null;
+    /** Delivery days of a weekly subscription; empty for other intervals. */
+    weekdays: Weekday[];
+    /** ISO date whose day of the month is the delivery day (monthly). */
+    monthDay: string | null;
+    addressId: number | null;
+    /** The merchant's decline reason or the customer's cancellation reason. */
+    reason: string | null;
+    createdAt: string;
+}
+type DeliveryStatus = 'scheduled' | 'delivered' | 'partially-delivered' | 'un-delivered' | 'invoiced';
+interface SubscriptionDeliveryItem {
+    id: number;
+    skuId: number;
+    name: string;
+    quantity: number;
+    unit: string | null;
+    price: number | null;
+    status: 'scheduled' | 'delivered' | 'un-delivered';
+    /** The product was removed from the subscription after this delivery. */
+    removed: boolean;
+}
+interface SubscriptionDelivery {
+    id: number;
+    /** ISO date. */
+    date: string | null;
+    status: DeliveryStatus;
+    items: SubscriptionDeliveryItem[];
+}
+/** A pause period; `endDate` is null while the subscription is still on hold. */
+interface SubscriptionHold {
+    id: number;
+    startDate: string | null;
+    endDate: string | null;
+}
+type InvoicePaymentStatus = 'paid' | 'unpaid' | 'refund' | 'unverified' | 'partially-paid';
+interface SubscriptionInvoice {
+    id: number;
+    orderId: number | null;
+    invoiceNumber: string | null;
+    invoiceDate: string | null;
+    dueDate: string | null;
+    /** Display text from the backend, e.g. "1 Oct - 31 Oct 2026". */
+    billingPeriod: string;
+    amount: number | null;
+    /** 'unpaid' when no payment was started. */
+    paymentStatus: InvoicePaymentStatus;
+}
+/**
+ * The result of `subscriptions.payInvoice`: the invoice is already paid, or there is a payment
+ * to make. Then run the provider's SDK for `payment.method` and confirm through
+ * `client.payments`, as after placing an order.
+ */
+type InvoicePayment = {
+    status: 'paid';
+} | {
+    status: 'payment-required';
+    payment: PendingPayment;
+};
+
+interface SubscriptionsApi {
+    /** The customer's subscriptions, newest first. Default limit 20. */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Page<Subscription>>;
+    /** Throws GrowupsellApiError with status 404 for a subscription that is not the customer's. */
+    detail(id: number): Promise<Subscription>;
+    /** Scheduled and past deliveries, oldest first. */
+    deliveries(id: number): Promise<SubscriptionDelivery[]>;
+    /** Pause periods, newest first. */
+    holds(id: number): Promise<SubscriptionHold[]>;
+    invoices(id: number): Promise<SubscriptionInvoice[]>;
+    /**
+     * Starts (or resumes) paying an invoice, e.g. from the "pay now" link in the invoice email.
+     * Returns `{status: 'paid'}`, or the payment to make: run the SDK for `payment.method`, then
+     * confirm through `client.payments`.
+     *
+     * Not a read, although the backend serves it as a GET: the first call for an invoice
+     * creates a payment and a gateway order; later calls return that same payment until it is
+     * paid. Call it only when the shopper chooses to pay, never to prefetch or poll.
+     *
+     * Every backend failure is a GrowupsellApiError with status 500 and the message
+     * "Something Went Wrong": unknown invoice, the business has no active online payment
+     * method, or the invoice's order is not completed. Show it as "this invoice cannot be paid
+     * online right now" rather than as a crash.
+     */
+    payInvoice(invoiceId: number): Promise<InvoicePayment>;
+    /**
+     * Subscribes the customer to a SKU. The merchant usually has to accept it (status
+     * `created` until then). Inputs the backend would silently accept but never deliver
+     * (weekly without weekdays) are refused before sending.
+     */
+    create(input: CreateSubscriptionInput): Promise<Subscription>;
+    /** Pauses an accepted, paid or running subscription; future deliveries are removed. */
+    hold(id: number): Promise<Subscription>;
+    /** Resumes a paused subscription; deliveries are scheduled again. */
+    resume(id: number): Promise<Subscription>;
+    /** Cancels with the customer's reason (required by the backend). */
+    cancel(id: number, reason: string): Promise<Subscription>;
+}
+interface CreateSubscriptionInput {
+    /** The logged-in customer's id: the backend takes it from the body, not from the login. */
+    customerId: number;
+    /** One of the customer's addresses. */
+    addressId: number;
+    skuId: number;
+    /** Per delivery; at least 1. */
+    quantity: number;
+    /**
+     * The SKU's current selling price (from the product detail). The backend stores and
+     * invoices what is sent; it does not look the price up.
+     */
+    price: number;
+    interval: SubscriptionInterval;
+    /** ISO dates (YYYY-MM-DD); the start must be after today (the backend checks). */
+    startDate: string;
+    endDate: string;
+    /** Required for 'weekly'; ignored otherwise. */
+    weekdays?: Weekday[];
+    /** Required for 'monthly': an ISO date whose day is the delivery day. Ignored otherwise. */
+    monthDay?: string;
+}
+
+/** Order history domain types. Built from wire responses in http/orders.ts. */
+/** Open string: the backend may add statuses. A cart is never an order (`cart` never appears). */
+type OrderStatus = 'created' | 'unpaid' | 'in_progress' | 'accepted' | 'shipping' | 'completed' | 'declined' | 'cancelled' | (string & {});
+type PaymentStatus = 'paid' | 'unpaid' | 'refund' | 'unverified' | 'partially-paid' | (string & {});
+/** The address as it was on the order. */
+interface OrderAddress {
+    id: number;
+    line1: string | null;
+    line2: string | null;
+    landmark: string | null;
+    city: string | null;
+    /** State name, e.g. "Maharashtra". */
+    state: string | null;
+    postalCode: string | null;
+    country: string | null;
+    /** The customer's label for the address, e.g. "home". */
+    type: string | null;
+}
+/** A row of the order history (`orders.list()`). */
+interface OrderListItem {
+    id: number;
+    /** Shown to the shopper; null until the merchant numbers the order. */
+    orderNumber: string | null;
+    /** `delivery`, `cod`, … */
+    type: string;
+    status: OrderStatus;
+    payable: number;
+    placedAt: string;
+}
+/** A line of a placed order. */
+interface OrderLine {
+    id: number;
+    /** Null for lines without a SKU (made by the merchant). */
+    skuId: number | null;
+    productId: number | null;
+    /** Product name with variants. */
+    name: string;
+    photo: string | null;
+    unitPrice: number;
+    quantity: number;
+    lineTotal: number;
+    /** Product/category/brand-level offer amount on this line; 0 otherwise. */
+    offerDiscount: number;
+    taxPercent: number | null;
+    isDigital: boolean;
+    customData: Record<string, unknown> | null;
+    /** The shopper may ask for a replacement (same SKU) of this line. */
+    canReplace: boolean;
+    /** The shopper may ask for an exchange (sibling SKU) of this line. */
+    canExchange: boolean;
+    /** How many units can still be replaced or exchanged. */
+    maxReplaceOrExchangeQuantity: number;
+}
+/** One part of the order's payment: online, gift card, reward points, cash on delivery… */
+interface OrderPaymentEntry {
+    id: number;
+    /** `pg`, `cod`, `giftcard`, `reward_point`, `cash`, `advance`; null if unknown. */
+    type: string | null;
+    amount: number;
+    status: string;
+    method: PaymentMethodType | null;
+    /** Human-readable, e.g. "Razorpay" or "Giftcard". */
+    label: string;
+}
+/** A placed order (`orders.detail()`). */
+interface OrderDetail {
+    id: number;
+    orderNumber: string | null;
+    invoiceNumber: string | null;
+    type: string;
+    status: OrderStatus;
+    /** The merchant's or the shopper's note on the last status change. */
+    statusMessage: string | null;
+    placedAt: string;
+    lines: OrderLine[];
+    subtotal: number;
+    offerDiscount: number;
+    promoDiscount: number;
+    deliveryCharge: number;
+    payable: number;
+    /** Null for digital-only orders. */
+    shippingAddress: OrderAddress | null;
+    billingAddress: OrderAddress | null;
+    payments: OrderPaymentEntry[];
+    hasExchangeOrReplacement: boolean;
+}
+/** The light order card of the history list (`orders.summary()`). */
+interface OrderSummary {
+    id: number;
+    orderNumber: string | null;
+    invoiceNumber: string | null;
+    status: OrderStatus;
+    subtotal: number;
+    payable: number;
+    placedAt: string;
+    items: {
+        name: string;
+        /** Variant labels, e.g. "128 GB, Blue"; null without variants. */
+        variant: string | null;
+        photo: string | null;
+        quantity: number;
+        unitPrice: number;
+    }[];
+    /** Null for digital-only orders. */
+    deliveryAddress: OrderAddress | null;
+    /** Null when the order has no payment record. */
+    payment: {
+        id: number;
+        status: PaymentStatus;
+        amount: number;
+        mode: string | null;
+    } | null;
+}
+/** A shipment of some of the order's lines. */
+interface Shipment {
+    id: number;
+    /** Delivery partner, e.g. "Shiprocket"; "Self" when the merchant delivers. */
+    partner: string;
+    trackingNumber: string | null;
+    /** As the backend labels it, e.g. "Out for delivery". */
+    status: string;
+    createdAt: string;
+    items: {
+        orderLineId: number;
+        name: string;
+        photo: string | null;
+        quantity: number;
+    }[];
+}
+/** Tracking for a partner shipment. */
+interface TrackingInfo {
+    trackingUrl: string | null;
+    /** The partner's tracking data as sent (Shiprocket). Not yet typed: no real response seen. */
+    events: unknown;
+}
+type InvoiceFormat = 'a4' | 'thermal_58mm' | 'thermal_108mm';
+
+interface OrderListOptions {
+    /** Page size. Default 10. */
+    limit?: number;
+    offset?: number;
+    /** Only orders in these statuses. */
+    status?: readonly OrderStatus[];
+    /** Matches the order number. */
+    search?: string;
+}
+interface DocumentOptions {
+    /** Paper format. Default `a4`. */
+    format?: InvoiceFormat;
+}
+interface CancelCodItemsInput {
+    orderId: number;
+    /** Lines to cancel (`OrderLine.id`) and how many units of each. */
+    items: readonly {
+        orderLineId: number;
+        quantity: number;
+    }[];
+    /** Shown to the merchant as the order's status message. */
+    reason: string;
+}
+interface OrdersApi {
+    /** The logged-in customer's placed orders, newest first. */
+    list(options?: OrderListOptions): Promise<Page<OrderListItem>>;
+    /**
+     * A placed order with its lines, payments and addresses. Rejects with a 404 for an order of
+     * another customer. Also the way to check an order after a payment or a timed-out
+     * `placeOrder`: a status other than `cart` means it was placed.
+     */
+    detail(orderId: number): Promise<OrderDetail>;
+    /** The light order card the history list shows. */
+    summary(orderId: number): Promise<OrderSummary>;
+    /** The order's shipments, newest first, each with the lines it carries. */
+    shipments(orderId: number): Promise<Shipment[]>;
+    /**
+     * Partner tracking for a shipment's `trackingNumber`. Rejects with a 400 (no message) for
+     * shipments the merchant delivers itself: only Shiprocket shipments can be tracked.
+     */
+    tracking(trackingNumber: string): Promise<TrackingInfo>;
+    /**
+     * The order's invoice as PDF bytes (`contentType` `application/pdf`), e.g. to open in a tab
+     * or share. Rejects with a 400 "Invoice not generated yet" until the merchant invoices it.
+     */
+    invoice(orderId: number, options?: DocumentOptions): Promise<BinaryResponse>;
+    /** E-mails the invoice to the customer instead. */
+    emailInvoice(orderId: number, options?: DocumentOptions): Promise<void>;
+    /** The credit note of a return (`ReturnRequest.id`) as PDF bytes. */
+    creditNote(returnId: number, options?: DocumentOptions): Promise<BinaryResponse>;
+    /** E-mails the credit note to the customer instead. */
+    emailCreditNote(returnId: number, options?: DocumentOptions): Promise<void>;
+    /**
+     * Cancels some units, or all, of an accepted cash-on-delivery order. Rejects with a 400 for
+     * other orders. Not idempotent: disable the button while it runs. Rejects without a request
+     * (`TypeError`, `RangeError`) when `items` is empty, a quantity is below 1 or `reason` is
+     * blank.
+     */
+    cancelCodItems(input: CancelCodItemsInput): Promise<void>;
+}
+
+/** Return and exchange domain types. Built from wire responses in http/returns.ts and
+ * http/exchanges.ts. */
+
+/** An order line that can still be returned. */
+interface ReturnableItem {
+    /** The order line (`OrderLine.id`): pass it to `returns.create()`. */
+    orderLineId: number;
+    name: string;
+    photo: string | null;
+    unitPrice: number;
+    /** Units bought minus units already returned (accepted or completed returns). */
+    maxQuantity: number;
+    /** Serial-tracked units of the line not yet returned; empty for untracked products. */
+    unitTrackingIds: number[];
+}
+/** Open string: the backend may add statuses. */
+type ReturnStatus = 'requested' | 'accepted' | 'declined' | 'in_progress' | 'completed' | (string & {});
+/** A return request of an order. */
+interface ReturnRequest {
+    /** Pass it to `orders.creditNote()` once the return is refunded. */
+    id: number;
+    status: ReturnStatus;
+    createdAt: string;
+    /** Refund amount after offers and promo codes. */
+    amount: number;
+    items: {
+        /** The return line id. The backend does not send which order line it belongs to. */
+        id: number;
+        name: string;
+        quantity: number;
+        status: ReturnStatus;
+    }[];
+}
+/** `replace`: the same SKU again; `exchange`: a sibling SKU of the same product. */
+type ExchangeType = 'replace' | 'exchange';
+/**
+ * A SKU the shopper can exchange a bought SKU for: an active, in-stock sibling of the same
+ * product (another variant), never the bought SKU itself.
+ */
+interface ExchangeTargetSku {
+    skuId: number;
+    skuCode: string;
+    /** Product name with the SKU's variants, e.g. "Iphone 15 (256 GB, Blue)". */
+    name: string;
+    /** The SKU's first photo; null when the product has none. */
+    photo: string | null;
+    price: number;
+    /** Always above 0: SKUs out of stock are not offered. */
+    stockQty: number;
+}
+/** An exchange or replacement request of an order. */
+interface ExchangeListItem {
+    id: number;
+    type: ExchangeType;
+    /** `requested`, `accepted`, `declined`, `in_progress` or `completed`. */
+    status: ReturnStatus;
+    createdAt: string;
+    /** The extra payment when the new SKU costs more; null otherwise. */
+    paymentId: number | null;
+    itemCount: number;
+}
+interface ExchangeDetail extends ExchangeListItem {
+    items: {
+        orderLineId: number;
+        /** The originally bought SKU's name with variants; null for lines without a SKU. */
+        name: string | null;
+        /** The SKU the shopper gets (the same SKU for a replacement). */
+        targetSkuId: number | null;
+        quantity: number;
+        /** Positive: the shopper pays the difference; negative: the store refunds it. */
+        priceDifference: number;
+        status: ReturnStatus;
+    }[];
+}
+/**
+ * The result of `exchanges.create()`. `payment-required` when the new SKU costs more and the
+ * difference is paid online: collect it like a checkout payment. Cash-on-delivery orders pay
+ * the difference on delivery, so they are `submitted`.
+ */
+type ExchangeResult = {
+    status: 'submitted';
+    id: number;
+    message: string | null;
+} | {
+    status: 'payment-required';
+    id: number;
+    payment: PendingPayment;
+};
+
+interface CreateReturnInput {
+    orderId: number;
+    /** The shopper's reason, shown to the merchant. */
+    reason: string;
+    items: readonly {
+        /** From `eligibleItems()`. */
+        orderLineId: number;
+        quantity: number;
+        /** For serial-tracked products: which units (from `eligibleItems()`). */
+        unitTrackingIds?: readonly number[];
+    }[];
+}
+interface ReturnsApi {
+    /** The order's lines that can still be returned (digital products never can). */
+    eligibleItems(orderId: number): Promise<ReturnableItem[]>;
+    /** The order's return requests, newest first. */
+    list(orderId: number): Promise<ReturnRequest[]>;
+    /**
+     * Requests a return; the merchant accepts or declines it. Not idempotent: disable the button
+     * while it runs. Rejects without a request (`TypeError`, `RangeError`) when `items` is empty,
+     * `reason` is blank or a quantity is below 1. Quantities are not checked against
+     * `eligibleItems()` here, and the backend does not check them either: the caller must.
+     */
+    create(input: CreateReturnInput): Promise<{
+        id: number;
+    }>;
+}
+
+interface CreateExchangeInput {
+    orderId: number;
+    type: ExchangeType;
+    /** The shopper's reason for the whole request. */
+    reason?: string;
+    items: readonly {
+        /** A line with `canReplace` / `canExchange` (`OrderLine.id`). */
+        orderLineId: number;
+        /** At most `OrderLine.maxReplaceOrExchangeQuantity`. */
+        quantity: number;
+        /** Required for `exchange`: a sibling SKU of the same product. Ignored for `replace`. */
+        targetSkuId?: number;
+        /** A reason for this line. */
+        reason?: string;
+        /** A photo of the item: a `File`/`Blob` on the web, `{ uri, name, type }` in React Native. */
+        photo?: UploadFile;
+    }[];
+}
+interface ExchangesApi {
+    /**
+     * Requests a replacement (same SKU) or an exchange (sibling SKU). When the new SKU costs more
+     * and the order was paid online, resolves `payment-required`: collect the payment like a
+     * checkout payment. Not idempotent: disable the button while it runs. Rejects without a
+     * request (`TypeError`, `RangeError`) when `items` is empty, a quantity is below 1 or an
+     * `exchange` item has no `targetSkuId`. Sent as multipart form data when any item has a photo.
+     */
+    create(input: CreateExchangeInput): Promise<ExchangeResult>;
+    /** The order's exchange and replacement requests, newest first. */
+    list(orderId: number): Promise<ExchangeListItem[]>;
+    /** One request with its lines. Rejects with a 404 for another customer's request. */
+    detail(exchangeId: number): Promise<ExchangeDetail>;
+    /**
+     * The SKUs a bought SKU can be exchanged for (`targetSkuId` in `create`): the product's other
+     * active, in-stock variants. Takes the bought SKU's id (`OrderLine.skuId`), not the order line:
+     * the backend checks no line eligibility, so offer it only for lines with `canExchange`.
+     * Rejects with a 404 when the SKU is unknown or deleted.
+     */
+    targetSkus(skuId: number): Promise<ExchangeTargetSku[]>;
+}
+
+interface Client {
+    /** Low-level request; prefer the domain modules below. */
+    request: RequestFn;
+    business: BusinessApi;
+    catalog: CatalogApi;
+    products: ProductsApi;
+    reviews: ReviewsApi;
+    wishlist: WishlistApi;
+    policies: PoliciesApi;
+    faq: FaqApi;
+    themeContent: ThemeContentApi;
+    /** Merchant-built product-page content: sections and blocks. */
+    productPage: ProductPageApi;
+    /** Merchant-built storefront pages (e.g. `/about-us`): hero and sections. */
+    customPages: CustomPagesApi;
+    /** Guest sessions (`x-session-token`). */
+    session: SessionApi;
+    /** Countries and states for the address form. */
+    lookup: LookupApi;
+    /** Signed-out customer flows: settings, sign-up, login, OTP, password reset. */
+    auth: AuthApi;
+    /** The logged-in customer's own account: profile, password, email and phone. */
+    customer: CustomerApi;
+    /** The logged-in customer's saved addresses. */
+    addresses: AddressesApi;
+    /** Checkout: order settings, placing the order, made-to-order advance orders. */
+    checkout: CheckoutApi;
+    /** Confirming payments: PhonePe, Stripe, Razorpay, bank transfer proof. */
+    payments: PaymentsApi;
+    blog: BlogApi;
+    forms: FormsApi;
+    helpdesk: HelpdeskApi;
+    /** Email newsletter sign-up (backend `/subscribers/`). */
+    newsletter: NewsletterApi;
+    /** Web push subscriptions; the app does the browser work and passes the subscription in. */
+    push: PushApi;
+    liveSupport: LiveSupportApi;
+    /** File uploads for custom-manufacturing form fields (logged-in customer). */
+    customManufacturing: CustomManufacturingApi;
+    /** A customer's product subscriptions: deliveries, pauses, invoices. */
+    subscriptions: SubscriptionsApi;
+    /** The shopper's cart (customer or guest session). */
+    cart: CartApi;
+    /** Offers, promo codes, gift cards and reward point settings. */
+    promotions: PromotionsApi;
+    /** The logged-in customer's placed orders: history, shipments, invoices, COD cancellation. */
+    orders: OrdersApi;
+    /** Return requests of the logged-in customer's orders. */
+    returns: ReturnsApi;
+    /** Replacement and exchange requests of the logged-in customer's orders. */
+    exchanges: ExchangesApi;
+}
+/**
+ * Creates an HTTP client for the Growupsell backend (ADR-008, ADR-015).
+ * Stateless apart from remembering which rejected token it already reported.
+ */
+declare function createClient(options: ClientOptions): Client;
+
+export { createClient as bu };
+export type { ExchangeDetail as $, AddCartItemInput as A, BankTransferOption as B, CancelCodItemsInput as C, ContentImage as D, ContentImageUpload as E, ContentImageUsage as F, ContentPlatform as G, Country as H, CountryState as I, CreateAdvanceOrderInput as J, CreateExchangeInput as K, CreateReturnInput as L, CreateReviewInput as M, CreateSubscriptionInput as N, Credentials as O, Currency as P, CustomManufacturingApi as Q, CustomPage as R, CustomPageContent as S, CustomPageContentInput as T, CustomPageHero as U, CustomPageSection as V, CustomPagesApi as W, CustomerApi as X, CustomerSettings as Y, DeliveryStatus as Z, DocumentOptions as _, Address as a, ReturnStatus as a$, ExchangeListItem as a0, ExchangeResult as a1, ExchangeTargetSku as a2, ExchangeType as a3, ExchangesApi as a4, Faq as a5, FaqApi as a6, FaqInput as a7, FetchInitLike as a8, FetchLike as a9, OrderPaymentEntry as aA, OrderStatus as aB, OrderSummary as aC, OrdersApi as aD, PaymentConfirmation as aE, PaymentStatus as aF, PaymentsApi as aG, PlaceOrderOptions as aH, PoliciesApi as aI, Policy as aJ, PolicyInput as aK, PolicyType as aL, ProductPageApi as aM, ProductSectionItemTargetInput as aN, ProductsApi as aO, PromotionsApi as aP, PublicForm as aQ, PushApi as aR, PushSubscriptionJson as aS, Query as aT, QueryValue as aU, RazorpayResult as aV, RegisterInput as aW, RequestFn as aX, RequestOptions as aY, ResetPasswordInput as aZ, ReturnRequest as a_, FetchResponseLike as aa, FormDataLike as ab, FormField as ac, FormFieldOption as ad, FormFieldType as ae, FormSummary as af, FormValue as ag, FormsApi as ah, GuestSession as ai, HelpdeskApi as aj, HttpMethod as ak, InquiryInput as al, InvoiceFormat as am, InvoicePayment as an, InvoicePaymentStatus as ao, LiveSupportApi as ap, LiveSupportWidget as aq, LoginInput as ar, LookupApi as as, MoveDirection as at, NewsletterApi as au, OrderAddress as av, OrderDetail as aw, OrderLine as ax, OrderListItem as ay, OrderListOptions as az, AddressInput as b, ReturnableItem as b0, ReturnsApi as b1, ReviewPhoto as b2, ReviewsApi as b3, SessionApi as b4, Shipment as b5, SignedInCustomer as b6, SocialLinks as b7, Subscription as b8, SubscriptionDelivery as b9, SubscriptionDeliveryItem as ba, SubscriptionHold as bb, SubscriptionInterval as bc, SubscriptionInvoice as bd, SubscriptionStatus as be, SubscriptionsApi as bf, ThemeContent as bg, ThemeContentApi as bh, ThemeSettings as bi, ThemeSettingsUpdate as bj, TrackingInfo as bk, UnauthorizedEvent as bl, UpdateProfileInput as bm, UpdateReviewInput as bn, UploadFile as bo, UploadedFile as bp, VerifyOtpInput as bq, Weekday as br, WishlistApi as bs, WishlistItem as bt, AddressesApi as c, AnyFetch as d, AuthApi as e, AuthResult as f, BinaryResponse as g, BlogApi as h, BlogAuthor as i, BlogCategory as j, BlogEditor as k, BlogPost as l, BlogPostSummary as m, Business as n, BusinessApi as o, BusinessMedia as p, BusinessSettings as q, CartAddressesInput as r, CartApi as s, CatalogApi as t, ChangePasswordInput as u, CheckoutApi as v, Client as w, ClientOptions as x, ConfirmEmailChangeInput as y, ConfirmPhoneChangeInput as z };