@tuppence/node 0.0.0-stage → 0.1.1

package/dist/resources.js

@@ -0,0 +1,1816 @@
+import { EncodedBody } from "./http.js";
+const id = (value) => encodeURIComponent(value);
+/** Every list, as an async iterator that fetches the next page only when it is needed. */
+async function* paginate(fetchPage, params = {}) {
+    let cursor = params.starting_after;
+    for (;;) {
+        const page = await fetchPage({ ...params, ...(cursor ? { starting_after: cursor } : {}) });
+        for (const item of page.data)
+            yield item;
+        const last = page.data[page.data.length - 1];
+        if (!page.has_more || !last)
+            return;
+        cursor = last.id;
+    }
+}
+function lister(http, path) {
+    const list = (params = {}, options) => http.request("GET", path, { query: params, ...options });
+    return {
+        list,
+        /** `for await (const item of listAll())` — every item, page by page. */
+        listAll: (params = {}, options) => paginate((p) => list({ ...params, ...p }, options)),
+    };
+}
+/** A list under one parent — `accounts.persons.list("acct_…")` — and its `listAll`. */
+function childLister(http, path) {
+    return {
+        list: (parentId, params = {}, options) => lister(http, path(parentId)).list(params, options),
+        listAll: (parentId, params = {}, options) => lister(http, path(parentId)).listAll(params, options),
+    };
+}
+/**
+ * The upload, as multipart — encoded ONCE, so every retry sends the same bytes under the same
+ * idempotency key. A stream is read whole first (the API takes up to 10 MB).
+ */
+async function multipart(fields, { file, filename }) {
+    // A copy the Blob can own: a view may sit on a SharedArrayBuffer.
+    const own = (view) => new Uint8Array(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    let blob;
+    if (file instanceof Blob)
+        blob = file;
+    else if (file instanceof ArrayBuffer)
+        blob = new Blob([file]);
+    else if (ArrayBuffer.isView(file))
+        blob = new Blob([own(file)]);
+    else {
+        const chunks = [];
+        for await (const chunk of file)
+            chunks.push(typeof chunk === "string" ? chunk : own(chunk));
+        blob = new Blob(chunks);
+    }
+    const form = new FormData();
+    for (const [name, value] of Object.entries(fields))
+        form.append(name, value);
+    form.append("file", blob, filename ?? (typeof File !== "undefined" && file instanceof File ? file.name : "upload"));
+    const encoded = new Response(form);
+    return new EncodedBody(new Uint8Array(await encoded.arrayBuffer()), encoded.headers.get("content-type") ?? "multipart/form-data");
+}
+export function resources(http) {
+    /** create / retrieve / update / list, the shape most resources share. */
+    const crud = (path) => ({
+        create: (body, options) => http.request("POST", path, { body, ...options }),
+        retrieve: (objectId, options) => http.request("GET", `${path}/${id(objectId)}`, options),
+        update: (objectId, body, options) => http.request("POST", `${path}/${id(objectId)}`, { body, ...options }),
+        ...lister(http, path),
+    });
+    return {
+        /** The AI agents a business runs — what its cards belong to (14-03). */
+        agents: {
+            ...crud("/v1/agents"),
+            /** What's normal for this agent's spending, and its latest unusual purchases (19-07). */
+            profile: (agentId, options) => http.request("GET", `/v1/agents/${id(agentId)}/profile`, options),
+            /**
+             * Funding mandates (54-15, E13): what a person lets an agent top the cards up with. Only a
+             * person signed in to the dashboard gives one (fresh second factor); a key lists and revokes.
+             */
+            fundingMandates: {
+                list: (agentId, params = {}, options) => http.request("GET", `/v1/agents/${id(agentId)}/funding_mandates`, { query: params, ...options }),
+                retrieve: (agentId, mandateId, options) => http.request("GET", `/v1/agents/${id(agentId)}/funding_mandates/${id(mandateId)}`, options),
+                /** Revoked at once: the agent's next top-up asks a person. */
+                revoke: (agentId, mandateId, options) => http.request("DELETE", `/v1/agents/${id(agentId)}/funding_mandates/${id(mandateId)}`, options),
+            },
+        },
+        /** Who cards are issued to. Secret keys only (14-03). */
+        cardholders: crud("/v1/cardholders"),
+        /** The rules cards spend under: on a card, or an agent's default. Secret keys only (14-04). */
+        spendPolicies: crud("/v1/spend_policies"),
+        /**
+         * Cards (14-05): virtual — the business's own, or an agent's (`agent`) — or physical, a
+         * person's. A person sees a card's number in Stripe's own fields, in the dashboard or the app
+         * (14-12, 16-07); the SDK never has a method for that.
+         */
+        cards: {
+            create: (body, options) => http.request("POST", "/v1/cards", { body, ...options }),
+            retrieve: (cardId, options) => http.request("GET", `/v1/cards/${id(cardId)}`, options),
+            update: (cardId, body, options) => http.request("POST", `/v1/cards/${id(cardId)}`, { body, ...options }),
+            /** `null` removes a limit; a card always keeps at least one. */
+            setLimits: (cardId, body, options) => http.request("POST", `/v1/cards/${id(cardId)}/limits`, { body, ...options }),
+            activate: (cardId, options) => http.request("POST", `/v1/cards/${id(cardId)}/activate`, options),
+            freeze: (cardId, options) => http.request("POST", `/v1/cards/${id(cardId)}/freeze`, options),
+            unfreeze: (cardId, options) => http.request("POST", `/v1/cards/${id(cardId)}/unfreeze`, options),
+            cancel: (cardId, options) => http.request("POST", `/v1/cards/${id(cardId)}/cancel`, options),
+            /**
+             * An active virtual card's number, CVC and expiry — the business's own or an agent's — to
+             * fill in a merchant's checkout (14-22). Only a restricted key made with `card_details:read`, on an account whose
+             * owner has allowed it; ten a minute per key; every read is audited and sent as
+             * `card.details_retrieved`. The SDK keeps nothing: never store, print or log the answer.
+             */
+            retrieveDetails: (cardId, options) => http.request("GET", `/v1/cards/${id(cardId)}/details`, options),
+            ...lister(http, "/v1/cards"),
+        },
+        /** Every purchase a card attempted, and what was decided (14-07). */
+        cardAuthorizations: {
+            retrieve: (authorizationId, options) => http.request("GET", `/v1/card_authorizations/${id(authorizationId)}`, options),
+            ...lister(http, "/v1/card_authorizations"),
+        },
+        /** What settled on the cards — captures and refunds (14-08) — and each purchase's story (14-10). */
+        cardTransactions: {
+            /** With `timeline`: asked, approved, authorised, captured, refunded — oldest first. */
+            retrieve: (transactionId, options) => http.request("GET", `/v1/card_transactions/${id(transactionId)}`, options),
+            ...lister(http, "/v1/card_transactions"),
+        },
+        /**
+         * Disputing a card purchase (53-05): a draft until submitted. Fill in the evidence, attach
+         * files, then submit — once; a person's act (an agent's key gets
+         * `dispute_submission_needs_person`, or an approval of `kind: "card_dispute_submission"`).
+         * Refusals: `dispute_evidence_incomplete` (`missing_evidence` in the error's `raw`),
+         * `dispute_window_closed` (`dispute_by`), `dispute_not_allowed` (`available_at`).
+         */
+        cardDisputes: {
+            /** `submit: true` sends it at once; `prefill: true` fills the evidence from what we know. */
+            create: (cardTransactionId, body = {}, options) => http.request("POST", `/v1/card_transactions/${id(cardTransactionId)}/disputes`, { body, ...options }),
+            retrieve: (disputeId, options) => http.request("GET", `/v1/card_disputes/${id(disputeId)}`, options),
+            /** A draft's evidence: fields you send replace what is saved; `null` clears one. */
+            update: (disputeId, body, options) => http.request("POST", `/v1/card_disputes/${id(disputeId)}`, {
+                body,
+                ...options,
+            }),
+            /** Attaches a PDF or JPEG (up to 5 MB) to a draft's evidence, as multipart. */
+            uploadFile: async (disputeId, params, options) => http.request("POST", `/v1/card_disputes/${id(disputeId)}/files`, {
+                body: await multipart(params.field ? { field: params.field } : {}, params),
+                ...options,
+            }),
+            /** Sends it to the card network. Nothing can be added after. */
+            submit: (disputeId, options) => http.request("POST", `/v1/card_disputes/${id(disputeId)}/submit`, options),
+            ...lister(http, "/v1/card_disputes"),
+        },
+        /** The cards' own balance, its top-ups (M54) and Issuing's limits (53-03). */
+        issuing: {
+            /**
+             * Each card limit: its value, what is used, when it resets and where it comes from. Over
+             * one, a request fails with `issuing_card_limit` / `issuing_cardholder_limit` (`limit`,
+             * `used`, `max`, `resets_at`, `increase_url` in the error's `raw`).
+             */
+            limits: {
+                retrieve: (options) => http.request("GET", "/v1/issuing/limits", options),
+            },
+            /**
+             * What the cards can spend right now (`spendable`) — read it before buying. `spends_from`:
+             * `issuing_balance` (UK, topped up) or `payments_balance` (US, the earnings directly).
+             */
+            balance: {
+                retrieve: (options) => http.request("GET", "/v1/issuing/balance", options),
+            },
+            /** The card balance's own bank details (UK: sort code and account number). */
+            fundingInstructions: {
+                retrieve: (options) => http.request("GET", "/v1/issuing/funding_instructions", options),
+            },
+            /**
+             * Money on its way to the card balance, whatever the method. Until it is `available` a
+             * top-up says what it waits on (`delay`) and when it should be spendable
+             * (`expected_available_at`); `issuing_topup.*` webhooks carry every change.
+             */
+            topups: {
+                /**
+                 * `{ method: "bank_transfer", amount }` (UK, free): `requires_action`, with your card
+                 * balance's bank details and a reference in `next_action.bank_transfer`; nothing moves
+                 * until you send it. `{ method: "balance", speed: "instant" }`: pending money onto the
+                 * cards now, for 0.99%. Every call carries an `Idempotency-Key` (pass `idempotencyKey`
+                 * to choose it), reused by its retries, so a retry never makes a second top-up.
+                 */
+                /**
+                 * Every way to top up that can be made now (54-07): for each `method` and `speed`,
+                 * `available` — or `reason`, `message` and a `fix_url` — the `fee`, the `total` you pay for
+                 * `amount` to arrive, `expected_available_at`, the `delay` it would wait on, and for
+                 * `bank_transfer` the bank details. Leave `amount` out for rates and timings only.
+                 */
+                options: (params = {}, options) => http.request("GET", "/v1/issuing/topups/options", {
+                    query: Object.fromEntries(Object.entries(params)
+                        .filter(([, v]) => v !== undefined)
+                        .map(([k, v]) => [k, String(v)])),
+                    ...options,
+                }),
+                create: (body, options) => http.request("POST", "/v1/issuing/topups", { body, ...options }),
+                retrieve: (topupId, options) => http.request("GET", `/v1/issuing/topups/${id(topupId)}`, options),
+                /** Calls off one still `requires_action` — before any money moves. */
+                cancel: (topupId, options) => http.request("POST", `/v1/issuing/topups/${id(topupId)}/cancel`, options),
+                /** Newest first; `status` and `method` filter. */
+                ...lister(http, "/v1/issuing/topups"),
+            },
+            /**
+             * Hosted top-up pages (54-18): a person tops up the card balance by card, or sees its bank
+             * details. Single use, good for 24 hours; a connected account's page wears its platform's
+             * branding. In a browser, `@tuppence/js`'s `tuppence.topups.redirect({ url })` sends them.
+             */
+            topupLinks: {
+                /** `{ return_url, amount? }`: the answer's `url` is shown only now — send it on. */
+                create: (body, options) => http.request("POST", "/v1/issuing/topup_links", { body, ...options }),
+                /** `open`, `used` (with the `topup` made on it) or `expired`. */
+                retrieve: (linkId, options) => http.request("GET", `/v1/issuing/topup_links/${id(linkId)}`, options),
+            },
+            /**
+             * The auto top-up rule (54-15): when Spendable, plus top-ups on their way, falls below
+             * `threshold`, top up by `amount` — `card` (a saved top-up card) or `balance` (UK). Paused
+             * after a failure (`status: paused`, `fix_url`). `update` changes only what it is sent.
+             */
+            autoTopup: {
+                retrieve: (options) => http.request("GET", "/v1/issuing/auto_topup", options),
+                update: (body, options) => http.request("POST", "/v1/issuing/auto_topup", { body, ...options }),
+            },
+            /**
+             * Your own cards saved for top-ups (54-15) — saved by a card top-up with
+             * `save_payment_method: true`, charged later with `{ method: "card", payment_method }`.
+             */
+            topupPaymentMethods: {
+                retrieve: (methodId, options) => http.request("GET", `/v1/issuing/topup_payment_methods/${id(methodId)}`, options),
+                /** Removed at Stripe too: it can't be charged again. */
+                remove: (methodId, options) => http.request("DELETE", `/v1/issuing/topup_payment_methods/${id(methodId)}`, options),
+                ...lister(http, "/v1/issuing/topup_payment_methods"),
+            },
+        },
+        /** TEST MODE: make things happen that a person, a bank or a card network would. */
+        testHelpers: {
+            issuing: {
+                topups: {
+                    /**
+                     * The bank transfer for a `requires_action` bank-transfer top-up arrives — Stripe's
+                     * test transfer, through the real arrival path. It is usually `available` in the answer;
+                     * on a slow sandbox, retrieve it again a few seconds later.
+                     */
+                    arrive: (topupId, options) => http.request("POST", `/v1/test_helpers/issuing/topups/${id(topupId)}/arrive`, options),
+                },
+            },
+        },
+        /** A person's say over a purchase at or over the threshold (14-09). Ask; poll; buy. */
+        approvals: {
+            /** Ask BEFORE buying — the merchant never sees a decline. */
+            create: (body, options) => http.request("POST", "/v1/approvals", { body, ...options }),
+            retrieve: (approvalId, options) => http.request("GET", `/v1/approvals/${id(approvalId)}`, options),
+            ...lister(http, "/v1/approvals"),
+        },
+        account: {
+            retrieve: (options) => http.request("GET", "/v1/account", options),
+            update: (body, options) => http.request("POST", "/v1/account", { body, ...options }),
+            /**
+             * Every price the account pays now (61-12): the card rate, surcharges, next-day and instant
+             * payouts, the dispute fee — each the list price or one agreed with Tuppence, with its dates.
+             */
+            retrievePricing: (params = {}, options) => http.request("GET", "/v1/account/pricing", {
+                query: params.currency ? { currency: params.currency } : {},
+                ...options,
+            }),
+        },
+        /**
+         * Bacs Direct Debit, by application (59-11): where the business is (`status`, its limits and
+         * usage, the price, and `fix_url` when something stops it), applying with a reason, answering
+         * what we asked, withdrawing, and asking for higher limits. Tuppence staff decide; a Connect
+         * platform may apply for one of its connected accounts with `{ tuppenceAccount }`.
+         */
+        directDebit: {
+            retrieve: (options) => http.request("GET", "/v1/direct_debit", options),
+            apply: (body, options) => http.request("POST", "/v1/direct_debit/application", {
+                body,
+                ...options,
+            }),
+            respond: (body, options) => http.request("POST", "/v1/direct_debit/application/respond", {
+                body,
+                ...options,
+            }),
+            withdraw: (options) => http.request("POST", "/v1/direct_debit/application/withdraw", options),
+            requestLimitIncrease: (body, options) => http.request("POST", "/v1/direct_debit/limit_increase", {
+                body,
+                ...options,
+            }),
+        },
+        /**
+         * Tuppence Connect: your connected accounts (M40) — each a full Tuppence account, which you
+         * act as with `{ tuppenceAccount }` on any request, or through `tuppence.as("acct_…")`.
+         */
+        accounts: {
+            /** Made in your key's mode, with Stripe's requirements for it in `requirements`. */
+            create: (body, options) => http.request("POST", "/v1/accounts", { body, ...options }),
+            retrieve: (accountId, options) => http.request("GET", `/v1/accounts/${id(accountId)}`, options),
+            update: (accountId, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}`, {
+                body,
+                ...options,
+            }),
+            /** Closes it. In live mode, only once it holds no money. */
+            del: (accountId, options) => http.request("DELETE", `/v1/accounts/${id(accountId)}`, options),
+            /** Its store as you see it (94-09): address, status, and this month's orders, revenue and your fees. */
+            retrieveStore: (accountId, options) => http.request("GET", `/v1/accounts/${id(accountId)}/store`, options),
+            /** Stops it for good: `fraud`, `terms_of_service` or `other`. */
+            reject: (accountId, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}/reject`, {
+                body,
+                ...options,
+            }),
+            ...lister(http, "/v1/accounts"),
+            /** The people behind a connected account (41-04): their names and roles come back, never the details. */
+            persons: {
+                create: (accountId, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}/persons`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (accountId, personId, options) => http.request("GET", `/v1/accounts/${id(accountId)}/persons/${id(personId)}`, options),
+                update: (accountId, personId, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}/persons/${id(personId)}`, {
+                    body,
+                    ...options,
+                }),
+                del: (accountId, personId, options) => http.request("DELETE", `/v1/accounts/${id(accountId)}/persons/${id(personId)}`, options),
+                /** Their identity check: a Stripe Identity session to send them to. */
+                createIdentitySession: (accountId, personId, options) => http.request("POST", `/v1/accounts/${id(accountId)}/persons/${id(personId)}/identity_sessions`, options),
+                /** Filter by role: `{ "relationship[owner]": true }`. */
+                ...childLister(http, (accountId) => `/v1/accounts/${id(accountId)}/persons`),
+            },
+            /**
+             * Where a connected account is paid out (41-05, 52-09, 52-17): the details, as
+             * `@tuppence/js` `bankAccountDetails` shapes them — kept encrypted by Tuppence, never
+             * returned or logged. A bank account token (`btok_…`) is refused.
+             */
+            externalAccounts: {
+                create: (accountId, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}/external_accounts`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (accountId, bankId, options) => http.request("GET", `/v1/accounts/${id(accountId)}/external_accounts/${id(bankId)}`, options),
+                /** `default_for_currency: true` — another becomes the default by being chosen. */
+                update: (accountId, bankId, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}/external_accounts/${id(bankId)}`, { body, ...options }),
+                /** Never the only default for its currency. */
+                del: (accountId, bankId, options) => http.request("DELETE", `/v1/accounts/${id(accountId)}/external_accounts/${id(bankId)}`, options),
+                ...childLister(http, (accountId) => `/v1/accounts/${id(accountId)}/external_accounts`),
+            },
+            /** What a connected account may do — `card_payments`, `transfers` — and what each needs. */
+            capabilities: {
+                list: (accountId, options) => http.request("GET", `/v1/accounts/${id(accountId)}/capabilities`, options),
+                retrieve: (accountId, capability, options) => http.request("GET", `/v1/accounts/${id(accountId)}/capabilities/${id(capability)}`, options),
+                update: (accountId, capability, body, options) => http.request("POST", `/v1/accounts/${id(accountId)}/capabilities/${id(capability)}`, { body, ...options }),
+            },
+        },
+        /** Onboarding a connected account (41-01): hand the link's `url` to the account's owner. */
+        accountLinks: {
+            /** Good once and for five minutes — make it when they click, not before. */
+            create: (body, options) => http.request("POST", "/v1/account_links", { body, ...options }),
+        },
+        /** Files for a connected account's verification (41-06), uploaded as that account. */
+        files: {
+            /** Send it as the account: `{ tuppenceAccount }`, or through `tuppence.as("acct_…")`. */
+            create: async (params, options) => http.request("POST", "/v1/files", {
+                body: await multipart({ purpose: params.purpose }, params),
+                ...options,
+            }),
+            retrieve: (fileId, options) => http.request("GET", `/v1/files/${id(fileId)}`, options),
+        },
+        /** Your fees on your connected accounts' payments (42-01), and any you gave back. */
+        applicationFees: {
+            retrieve: (feeId, options) => http.request("GET", `/v1/application_fees/${id(feeId)}`, options),
+            ...lister(http, "/v1/application_fees"),
+            refunds: {
+                /** All of what is left of the fee, or `amount` of it — from your Connect balance. */
+                create: (feeId, body = {}, options) => http.request("POST", `/v1/application_fees/${id(feeId)}/refunds`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (feeId, refundId, options) => http.request("GET", `/v1/application_fees/${id(feeId)}/refunds/${id(refundId)}`, options),
+                ...childLister(http, (feeId) => `/v1/application_fees/${id(feeId)}/refunds`),
+            },
+        },
+        /** Money from your Connect balance to a connected account (42-03), and back. */
+        transfers: {
+            create: (body, options) => http.request("POST", "/v1/transfers", { body, ...options }),
+            retrieve: (transferId, options) => http.request("GET", `/v1/transfers/${id(transferId)}`, options),
+            ...lister(http, "/v1/transfers"),
+            reversals: {
+                /** All of what is left of the transfer, or `amount` of it. */
+                create: (transferId, body = {}, options) => http.request("POST", `/v1/transfers/${id(transferId)}/reversals`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (transferId, reversalId, options) => http.request("GET", `/v1/transfers/${id(transferId)}/reversals/${id(reversalId)}`, options),
+                ...childLister(http, (transferId) => `/v1/transfers/${id(transferId)}/reversals`),
+            },
+        },
+        paymentLinks: {
+            create: (body, options) => http.request("POST", "/v1/payment_links", { body, ...options }),
+            retrieve: (linkId, options) => http.request("GET", `/v1/payment_links/${id(linkId)}`, options),
+            update: (linkId, body, options) => http.request("POST", `/v1/payment_links/${id(linkId)}`, { body, ...options }),
+            expire: (linkId, options) => http.request("POST", `/v1/payment_links/${id(linkId)}/expire`, options),
+            /** Takes payments again on a link the card-testing check paused (13-03), once you have looked. */
+            unpause: (linkId, options) => http.request("POST", `/v1/payment_links/${id(linkId)}/unpause`, options),
+            ...lister(http, "/v1/payment_links"),
+        },
+        /** What a business sells on repeat. A plan's price never changes: a new price is a new plan. */
+        plans: {
+            create: (body, options) => http.request("POST", "/v1/plans", { body, ...options }),
+            retrieve: (planId, options) => http.request("GET", `/v1/plans/${id(planId)}`, options),
+            /** Renaming and metadata only — the price, interval and trial cannot be changed. */
+            update: (planId, body, options) => http.request("POST", `/v1/plans/${id(planId)}`, { body, ...options }),
+            /** Stops new subscriptions; the ones already on it carry on. */
+            archive: (planId, options) => http.request("POST", `/v1/plans/${id(planId)}/archive`, options),
+            ...lister(http, "/v1/plans"),
+        },
+        /** Discounts on subscriptions: a percentage or an amount off, for some charges or for ever. */
+        coupons: {
+            create: (body, options) => http.request("POST", "/v1/coupons", { body, ...options }),
+            retrieve: (couponId, options) => http.request("GET", `/v1/coupons/${id(couponId)}`, options),
+            /** Stops new redemptions; subscriptions already carrying it keep it. */
+            archive: (couponId, options) => http.request("POST", `/v1/coupons/${id(couponId)}/archive`, options),
+            ...lister(http, "/v1/coupons"),
+        },
+        /** What each subscription charge was for, numbered without gaps. No tax is calculated. */
+        invoices: {
+            retrieve: (invoiceId, options) => http.request("GET", `/v1/invoices/${id(invoiceId)}`, options),
+            ...lister(http, "/v1/invoices"),
+        },
+        /** The customer portal: a one-hour link for one customer, doing only what you allow. */
+        portalSessions: {
+            create: (body, options) => http.request("POST", "/v1/portal_sessions", { body, ...options }),
+        },
+        /** Codes a customer types for a coupon, matched in any case. */
+        promoCodes: {
+            create: (body, options) => http.request("POST", "/v1/promo_codes", { body, ...options }),
+            retrieve: (promoCodeId, options) => http.request("GET", `/v1/promo_codes/${id(promoCodeId)}`, options),
+            deactivate: (promoCodeId, options) => http.request("POST", `/v1/promo_codes/${id(promoCodeId)}/deactivate`, options),
+            ...lister(http, "/v1/promo_codes"),
+        },
+        /** Someone paying for a plan, over and over, on a card they saved. */
+        subscriptions: {
+            /** Charges the first period now, unless the plan has a trial. */
+            create: (body, options) => http.request("POST", "/v1/subscriptions", { body, ...options }),
+            retrieve: (subscriptionId, options) => http.request("GET", `/v1/subscriptions/${id(subscriptionId)}`, options),
+            /**
+             * What moving to another plan would cost — the unused time credited, the remaining time
+             * charged. Pass the `proration_at` it returns back to `change` and the charge is this
+             * number to the penny.
+             */
+            preview: (subscriptionId, body, options) => http.request("POST", `/v1/subscriptions/${id(subscriptionId)}/preview`, {
+                body,
+                ...options,
+            }),
+            /** A dearer plan is charged and takes effect now; a cheaper one waits for the period. */
+            change: (subscriptionId, body, options) => http.request("POST", `/v1/subscriptions/${id(subscriptionId)}/change`, {
+                body,
+                ...options,
+            }),
+            /** Ends it — now, or with `at_period_end: true` when the period they have paid for ends. */
+            cancel: (subscriptionId, body, options) => http.request("POST", `/v1/subscriptions/${id(subscriptionId)}/cancel`, {
+                ...(body ? { body } : {}),
+                ...options,
+            }),
+            /** Nothing is charged until it resumes — on `resumes_at`, or when `resume` is called. */
+            pause: (subscriptionId, body, options) => http.request("POST", `/v1/subscriptions/${id(subscriptionId)}/pause`, {
+                ...(body ? { body } : {}),
+                ...options,
+            }),
+            /** Charged now if the period it had paid for is over; otherwise it simply carries on. */
+            resume: (subscriptionId, options) => http.request("POST", `/v1/subscriptions/${id(subscriptionId)}/resume`, options),
+            /** Takes back a cancellation set for the end of the period, before it lands. */
+            reactivate: (subscriptionId, options) => http.request("POST", `/v1/subscriptions/${id(subscriptionId)}/reactivate`, options),
+            ...lister(http, "/v1/subscriptions"),
+        },
+        payments: {
+            /** Creates the payment; the payer pays at its `approval_url` (or your page, with the JS SDK). */
+            create: (body, options) => http.request("POST", "/v1/payments", { body, ...options }),
+            /** Charges a card the customer saved for off-session use, under its mandate. */
+            chargeSaved: (body, options) => http.request("POST", "/v1/payments/charge_saved", { body, ...options }),
+            retrieve: (paymentId, options) => http.request("GET", `/v1/payments/${id(paymentId)}`, options),
+            /** Presents a card — in test mode, one of Stripe's test cards by name (`pm_card_gb`). */
+            confirm: (paymentId, body, options) => http.request("POST", `/v1/payments/${id(paymentId)}/confirm`, {
+                body,
+                ...options,
+            }),
+            /** Takes a held (`requires_capture`) payment — all of it, or `amount_to_capture`. */
+            capture: (paymentId, body = {}, options) => http.request("POST", `/v1/payments/${id(paymentId)}/capture`, {
+                body,
+                ...options,
+            }),
+            cancel: (paymentId, options) => http.request("POST", `/v1/payments/${id(paymentId)}/cancel`, options),
+            ...lister(http, "/v1/payments"),
+        },
+        refunds: {
+            create: (body, options) => http.request("POST", "/v1/refunds", { body, ...options }),
+            retrieve: (refundId, options) => http.request("GET", `/v1/refunds/${id(refundId)}`, options),
+            ...lister(http, "/v1/refunds"),
+        },
+        customers: {
+            create: (body, options) => http.request("POST", "/v1/customers", { body, ...options }),
+            retrieve: (customerId, options) => http.request("GET", `/v1/customers/${id(customerId)}`, options),
+            update: (customerId, body, options) => http.request("POST", `/v1/customers/${id(customerId)}`, { body, ...options }),
+            ...lister(http, "/v1/customers"),
+            /**
+             * What the customer told your store's quiz they like (91-07), kept only when they ticked
+             * *Remember my answers*: all of it, by attribute. It orders their search, never their prices.
+             */
+            preferences: (customerId, options) => http.request("GET", `/v1/customers/${id(customerId)}/preferences`, options),
+        },
+        balance: {
+            retrieve: (options) => http.request("GET", "/v1/balance", options),
+            /**
+             * Everything that moved the balance, newest first. Filters: `type` (comma-separated),
+             * `payout` (what that payout covered); a platform's Connect balance with `balance: "connect"`.
+             */
+            listTransactions: (params = {}, options) => http.request("GET", "/v1/balance/transactions", {
+                query: params,
+                ...options,
+            }),
+            listAllTransactions: (params = {}, options) => lister(http, "/v1/balance/transactions").listAll(params, options),
+        },
+        payouts: {
+            create: (body, options) => http.request("POST", "/v1/payouts", { body, ...options }),
+            retrieve: (payoutId, options) => http.request("GET", `/v1/payouts/${id(payoutId)}`, options),
+            ...lister(http, "/v1/payouts"),
+            /** What the payout covered, from the books: the balance before, its activity, after. */
+            reconciliation: (payoutId, options) => http.request("GET", `/v1/payouts/${id(payoutId)}/reconciliation`, options),
+            /**
+             * What an instant move would cost (0.99%, taken out of it) and what arrives — at the bank
+             * (the default) or, with `destination: "card_balance"`, on the card balance — and when.
+             * Omit `amount` for the most that could go now. A destination that can't be used still
+             * answers, `available: false`, with the `reason`, `message` and `fix_url`.
+             */
+            instantQuote: (params = {}, options) => http.request("GET", "/v1/payouts/instant/quote", {
+                query: {
+                    ...(params.amount !== undefined ? { amount: String(params.amount) } : {}),
+                    ...(params.destination ? { destination: params.destination } : {}),
+                },
+                ...options,
+            }),
+            /** The schedule, the bank, the limits, and instant access per destination. */
+            settings: (options) => http.request("GET", "/v1/payout_settings", options),
+            /**
+             * Next-day payouts (UK) on or off: 0.2% on each payment from then on, paid out the day after
+             * it's taken. Refused with `next_day_unavailable` (and its `reason`) until
+             * `settings().next_day.available` says so.
+             */
+            setNextDay: (body, options) => http.request("POST", "/v1/payout_settings/next_day", { body, ...options }),
+        },
+        disputes: {
+            retrieve: (disputeId, options) => http.request("GET", `/v1/disputes/${id(disputeId)}`, options),
+            update: (disputeId, body, options) => http.request("POST", `/v1/disputes/${id(disputeId)}`, { body, ...options }),
+            submit: (disputeId, options) => http.request("POST", `/v1/disputes/${id(disputeId)}/submit`, options),
+            ...lister(http, "/v1/disputes"),
+        },
+        events: {
+            retrieve: (eventId, options) => http.request("GET", `/v1/events/${id(eventId)}`, options),
+            ...lister(http, "/v1/events"),
+        },
+        webhookEndpoints: {
+            /** The response carries the endpoint's signing `secret` — once. Store it. */
+            create: (body, options) => http.request("POST", "/v1/webhook_endpoints", {
+                body,
+                ...options,
+            }),
+            retrieve: (endpointId, options) => http.request("GET", `/v1/webhook_endpoints/${id(endpointId)}`, options),
+            update: (endpointId, body, options) => http.request("POST", `/v1/webhook_endpoints/${id(endpointId)}`, {
+                body,
+                ...options,
+            }),
+            del: (endpointId, options) => http.request("DELETE", `/v1/webhook_endpoints/${id(endpointId)}`, options),
+            ...lister(http, "/v1/webhook_endpoints"),
+        },
+        /** The domains your own checkout runs on, so Apple Pay and Google Pay show there (09-13). */
+        paymentMethodDomains: {
+            create: (body, options) => http.request("POST", "/v1/payment_method_domains", {
+                body,
+                ...options,
+            }),
+            retrieve: (domainId, options) => http.request("GET", `/v1/payment_method_domains/${id(domainId)}`, options),
+            /** Asks Stripe to check the domain's wallets again now. */
+            validate: (domainId, options) => http.request("POST", `/v1/payment_method_domains/${id(domainId)}/validate`, options),
+            del: (domainId, options) => http.request("DELETE", `/v1/payment_method_domains/${id(domainId)}`, options),
+            ...lister(http, "/v1/payment_method_domains"),
+        },
+        meters: {
+            create: (body, options) => http.request("POST", "/v1/meters", { body, ...options }),
+            list: (options) => http.request("GET", "/v1/meters", options),
+        },
+        credits: {
+            /** Every customer holding credit, with the totals topped up and used. */
+            ...lister(http, "/v1/credits"),
+            retrieve: (customerId, options) => http.request("GET", `/v1/credits/${id(customerId)}`, options),
+            /** Sells credit: returns the top-up payment to be paid. */
+            topup: (customerId, body, options) => http.request("POST", `/v1/credits/${id(customerId)}/topups`, {
+                body,
+                ...options,
+            }),
+            /** A customer's top-ups, newest first. */
+            listTopups: (customerId, params = {}, options) => http.request("GET", `/v1/credits/${id(customerId)}/topups`, {
+                query: params,
+                ...options,
+            }),
+        },
+        meterEvents: {
+            /**
+             * Records usage and draws the customer's credit down. Naturally idempotent on
+             * `identifier` — the same event twice is one charge, and says `replayed`.
+             */
+            create: (body, options) => http.request("POST", "/v1/meter_events", { body, ...options }),
+            /** Recorded usage, newest first — one `customer`'s, or one `meter`'s (name or id). */
+            ...lister(http, "/v1/meter_events"),
+            /**
+             * Usage per meter and per UTC day, `from`–`to` (YYYY-MM-DD, inclusive; default the last
+             * 30 days) — summed from the events themselves.
+             */
+            summary: (params = {}, options) => http.request("GET", "/v1/meter_events/summary", {
+                query: params,
+                ...options,
+            }),
+        },
+        // ---- Tuppence Events (M114): ticketed events, their ticket types, orders and tickets. ----
+        // `/v1/events` is the webhook event log, so the events themselves live under `ticketing`.
+        ticketing: {
+            /** Events: a draft from a title and `starts_at`, then on sale, off sale or cancelled. */
+            events: {
+                create: (body, options) => http.request("POST", "/v1/ticketing/events", { body, ...options }),
+                retrieve: (eventId, options) => http.request("GET", `/v1/ticketing/events/${id(eventId)}`, options),
+                update: (eventId, body, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}`, {
+                    body,
+                    ...options,
+                }),
+                /** On sale: its page opens and `event.published` is sent. */
+                publish: (eventId, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}/publish`, {
+                    body: {},
+                    ...options,
+                }),
+                /** Off sale, back to a draft. Tickets already sold stay valid. */
+                unpublish: (eventId, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}/unpublish`, {
+                    body: {},
+                    ...options,
+                }),
+                /** For good: every ticket voided, every buyer refunded in full, once. */
+                cancel: (eventId, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}/cancel`, {
+                    body: {},
+                    ...options,
+                }),
+                /** The guest list a door device checks guests in from, with the key to verify codes. */
+                checkInManifest: (eventId, options) => http.request("GET", `/v1/ticketing/events/${id(eventId)}/check_in_manifest`, options),
+                /** Gross, refunds, fees, held and released for one event. */
+                settlement: (eventId, options) => http.request("GET", `/v1/ticketing/events/${id(eventId)}/settlement`, options),
+                /** More dates (118-01): one (`starts_at`), a list (`dates`), or a series (`repeat`). */
+                addDates: (eventId, body, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}/dates`, {
+                    body,
+                    ...options,
+                }),
+                /** Moves one date or changes its capacity; its funds hold's release follows. */
+                updateDate: (eventId, dateId, body, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}/dates/${id(dateId)}`, { body, ...options }),
+                /** Removes a date nobody has ordered for; an event keeps one date at least. */
+                removeDate: (eventId, dateId, options) => http.request("DELETE", `/v1/ticketing/events/${id(eventId)}/dates/${id(dateId)}`, options),
+                /** The door, live: tickets in by gate and by type (116-07). */
+                checkInCounts: (eventId, options) => http.request("GET", `/v1/ticketing/events/${id(eventId)}/check_in_counts`, options),
+                ...lister(http, "/v1/ticketing/events"),
+            },
+            /** Events a door can check guests in for, soonest first (116-05). */
+            checkInEvents: {
+                list: (options) => http.request("GET", "/v1/ticketing/check_in_events", options),
+            },
+            /** Messages to an event's attendees by email, text or WhatsApp, now or scheduled (118-04). */
+            messages: {
+                create: (eventId, body, options) => http.request("POST", `/v1/ticketing/events/${id(eventId)}/messages`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (messageId, options) => http.request("GET", `/v1/ticketing/messages/${id(messageId)}`, options),
+                /** A scheduled message that has not gone yet. */
+                cancel: (messageId, options) => http.request("POST", `/v1/ticketing/messages/${id(messageId)}/cancel`, {
+                    body: {},
+                    ...options,
+                }),
+                ...childLister(http, (eventId) => `/v1/ticketing/events/${id(eventId)}/messages`),
+            },
+            /** Places on sold-out ticket types' waitlists, in turn (117-07). */
+            waitlist: lister(http, "/v1/ticketing/waitlist"),
+            /** Partners' commissions on orders made with affiliate codes (118-03). */
+            commissions: lister(http, "/v1/ticketing/commissions"),
+            /** The account's settings for every event: its ad pixels (118-06). */
+            settings: {
+                retrieve: (options) => http.request("GET", "/v1/ticketing/settings", options),
+                update: (body, options) => http.request("POST", "/v1/ticketing/settings", { body, ...options }),
+            },
+            /** Promo and access codes, typed by the buyer at checkout (114-07). */
+            promoCodes: {
+                create: (body, options) => http.request("POST", "/v1/ticketing/promo_codes", { body, ...options }),
+                retrieve: (codeId, options) => http.request("GET", `/v1/ticketing/promo_codes/${id(codeId)}`, options),
+                update: (codeId, body, options) => http.request("POST", `/v1/ticketing/promo_codes/${id(codeId)}`, {
+                    body,
+                    ...options,
+                }),
+                del: (codeId, options) => http.request("DELETE", `/v1/ticketing/promo_codes/${id(codeId)}`, options),
+                ...lister(http, "/v1/ticketing/promo_codes"),
+            },
+            /** Scans at the door: a `code`, a `short_code` or a `ticket`; the first scan admits. */
+            checkIns: {
+                create: (body, options) => http.request("POST", "/v1/ticketing/check_ins", { body, ...options }),
+                /** A device's offline scans, applied in the order they were made. */
+                sync: (body, options) => http.request("POST", "/v1/ticketing/check_ins/sync", { body, ...options }),
+                /** Newest first; `event` or `ticket` for one's. A refused scan has no id, so no `listAll`. */
+                list: (params = {}, options) => http.request("GET", "/v1/ticketing/check_ins", {
+                    query: params,
+                    ...options,
+                }),
+            },
+            /** Ticket money held until after each date, and when it is released (114-05). */
+            fundsHolds: lister(http, "/v1/ticketing/funds_holds"),
+            reports: {
+                /** Sales by event, ticket type and source; `from` and `to` are `YYYY-MM-DD`. */
+                sales: (params = {}, options) => http.request("GET", "/v1/ticketing/reports/sales", {
+                    query: params,
+                    ...options,
+                }),
+            },
+        },
+        /** What an event sells: free or paid, with up to five price phases before the base price. */
+        ticketTypes: {
+            create: (body, options) => http.request("POST", "/v1/ticket_types", { body, ...options }),
+            retrieve: (typeId, options) => http.request("GET", `/v1/ticket_types/${id(typeId)}`, options),
+            update: (typeId, body, options) => http.request("POST", `/v1/ticket_types/${id(typeId)}`, { body, ...options }),
+            /** Off sale for good; tickets already sold stay valid. */
+            archive: (typeId, options) => http.request("DELETE", `/v1/ticket_types/${id(typeId)}`, options),
+            ...lister(http, "/v1/ticket_types"),
+        },
+        /** Buyers' orders, placed on the event page; a key reads and refunds them. */
+        ticketOrders: {
+            retrieve: (orderId, options) => http.request("GET", `/v1/ticket_orders/${id(orderId)}`, options),
+            /** In full, or `tickets` by id: they are voided and their seats go back on sale. */
+            refund: (orderId, body = {}, options) => http.request("POST", `/v1/ticket_orders/${id(orderId)}/refund`, {
+                body,
+                ...options,
+            }),
+            /** An approval-only event's request (118-02): approve it, and the buyer is asked to pay. */
+            approve: (orderId, options) => http.request("POST", `/v1/ticket_orders/${id(orderId)}/approve`, {
+                body: {},
+                ...options,
+            }),
+            /** Decline a request; its seats go back on sale. */
+            decline: (orderId, options) => http.request("POST", `/v1/ticket_orders/${id(orderId)}/decline`, {
+                body: {},
+                ...options,
+            }),
+            ...lister(http, "/v1/ticket_orders"),
+        },
+        /** One admission each: its holder, status and short code. */
+        tickets: {
+            retrieve: (ticketId, options) => http.request("GET", `/v1/tickets/${id(ticketId)}`, options),
+            /** Give it to someone else (117-06): it is voided and a new ticket issued to them. */
+            transfer: (ticketId, body, options) => http.request("POST", `/v1/tickets/${id(ticketId)}/transfer`, {
+                body,
+                ...options,
+            }),
+            /** Back to a sold-out type's waitlist to sell at face value (117-08). */
+            return: (ticketId, options) => http.request("POST", `/v1/tickets/${id(ticketId)}/return`, {
+                body: {},
+                ...options,
+            }),
+            ...lister(http, "/v1/tickets"),
+        },
+        // ---- Bookings (M23) ----
+        /** Where services happen (23-03). Every account has one from the first look. */
+        locations: {
+            create: (body, options) => http.request("POST", "/v1/locations", { body, ...options }),
+            retrieve: (locationId, options) => http.request("GET", `/v1/locations/${id(locationId)}`, options),
+            update: (locationId, body, options) => http.request("POST", `/v1/locations/${id(locationId)}`, { body, ...options }),
+            archive: (locationId, options) => http.request("POST", `/v1/locations/${id(locationId)}/archive`, options),
+            /** Does a mobile location cover a client — by `postcode`, or `lat` and `lng`? */
+            coverage: (locationId, params, options) => http.request("GET", `/v1/locations/${id(locationId)}/coverage`, {
+                query: params,
+                ...options,
+            }),
+            ...lister(http, "/v1/locations"),
+        },
+        /**
+         * The country packs (31-19): a country's tax components and classes, location tax defaults,
+         * receipt rules, rounding and conventions, as data. Reference data — the same for every account,
+         * readable with any key.
+         */
+        countryPacks: {
+            /** A country's pack (`GB`, `CA`, `US`…) — or a province's or state's with `region` (`QC`, `TX`). */
+            retrieve: (country, params = {}, options) => http.request("GET", `/v1/country_packs/${id(country)}`, {
+                query: params,
+                ...options,
+            }),
+        },
+        /** Headings services are grouped under (23-04). */
+        serviceCategories: {
+            create: (body, options) => http.request("POST", "/v1/service_categories", { body, ...options }),
+            retrieve: (categoryId, options) => http.request("GET", `/v1/service_categories/${id(categoryId)}`, options),
+            update: (categoryId, body, options) => http.request("POST", `/v1/service_categories/${id(categoryId)}`, {
+                body,
+                ...options,
+            }),
+            archive: (categoryId, options) => http.request("POST", `/v1/service_categories/${id(categoryId)}/archive`, options),
+            ...lister(http, "/v1/service_categories"),
+        },
+        /** What a business offers (23-04): duration, price, options, add-ons, what it needs, who does it. */
+        services: {
+            create: (body, options) => http.request("POST", "/v1/services", { body, ...options }),
+            retrieve: (serviceId, options) => http.request("GET", `/v1/services/${id(serviceId)}`, options),
+            update: (serviceId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}`, { body, ...options }),
+            archive: (serviceId, options) => http.request("POST", `/v1/services/${id(serviceId)}/archive`, options),
+            createVariant: (serviceId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/variants`, {
+                body,
+                ...options,
+            }),
+            updateVariant: (serviceId, variantId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/variants/${id(variantId)}`, { body, ...options }),
+            createAddon: (serviceId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/addons`, {
+                body,
+                ...options,
+            }),
+            updateAddon: (serviceId, addonId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/addons/${id(addonId)}`, {
+                body,
+                ...options,
+            }),
+            /** The whole list of what it needs — `[{kind, count}]`; what is not here is no longer needed. */
+            setResources: (serviceId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/resources`, {
+                body,
+                ...options,
+            }),
+            /** The whole list of who performs it; empty means everyone active does. */
+            setStaff: (serviceId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/staff`, {
+                body,
+                ...options,
+            }),
+            setImage: (serviceId, body, options) => http.request("POST", `/v1/services/${id(serviceId)}/image`, {
+                body,
+                ...options,
+            }),
+            removeImage: (serviceId, options) => http.request("DELETE", `/v1/services/${id(serviceId)}/image`, options),
+            /** What it would take and cost as chosen — an option, add-ons, a person, a group. */
+            quote: (serviceId, body = {}, options) => http.request("POST", `/v1/services/${id(serviceId)}/quote`, {
+                body,
+                ...options,
+            }),
+            ...lister(http, "/v1/services"),
+        },
+        /** The people who perform services (23-05), and their hours. */
+        staff: {
+            create: (body, options) => http.request("POST", "/v1/staff", { body, ...options }),
+            retrieve: (staffId, options) => http.request("GET", `/v1/staff/${id(staffId)}`, options),
+            update: (staffId, body, options) => http.request("POST", `/v1/staff/${id(staffId)}`, { body, ...options }),
+            archive: (staffId, options) => http.request("POST", `/v1/staff/${id(staffId)}/archive`, options),
+            setLocations: (staffId, body, options) => http.request("POST", `/v1/staff/${id(staffId)}/locations`, {
+                body,
+                ...options,
+            }),
+            setServices: (staffId, body, options) => http.request("POST", `/v1/staff/${id(staffId)}/services`, {
+                body,
+                ...options,
+            }),
+            setImage: (staffId, body, options) => http.request("POST", `/v1/staff/${id(staffId)}/image`, { body, ...options }),
+            removeImage: (staffId, options) => http.request("DELETE", `/v1/staff/${id(staffId)}/image`, options),
+            /** Hours: a weekly pattern or a two-week rotation at a location, from a date. */
+            createSchedule: (staffId, body, options) => http.request("POST", `/v1/staff/${id(staffId)}/schedules`, {
+                body,
+                ...options,
+            }),
+            updateSchedule: (staffId, scheduleId, body, options) => http.request("POST", `/v1/staff/${id(staffId)}/schedules/${id(scheduleId)}`, {
+                body,
+                ...options,
+            }),
+            listSchedules: (staffId, options) => http.request("GET", `/v1/staff/${id(staffId)}/schedules`, options),
+            /** When they actually work between two dates: hours, less time off, plus extra hours. */
+            workingHours: (staffId, params, options) => http.request("GET", `/v1/staff/${id(staffId)}/working_hours`, {
+                query: params,
+                ...options,
+            }),
+            ...lister(http, "/v1/staff"),
+        },
+        /** Time off, breaks, blocked time and extra hours (23-05). */
+        scheduleExceptions: {
+            create: (body, options) => http.request("POST", "/v1/schedule_exceptions", { body, ...options }),
+            retrieve: (exceptionId, options) => http.request("GET", `/v1/schedule_exceptions/${id(exceptionId)}`, options),
+            del: (exceptionId, options) => http.request("DELETE", `/v1/schedule_exceptions/${id(exceptionId)}`, options),
+            ...lister(http, "/v1/schedule_exceptions"),
+        },
+        /** Rooms, chairs, baths — what a service needs besides a person (23-06). */
+        resources: {
+            create: (body, options) => http.request("POST", "/v1/resources", { body, ...options }),
+            retrieve: (resourceId, options) => http.request("GET", `/v1/resources/${id(resourceId)}`, options),
+            update: (resourceId, body, options) => http.request("POST", `/v1/resources/${id(resourceId)}`, { body, ...options }),
+            archive: (resourceId, options) => http.request("POST", `/v1/resources/${id(resourceId)}/archive`, options),
+            /** Could these requirements be met at a location — and if not, what is short? */
+            check: (body, options) => http.request("POST", "/v1/resources/check", { body, ...options }),
+            ...lister(http, "/v1/resources"),
+        },
+        /** The account's booking policy (23-07): deposits, cancellation, notice, approval, holds. */
+        bookingPolicy: {
+            retrieve: (options) => http.request("GET", "/v1/booking_policy", options),
+            /** Every change is a new version; bookings keep the one their client accepted. */
+            update: (body, options) => http.request("POST", "/v1/booking_policy", { body, ...options }),
+            listVersions: (params = {}, options) => http.request("GET", "/v1/booking_policy/versions", {
+                query: params,
+                ...options,
+            }),
+            /** The policy's words as a client sees them — for a service, an amount, or a draft. */
+            render: (body = {}, options) => http.request("POST", "/v1/booking_policy/render", { body, ...options }),
+        },
+        /** The business's public booking page (24-01): its address, look, content, flow — and whether it is published. */
+        bookingPage: {
+            retrieve: (options) => http.request("GET", "/v1/booking_page", options),
+            /** Each of `theme`, `content`, `flow` and `seo` is a patch; a new `slug` keeps the old one redirecting for 90 days. */
+            update: (body, options) => http.request("POST", "/v1/booking_page", { body, ...options }),
+            publish: (options) => http.request("POST", "/v1/booking_page/publish", { body: {}, ...options }),
+            unpublish: (options) => http.request("POST", "/v1/booking_page/unpublish", { body: {}, ...options }),
+            /** Shown once; minting another retires the last. */
+            createPreviewToken: (options) => http.request("POST", "/v1/booking_page/preview_token", {
+                body: {},
+                ...options,
+            }),
+            /** A picture (base64 PNG or JPEG), re-encoded and shown last; at most 20. */
+            addGalleryImage: (body, options) => http.request("POST", "/v1/booking_page/gallery", { body, ...options }),
+            setCover: (body, options) => http.request("POST", "/v1/booking_page/cover", { body, ...options }),
+        },
+        /** When a client could book (23-10). */
+        availability: {
+            /**
+             * The starts between `from` and `to` (`YYYY-MM-DD`, up to 62 days) for a `service` (with
+             * `variant` and `addons`) or `items` (`svc_…` or `svc_…:svar_…`, a visit of several), at a
+             * `location`, with a `staff_member` or anyone.
+             */
+            query: (params, options) => {
+                const { addons, items, ...rest } = params;
+                return http.request("GET", "/v1/availability", {
+                    query: {
+                        ...rest,
+                        ...(addons ? { addons: addons.join(",") } : {}),
+                        ...(items ? { items: items.join(",") } : {}),
+                    },
+                    ...options,
+                });
+            },
+            /** The first start a client could book, on or after `from` (today by default). */
+            next: (params, options) => {
+                const { addons, items, ...rest } = params;
+                return http.request("GET", "/v1/availability/next", {
+                    query: {
+                        ...rest,
+                        ...(addons ? { addons: addons.join(",") } : {}),
+                        ...(items ? { items: items.join(",") } : {}),
+                    },
+                    ...options,
+                });
+            },
+        },
+        /** Bookings (23-11, 23-12): made from what availability offered, then their whole life. */
+        bookings: {
+            /** Needs an idempotency key — the SDK always sends one. `409 slot_unavailable` names other starts. */
+            create: (body, options) => http.request("POST", "/v1/bookings", { body, ...options }),
+            retrieve: (bookingId, options) => http.request("GET", `/v1/bookings/${id(bookingId)}`, options),
+            /** Notes and metadata. When, and with whom, is `reschedule`. */
+            update: (bookingId, body, options) => http.request("POST", `/v1/bookings/${id(bookingId)}`, { body, ...options }),
+            /** Takes the slot for the policy's `hold_minutes` with no client yet; confirm it to book. */
+            hold: (body, options) => http.request("POST", "/v1/bookings/holds", { body, ...options }),
+            extendHold: (bookingId, options) => http.request("POST", `/v1/bookings/holds/${id(bookingId)}/extend`, options),
+            releaseHold: (bookingId, options) => http.request("POST", `/v1/bookings/holds/${id(bookingId)}/release`, options),
+            confirm: (bookingId, body = {}, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/confirm`, {
+                body,
+                ...options,
+            }),
+            reschedule: (bookingId, body, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/reschedule`, {
+                body,
+                ...options,
+            }),
+            /** `by: "client"` applies the policy's outcome; the business owes nothing and returns everything. */
+            cancel: (bookingId, body = {}, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/cancel`, {
+                body,
+                ...options,
+            }),
+            checkIn: (bookingId, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/check_in`, options),
+            start: (bookingId, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/start`, options),
+            complete: (bookingId, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/complete`, options),
+            noShow: (bookingId, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/no_show`, options),
+            approve: (bookingId, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/approve`, options),
+            decline: (bookingId, body = {}, options) => http.request("POST", `/v1/bookings/${id(bookingId)}/decline`, {
+                body,
+                ...options,
+            }),
+            ...lister(http, "/v1/bookings"),
+        },
+        /** A class's sessions (23-13): scheduled, with seats. */
+        classSessions: {
+            create: (body, options) => http.request("POST", "/v1/class_sessions", { body, ...options }),
+            retrieve: (sessionId, options) => http.request("GET", `/v1/class_sessions/${id(sessionId)}`, options),
+            update: (sessionId, body, options) => http.request("POST", `/v1/class_sessions/${id(sessionId)}`, {
+                body,
+                ...options,
+            }),
+            cancel: (sessionId, body = {}, options) => http.request("POST", `/v1/class_sessions/${id(sessionId)}/cancel`, {
+                body,
+                ...options,
+            }),
+            ...lister(http, "/v1/class_sessions"),
+        },
+        /** "Every Monday at 10:00 with Ana" (23-14): a rule, kept as bookings eight weeks ahead. */
+        bookingSeries: {
+            create: (body, options) => http.request("POST", "/v1/booking_series", { body, ...options }),
+            retrieve: (seriesId, options) => http.request("GET", `/v1/booking_series/${id(seriesId)}`, options),
+            /** "This and following": a new time or person from a date. */
+            update: (seriesId, body, options) => http.request("POST", `/v1/booking_series/${id(seriesId)}`, {
+                body,
+                ...options,
+            }),
+            skip: (seriesId, body, options) => http.request("POST", `/v1/booking_series/${id(seriesId)}/skip`, {
+                body,
+                ...options,
+            }),
+            end: (seriesId, body = {}, options) => http.request("POST", `/v1/booking_series/${id(seriesId)}/end`, {
+                body,
+                ...options,
+            }),
+            ...lister(http, "/v1/booking_series"),
+        },
+        /** Wishes for a slot that is not there yet (23-15), offered the moment one frees up. */
+        waitlist: {
+            create: (body, options) => http.request("POST", "/v1/waitlist", { body, ...options }),
+            retrieve: (entryId, options) => http.request("GET", `/v1/waitlist/${id(entryId)}`, options),
+            update: (entryId, body, options) => http.request("POST", `/v1/waitlist/${id(entryId)}`, { body, ...options }),
+            cancel: (entryId, options) => http.request("POST", `/v1/waitlist/${id(entryId)}/cancel`, options),
+            /** Takes up the open offer: the held slot becomes the client's booking. */
+            accept: (entryId, options) => http.request("POST", `/v1/waitlist/${id(entryId)}/accept`, options),
+            ...lister(http, "/v1/waitlist"),
+        },
+        // ---- The store (94-02): every store operation has a method here and in Python, which
+        // `scripts/check-sdk-coverage.mjs` holds to as each store resource ships. ----
+        /** Customers' reviews (M91): read them, reply, hide one, publish one. */
+        reviews: {
+            retrieve: (reviewId, options) => http.request("GET", `/v1/reviews/${id(reviewId)}`, options),
+            /** The average and the count, as the store shows them. */
+            summary: (options) => http.request("GET", "/v1/reviews/summary", options),
+            reply: (reviewId, body, options) => http.request("POST", `/v1/reviews/${id(reviewId)}/reply`, { body, ...options }),
+            hide: (reviewId, options) => http.request("POST", `/v1/reviews/${id(reviewId)}/hide`, { body: {}, ...options }),
+            publish: (reviewId, options) => http.request("POST", `/v1/reviews/${id(reviewId)}/publish`, {
+                body: {},
+                ...options,
+            }),
+            ...lister(http, "/v1/reviews"),
+        },
+        /** What changed in the store and who changed it, each with its undo (92-01). */
+        changeSets: {
+            retrieve: (changeSetId, options) => http.request("GET", `/v1/change_sets/${id(changeSetId)}`, options),
+            /** Undoes the change, if nothing since depends on it. */
+            revert: (changeSetId, options) => http.request("POST", `/v1/change_sets/${id(changeSetId)}/revert`, {
+                body: {},
+                ...options,
+            }),
+            ...lister(http, "/v1/change_sets"),
+        },
+        /** Moving a store from another platform (93-01): files, a preview, then the run. */
+        storeImports: {
+            create: (body, options) => http.request("POST", "/v1/store_imports", { body, ...options }),
+            retrieve: (importId, options) => http.request("GET", `/v1/store_imports/${id(importId)}`, options),
+            /**
+             * What a completed import's last 12 months of orders would have cost on Tuppence, beside the
+             * plan you paid: a confirmed `plan`, or your own `monthly_fee`, `card_bps` and `card_fixed`.
+             */
+            savings: (importId, params = {}, options) => http.request("GET", `/v1/store_imports/${id(importId)}/savings`, {
+                query: Object.fromEntries(Object.entries(params)
+                    .filter(([, v]) => v !== undefined)
+                    .map(([k, v]) => [k, String(v)])),
+                ...options,
+            }),
+            update: (importId, body, options) => http.request("POST", `/v1/store_imports/${id(importId)}`, {
+                body,
+                ...options,
+            }),
+            /** An export file, in parts of up to 800,000 characters. */
+            addFile: (importId, body, options) => http.request("POST", `/v1/store_imports/${id(importId)}/files`, {
+                body,
+                ...options,
+            }),
+            /** What would come across, writing nothing. */
+            preview: (importId, options) => http.request("POST", `/v1/store_imports/${id(importId)}/preview`, {
+                body: {},
+                ...options,
+            }),
+            run: (importId, options) => http.request("POST", `/v1/store_imports/${id(importId)}/run`, {
+                body: {},
+                ...options,
+            }),
+            /** The stock mirror that keeps the old store and this one level while you move (live mode). */
+            retrieveStockMirror: (importId, options) => http.request("GET", `/v1/store_imports/${id(importId)}/stock_mirror`, options),
+            /** Turn the stock mirror on (with `credentials` after it was off) or off. */
+            setStockMirror: (importId, body, options) => http.request("POST", `/v1/store_imports/${id(importId)}/stock_mirror`, {
+                body,
+                ...options,
+            }),
+            ...lister(http, "/v1/store_imports"),
+        },
+        /** The store's operator jobs (M92): what each does, its runs, briefs and examples. */
+        assistantJobs: {
+            list: (options) => http.request("GET", "/v1/assistant_jobs", options),
+            retrieve: (jobId, options) => http.request("GET", `/v1/assistant_jobs/${id(jobId)}`, options),
+            runs: childLister(http, (jobId) => `/v1/assistant_jobs/${id(jobId)}/runs`),
+            listBriefs: (jobId, options) => http.request("GET", `/v1/assistant_jobs/${id(jobId)}/briefs`, options),
+            listExamples: (jobId, options) => http.request("GET", `/v1/assistant_jobs/${id(jobId)}/examples`, options),
+        },
+        /**
+         * Sales per channel (90-17): orders, units, gross, discounts, refunds, the channel's own
+         * fees (estimated and final apart, never Tuppence's) and net; `from`/`to` are business days.
+         */
+        channelReports: {
+            retrieve: (params = {}, options) => http.request("GET", "/v1/reports/channels", {
+                query: params,
+                ...options,
+            }),
+        },
+        /** The store's daily briefs (M92). */
+        storeBriefs: {
+            retrieve: (briefId, options) => http.request("GET", `/v1/store_briefs/${id(briefId)}`, options),
+            ...lister(http, "/v1/store_briefs"),
+        },
+        /**
+         * The business's one store site (85-02): settings, domains, fonts, pages, publishing and
+         * its versions. `list` answers the one site, so `data[0].id` is the site to work on.
+         */
+        sites: {
+            list: (options) => http.request("GET", "/v1/sites", options),
+            retrieve: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}`, options),
+            update: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}`, { body, ...options }),
+            /** Takes checkouts again after the store paused them. */
+            resumeCheckouts: (siteId, options) => http.request("POST", `/v1/sites/${id(siteId)}/resume_checkouts`, {
+                body: {},
+                ...options,
+            }),
+            /** A new free address; the old one redirects to it. */
+            changeSlug: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/slug`, { body, ...options }),
+            /** Publishes the draft as a new version, live at once. */
+            publish: (siteId, body = {}, options) => http.request("POST", `/v1/sites/${id(siteId)}/publish`, { body, ...options }),
+            /** Publishes the draft at `at` (Unix seconds). */
+            schedule: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/schedule`, {
+                body,
+                ...options,
+            }),
+            cancelSchedule: (siteId, options) => http.request("DELETE", `/v1/sites/${id(siteId)}/schedule`, options),
+            /** A short-lived link to the draft, for someone without a dashboard login. */
+            createPreviewToken: (siteId, options) => http.request("POST", `/v1/sites/${id(siteId)}/preview_token`, {
+                body: {},
+                ...options,
+            }),
+            /** What a page would render with: the site's data for blocks you send, saving nothing. */
+            renderContext: (siteId, body = {}, options) => http.request("POST", `/v1/sites/${id(siteId)}/render_context`, {
+                body,
+                ...options,
+            }),
+            /** What stands between the store and taking orders, each with its fix. */
+            readiness: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/readiness`, options),
+            sellingAbroad: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/selling_abroad`, options),
+            checklist: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/checklist`, options),
+            retrieveReturnPolicy: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/return_policy`, options),
+            updateReturnPolicy: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/return_policy`, {
+                body,
+                ...options,
+            }),
+            /** Your own domains: add one, check its DNS records, remove it. */
+            domains: {
+                list: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/domains`, options),
+                add: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/domains`, {
+                    body,
+                    ...options,
+                }),
+                check: (siteId, hostname, options) => http.request("POST", `/v1/sites/${id(siteId)}/domains/${id(hostname)}/check`, { body: {}, ...options }),
+                remove: (siteId, hostname, options) => http.request("DELETE", `/v1/sites/${id(siteId)}/domains/${id(hostname)}`, options),
+            },
+            /** Moving the old store's domain here, the certificate first and the email records kept (live mode). */
+            domainSwitch: {
+                retrieve: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/domain_switch`, options),
+                start: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/domain_switch`, {
+                    body,
+                    ...options,
+                }),
+                check: (siteId, options) => http.request("POST", `/v1/sites/${id(siteId)}/domain_switch/check`, {
+                    body: {},
+                    ...options,
+                }),
+                switch: (siteId, options) => http.request("POST", `/v1/sites/${id(siteId)}/domain_switch/switch`, {
+                    body: {},
+                    ...options,
+                }),
+                rollBack: (siteId, options) => http.request("POST", `/v1/sites/${id(siteId)}/domain_switch/roll_back`, {
+                    body: {},
+                    ...options,
+                }),
+            },
+            /** The site's fonts: a Google font by name, or your own file with its licence confirmed. */
+            fonts: {
+                list: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/fonts`, options),
+                add: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/fonts`, { body, ...options }),
+                remove: (siteId, family, options) => http.request("DELETE", `/v1/sites/${id(siteId)}/fonts/${id(family)}`, options),
+            },
+            /** The draft's pages; a change shows on the store once the site is published. */
+            pages: {
+                list: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/pages`, options),
+                create: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/pages`, { body, ...options }),
+                retrieve: (siteId, pageId, options) => http.request("GET", `/v1/sites/${id(siteId)}/pages/${id(pageId)}`, options),
+                update: (siteId, pageId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/pages/${id(pageId)}`, {
+                    body,
+                    ...options,
+                }),
+                /** Archives the page; the home page cannot be archived. */
+                archive: (siteId, pageId, options) => http.request("DELETE", `/v1/sites/${id(siteId)}/pages/${id(pageId)}`, options),
+            },
+            /** Every published version; reverting makes an old one the draft and publishes it. */
+            versions: {
+                list: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/versions`, options),
+                retrieve: (siteId, versionId, options) => http.request("GET", `/v1/sites/${id(siteId)}/versions/${id(versionId)}`, options),
+                revert: (siteId, versionId, options) => http.request("POST", `/v1/sites/${id(siteId)}/versions/${id(versionId)}/revert`, { body: {}, ...options }),
+            },
+            /** The design file: export the look, sections and layouts; import one into the draft. */
+            exportDesign: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/design`, options),
+            importDesign: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/design/import`, {
+                body,
+                ...options,
+            }),
+            /** Runs a section's source through the checks, saving nothing. */
+            checkSection: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/section_checks`, {
+                body,
+                ...options,
+            }),
+            retrieveSectionVersion: (siteId, versionId, options) => http.request("GET", `/v1/sites/${id(siteId)}/section_versions/${id(versionId)}`, options),
+            /** Paths shoppers asked for three or more times in a day that had no page, with suggestions. */
+            listNotFound: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/not_found`, options),
+            /** The site's translations in one of the business's languages (91-15): draft, approved or stale. */
+            listTranslations: (siteId, params = {}, options) => http.request("GET", `/v1/sites/${id(siteId)}/translations`, {
+                query: params,
+                ...options,
+            }),
+            /** Drafts the site's products in a language, in the brand voice; a person approves them. */
+            draftTranslations: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/translations/draft`, {
+                body,
+                ...options,
+            }),
+            /** The site's redirects (93-06), newest first, each with how often it was answered. */
+            listRedirects: (siteId, params = {}, options) => http.request("GET", `/v1/sites/${id(siteId)}/redirects`, {
+                query: params,
+                ...options,
+            }),
+            /** Redirect an old path (301): a chain is flattened to one hop, a loop is refused. */
+            createRedirect: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/redirects`, {
+                body,
+                ...options,
+            }),
+            /** Remove a redirect: the old path answers 404 again. */
+            deleteRedirect: (siteId, redirectId, options) => http.request("DELETE", `/v1/sites/${id(siteId)}/redirects/${id(redirectId)}`, options),
+            /** The design agent: a change to how the store looks, proposed for a person to approve. */
+            designRuns: {
+                create: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/design_runs`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (siteId, runId, options) => http.request("GET", `/v1/sites/${id(siteId)}/design_runs/${id(runId)}`, options),
+            },
+            /** The site's custom sections, each through the same checks as the agent's. */
+            sections: {
+                list: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/sections`, options),
+                create: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/sections`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (siteId, sectionId, options) => http.request("GET", `/v1/sites/${id(siteId)}/sections/${id(sectionId)}`, options),
+                rename: (siteId, sectionId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/sections/${id(sectionId)}`, {
+                    body,
+                    ...options,
+                }),
+                /** Takes it off every draft page; the live site keeps it until the next publish. */
+                del: (siteId, sectionId, options) => http.request("DELETE", `/v1/sites/${id(siteId)}/sections/${id(sectionId)}`, options),
+                duplicate: (siteId, sectionId, options) => http.request("POST", `/v1/sites/${id(siteId)}/sections/${id(sectionId)}/duplicate`, { body: {}, ...options }),
+                /** An earlier version's source becomes the next version. */
+                restore: (siteId, sectionId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/sections/${id(sectionId)}/restore`, { body, ...options }),
+                /** The next version from source edited by hand; it becomes the current one. */
+                edit: (siteId, sectionId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/sections/${id(sectionId)}/versions`, { body, ...options }),
+            },
+            /** Code sections, only with them switched on for the site (S25). */
+            codeSections: {
+                list: (siteId, options) => http.request("GET", `/v1/sites/${id(siteId)}/code_sections`, options),
+                create: (siteId, body, options) => http.request("POST", `/v1/sites/${id(siteId)}/code_sections`, {
+                    body,
+                    ...options,
+                }),
+                retrieve: (siteId, codeId, options) => http.request("GET", `/v1/sites/${id(siteId)}/code_sections/${id(codeId)}`, options),
+            },
+        },
+        /**
+         * The store builder and its helpers (M86): a change from a sentence, the builder's proposals,
+         * a product from a photo, and the store's settings. A proposal or a snap also streams its
+         * progress as Server-Sent Events for a browser; from a server, `retrieve` answers the same.
+         */
+        store: {
+            /** A change from a sentence, proposed as a change set; nothing changes until approved. */
+            proposeChange: (body, options) => http.request("POST", "/v1/store/changes", { body, ...options }),
+            retrieveSettings: (options) => http.request("GET", "/v1/store/settings", options),
+            /** `po_limit`: the most a restock drafts on its own; `null` restores the default. */
+            updateSettings: (body, options) => http.request("POST", "/v1/store/settings", { body, ...options }),
+            proposals: {
+                /** Newest first, without items; `{ status: "open" }` answers the one still open. */
+                list: (params = {}, options) => http.request("GET", "/v1/store/proposals", {
+                    query: params,
+                    ...options,
+                }),
+                /** Starts the builder from any mix of a sentence, the till, a website, socials and files. */
+                create: (body = {}, options) => http.request("POST", "/v1/store/proposals", { body, ...options }),
+                /** The proposal with a page of its items (`group`, `limit` up to 200, `starting_after`). */
+                retrieve: (proposalId, params = {}, options) => http.request("GET", `/v1/store/proposals/${id(proposalId)}`, {
+                    query: params,
+                    ...options,
+                }),
+                /** Discards it; nothing it proposed is kept. */
+                discard: (proposalId, options) => http.request("DELETE", `/v1/store/proposals/${id(proposalId)}`, options),
+                /** `accept`, `reject` or `edit` (with `payload`) one item. */
+                decideItem: (proposalId, itemId, body, options) => http.request("POST", `/v1/store/proposals/${id(proposalId)}/items/${id(itemId)}`, { body, ...options }),
+                /** Redoes one item on your words, at most 3 times an item. */
+                redoItem: (proposalId, itemId, body, options) => http.request("POST", `/v1/store/proposals/${id(proposalId)}/items/${id(itemId)}/redo`, { body, ...options }),
+                /** A link to the store as the proposal would make it, never written or cached. */
+                preview: (proposalId, options) => http.request("POST", `/v1/store/proposals/${id(proposalId)}/preview`, {
+                    body: {},
+                    ...options,
+                }),
+                acceptAll: (proposalId, options) => http.request("POST", `/v1/store/proposals/${id(proposalId)}/accept_all`, { body: {}, ...options }),
+                /** Applies every accepted item with no guess left. */
+                publish: (proposalId, body = {}, options) => http.request("POST", `/v1/store/proposals/${id(proposalId)}/publish`, {
+                    body,
+                    ...options,
+                }),
+            },
+            /** A product from 1 to 5 photos: a draft to price, count and publish. */
+            snaps: {
+                create: (body, options) => http.request("POST", "/v1/store/snaps", { body, ...options }),
+                retrieve: (snapId, options) => http.request("GET", `/v1/store/snaps/${id(snapId)}`, options),
+                /** Prices a ready snap's draft, counts its stock in and puts it on its channels. */
+                publish: (snapId, body, options) => http.request("POST", `/v1/store/snaps/${id(snapId)}/publish`, {
+                    body,
+                    ...options,
+                }),
+                /** A studio or lifestyle shot of the main photo, added to the draft. */
+                addPhoto: (snapId, body, options) => http.request("POST", `/v1/store/snaps/${id(snapId)}/photos`, {
+                    body,
+                    ...options,
+                }),
+            },
+        },
+        /**
+         * Fulfilment (M87): the pick list, packing, labels from the balance or your own carrier
+         * account, shipping, local delivery and collection.
+         */
+        fulfilments: {
+            /** The pick list: what is still to leave, oldest promise first. */
+            ...lister(http, "/v1/fulfilments"),
+            retrieve: (fulfilmentId, options) => http.request("GET", `/v1/fulfilments/${id(fulfilmentId)}`, options),
+            /** Packs it by scans, with the package and weight. */
+            pack: (fulfilmentId, body, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/pack`, {
+                body,
+                ...options,
+            }),
+            /** The packing slip: where it goes and what is in the box, no prices. */
+            packingSlip: (fulfilmentId, options) => http.request("GET", `/v1/fulfilments/${id(fulfilmentId)}/packing_slip`, options),
+            /** What a label costs for the packed parcel, by service. */
+            rates: (fulfilmentId, options) => http.request("GET", `/v1/fulfilments/${id(fulfilmentId)}/rates`, options),
+            /** Buys a label; `confirm_amount` must equal the quoted price. */
+            buyLabel: (fulfilmentId, body, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/label`, {
+                body,
+                ...options,
+            }),
+            voidLabel: (fulfilmentId, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/label/void`, {
+                body: {},
+                ...options,
+            }),
+            /** Labels for many packed parcels at once. */
+            buyLabels: (body, options) => http.request("POST", "/v1/fulfilments/labels", { body, ...options }),
+            /** Marks it shipped, with your own tracking number when the label was not ours. */
+            ship: (fulfilmentId, body = {}, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/ship`, {
+                body,
+                ...options,
+            }),
+            /** Ready to collect: the shopper is told. */
+            ready: (fulfilmentId, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/ready`, {
+                body: {},
+                ...options,
+            }),
+            /** Hands over a collection by the shopper's code. */
+            collect: (body, options) => http.request("POST", "/v1/fulfilments/collect", { body, ...options }),
+            /** A local delivery leaves. */
+            outForDelivery: (fulfilmentId, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/out_for_delivery`, {
+                body: {},
+                ...options,
+            }),
+            delivered: (fulfilmentId, options) => http.request("POST", `/v1/fulfilments/${id(fulfilmentId)}/delivered`, {
+                body: {},
+                ...options,
+            }),
+        },
+        /** Returns and exchanges (87-09): requested, approved, on their way back, received, closed. */
+        returns: {
+            ...lister(http, "/v1/returns"),
+            create: (body, options) => http.request("POST", "/v1/returns", { body, ...options }),
+            retrieve: (returnId, options) => http.request("GET", `/v1/returns/${id(returnId)}`, options),
+            /** Finds the order a parcel or a receipt's code belongs to, at the counter. */
+            scan: (body, options) => http.request("POST", "/v1/returns/scan", { body, ...options }),
+            approve: (returnId, body = {}, options) => http.request("POST", `/v1/returns/${id(returnId)}/approve`, { body, ...options }),
+            reject: (returnId, body = {}, options) => http.request("POST", `/v1/returns/${id(returnId)}/reject`, { body, ...options }),
+            /** Received back; the refund or exchange follows the return's terms. */
+            receive: (returnId, body = {}, options) => http.request("POST", `/v1/returns/${id(returnId)}/receive`, { body, ...options }),
+            /** How the parcel can come back: a label, a drop-off, a shop. */
+            waysBack: (returnId, options) => http.request("GET", `/v1/returns/${id(returnId)}/ways_back`, options),
+            chooseWayBack: (returnId, body, options) => http.request("POST", `/v1/returns/${id(returnId)}/way_back`, { body, ...options }),
+            close: (returnId, options) => http.request("POST", `/v1/returns/${id(returnId)}/close`, {
+                body: {},
+                ...options,
+            }),
+        },
+        /** Closing the shipping day (87-10): the manifest for the carrier. */
+        shippingManifests: {
+            ...lister(http, "/v1/shipping_manifests"),
+            retrieve: (manifestId, options) => http.request("GET", `/v1/shipping_manifests/${id(manifestId)}`, options),
+            closeDay: (body = {}, options) => http.request("POST", "/v1/shipping_manifests", { body, ...options }),
+        },
+        /** A carrier collecting from a location (87-10). */
+        carrierPickups: {
+            ...lister(http, "/v1/carrier_pickups"),
+            retrieve: (pickupId, options) => http.request("GET", `/v1/carrier_pickups/${id(pickupId)}`, options),
+            book: (body, options) => http.request("POST", "/v1/carrier_pickups", { body, ...options }),
+        },
+        /** Postage owed for labels bought from the balance, and the credit limit (87-03). */
+        postage: {
+            retrieve: (options) => http.request("GET", "/v1/postage", options),
+        },
+        /** Your own carrier accounts for labels (87-03b); the balance is the fallback if allowed. */
+        carrierAccounts: {
+            /** The connected accounts, with every carrier and the fields each needs. */
+            list: (options) => http.request("GET", "/v1/carrier_accounts", options),
+            connect: (body, options) => http.request("POST", "/v1/carrier_accounts", { body, ...options }),
+            update: (accountId, body, options) => http.request("POST", `/v1/carrier_accounts/${id(accountId)}`, {
+                body,
+                ...options,
+            }),
+            disconnect: (accountId, options) => http.request("DELETE", `/v1/carrier_accounts/${id(accountId)}`, options),
+        },
+        /** What delivery costs where (87-01): profiles of zones, each with its rates. */
+        shippingProfiles: {
+            ...lister(http, "/v1/shipping_profiles"),
+            create: (body = {}, options) => http.request("POST", "/v1/shipping_profiles", { body, ...options }),
+            retrieve: (profileId, options) => http.request("GET", `/v1/shipping_profiles/${id(profileId)}`, options),
+            update: (profileId, body, options) => http.request("POST", `/v1/shipping_profiles/${id(profileId)}`, {
+                body,
+                ...options,
+            }),
+            del: (profileId, options) => http.request("DELETE", `/v1/shipping_profiles/${id(profileId)}`, options),
+            /** Moves these products onto the profile. */
+            assignProducts: (profileId, body, options) => http.request("POST", `/v1/shipping_profiles/${id(profileId)}/products`, {
+                body,
+                ...options,
+            }),
+            /** Products' weights where none was given, as delivery estimates them. */
+            estimatedWeights: (params = {}, options) => http.request("GET", "/v1/shipping_profiles/weights", {
+                query: params,
+                ...options,
+            }),
+            /** The delivery options a shopper would see for an address and basket. */
+            preview: (params, options) => http.request("GET", "/v1/shipping_profiles/preview", {
+                query: params,
+                ...options,
+            }),
+            createZone: (profileId, body, options) => http.request("POST", `/v1/shipping_profiles/${id(profileId)}/zones`, {
+                body,
+                ...options,
+            }),
+            updateZone: (profileId, zoneId, body, options) => http.request("POST", `/v1/shipping_profiles/${id(profileId)}/zones/${id(zoneId)}`, { body, ...options }),
+            deleteZone: (profileId, zoneId, options) => http.request("DELETE", `/v1/shipping_profiles/${id(profileId)}/zones/${id(zoneId)}`, options),
+            createRate: (profileId, zoneId, body, options) => http.request("POST", `/v1/shipping_profiles/${id(profileId)}/zones/${id(zoneId)}/rates`, { body, ...options }),
+            updateRate: (profileId, zoneId, rateId, body, options) => http.request("POST", `/v1/shipping_profiles/${id(profileId)}/zones/${id(zoneId)}/rates/${id(rateId)}`, { body, ...options }),
+            deleteRate: (profileId, zoneId, rateId, options) => http.request("DELETE", `/v1/shipping_profiles/${id(profileId)}/zones/${id(zoneId)}/rates/${id(rateId)}`, options),
+        },
+        /** The boxes you pack in, for label rates (87-02). */
+        shippingPackages: {
+            ...lister(http, "/v1/shipping_packages"),
+            create: (body, options) => http.request("POST", "/v1/shipping_packages", { body, ...options }),
+            update: (packageId, body, options) => http.request("POST", `/v1/shipping_packages/${id(packageId)}`, {
+                body,
+                ...options,
+            }),
+            del: (packageId, options) => http.request("DELETE", `/v1/shipping_packages/${id(packageId)}`, options),
+        },
+        /** The carriers' services a rate or a label can use. */
+        shippingServices: {
+            list: (params = {}, options) => http.request("GET", "/v1/shipping_services", {
+                query: params,
+                ...options,
+            }),
+        },
+        /** The media library (85-04): photos and videos for products and pages. */
+        media: {
+            ...lister(http, "/v1/media"),
+            /** A photo (base64 `data`), or a video from a finished upload; same bytes, same asset. */
+            create: (body, options) => http.request("POST", "/v1/media", { body, ...options }),
+            /** A resumable upload for a video up to 50 MB: send the bytes to `upload_url`. */
+            createUpload: (body, options) => http.request("POST", "/v1/media/uploads", { body, ...options }),
+            retrieve: (assetId, options) => http.request("GET", `/v1/media/${id(assetId)}`, options),
+            update: (assetId, body, options) => http.request("POST", `/v1/media/${id(assetId)}`, { body, ...options }),
+            /** 90-11: the products a video shows, proposed from up to six frames; they wait for you. */
+            proposeVideoTags: (assetId, body, options) => http.request("POST", `/v1/media/${id(assetId)}/video_tags/propose`, {
+                body,
+                ...options,
+            }),
+            /** 90-11: a video's product tags, confirmed: only these show on the store. */
+            setVideoTags: (assetId, body, options) => http.request("POST", `/v1/media/${id(assetId)}/video_tags`, {
+                body,
+                ...options,
+            }),
+            del: (assetId, options) => http.request("DELETE", `/v1/media/${id(assetId)}`, options),
+        },
+        /** The files digital products deliver to buyers (88-12). */
+        digitalAssets: {
+            ...lister(http, "/v1/digital_assets"),
+            create: (body, options) => http.request("POST", "/v1/digital_assets", { body, ...options }),
+            retrieve: (assetId, options) => http.request("GET", `/v1/digital_assets/${id(assetId)}`, options),
+            del: (assetId, options) => http.request("DELETE", `/v1/digital_assets/${id(assetId)}`, options),
+        },
+        /** Product photo edits (86-13): clean, studio, relight or scene, each a new asset. */
+        imageStudio: {
+            retrieve: (params = {}, options) => http.request("GET", "/v1/image_studio", { query: params, ...options }),
+            createEdit: (body, options) => http.request("POST", "/v1/image_studio/edits", { body, ...options }),
+        },
+        /** Store collections (85-05): chosen products, or rules that pick them. */
+        collections: {
+            ...lister(http, "/v1/collections"),
+            create: (body = {}, options) => http.request("POST", "/v1/collections", { body, ...options }),
+            retrieve: (collectionId, options) => http.request("GET", `/v1/collections/${id(collectionId)}`, options),
+            update: (collectionId, body, options) => http.request("POST", `/v1/collections/${id(collectionId)}`, {
+                body,
+                ...options,
+            }),
+            del: (collectionId, options) => http.request("DELETE", `/v1/collections/${id(collectionId)}`, options),
+            /** The collection's products in its order. */
+            products: childLister(http, (collectionId) => `/v1/collections/${id(collectionId)}/products`),
+        },
+        /** Drops (85-12): a limited release at a set time, sold through a fair queue. */
+        drops: {
+            ...lister(http, "/v1/drops"),
+            create: (body, options) => http.request("POST", "/v1/drops", { body, ...options }),
+            retrieve: (dropId, options) => http.request("GET", `/v1/drops/${id(dropId)}`, options),
+            update: (dropId, body, options) => http.request("POST", `/v1/drops/${id(dropId)}`, { body, ...options }),
+            /** The queue as counts: joined, drawing, waiting, checking out, done, and the waitlist. */
+            queue: (dropId, options) => http.request("GET", `/v1/drops/${id(dropId)}/queue`, options),
+        },
+        /**
+         * Products, one catalogue for the till and the store: their web fields (85-03), going
+         * online, variants, the image, licence keys for digital products and return insights.
+         */
+        products: {
+            ...lister(http, "/v1/products"),
+            create: (body, options) => http.request("POST", "/v1/products", { body, ...options }),
+            retrieve: (productId, options) => http.request("GET", `/v1/products/${id(productId)}`, options),
+            /** Web fields too: `web_title`, `web_description`, `web_path`, `seo`, `media`, `channels`. */
+            update: (productId, body, options) => http.request("POST", `/v1/products/${id(productId)}`, { body, ...options }),
+            /** The product with this barcode or SKU. */
+            lookup: (params, options) => http.request("GET", "/v1/products/lookup", { query: params, ...options }),
+            bulkUpdate: (body, options) => http.request("POST", "/v1/products/bulk", { body, ...options }),
+            archive: (productId, options) => http.request("POST", `/v1/products/${id(productId)}/archive`, {
+                body: {},
+                ...options,
+            }),
+            /** Sold out or back, on every channel at once. */
+            setAvailable: (productId, body, options) => http.request("POST", `/v1/products/${id(productId)}/available`, {
+                body,
+                ...options,
+            }),
+            /** What it still needs to go online, each with its fix. */
+            onlineChecklist: (productId, options) => http.request("GET", `/v1/products/${id(productId)}/online_checklist`, options),
+            publishOnline: (productId, options) => http.request("POST", `/v1/products/${id(productId)}/publish_online`, {
+                body: {},
+                ...options,
+            }),
+            unpublishOnline: (productId, options) => http.request("POST", `/v1/products/${id(productId)}/unpublish_online`, {
+                body: {},
+                ...options,
+            }),
+            variants: childLister(http, (productId) => `/v1/products/${id(productId)}/variants`),
+            updateVariant: (productId, variantId, body, options) => http.request("POST", `/v1/products/${id(productId)}/variants/${id(variantId)}`, { body, ...options }),
+            setImage: (productId, body, options) => http.request("POST", `/v1/products/${id(productId)}/image`, { body, ...options }),
+            removeImage: (productId, options) => http.request("DELETE", `/v1/products/${id(productId)}/image`, options),
+            /** A digital product's licence keys: how many are left. */
+            retrieveLicenceKeys: (productId, options) => http.request("GET", `/v1/products/${id(productId)}/licence_keys`, options),
+            addLicenceKeys: (productId, body, options) => http.request("POST", `/v1/products/${id(productId)}/licence_keys`, {
+                body,
+                ...options,
+            }),
+            /** Why it comes back, from its returns (87-09). */
+            returnInsights: (productId, options) => http.request("GET", `/v1/products/${id(productId)}/return_insights`, options),
+        },
+        /**
+         * Orders, one list for the till, the store and every channel (`source`): find them,
+         * change them, take tenders, return lines and send receipts.
+         */
+        orders: {
+            ...lister(http, "/v1/orders"),
+            create: (body, options) => http.request("POST", "/v1/orders", { body, ...options }),
+            retrieve: (orderId, options) => http.request("GET", `/v1/orders/${id(orderId)}`, options),
+            /** The order's lines, totals, fulfilment, payments and contact details. */
+            details: (orderId, options) => http.request("GET", `/v1/orders/${id(orderId)}/details`, options),
+            /** The order found by a receipt's number or code. */
+            findByReceipt: (body, options) => http.request("POST", "/v1/orders/by_receipt", { body, ...options }),
+            events: childLister(http, (orderId) => `/v1/orders/${id(orderId)}/events`),
+            /** A till's offline events, applied in order; replays are ignored. */
+            appendEvents: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/events`, { body, ...options }),
+            hold: (orderId, body = {}, options) => http.request("POST", `/v1/orders/${id(orderId)}/hold`, { body, ...options }),
+            resume: (orderId, body = {}, options) => http.request("POST", `/v1/orders/${id(orderId)}/resume`, { body, ...options }),
+            void: (orderId, body = {}, options) => http.request("POST", `/v1/orders/${id(orderId)}/void`, { body, ...options }),
+            setOrderType: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/order_type`, { body, ...options }),
+            applyDiscount: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/discounts`, { body, ...options }),
+            setTaxExemption: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/tax_exemption`, {
+                body,
+                ...options,
+            }),
+            setCustomer: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/customer`, { body, ...options }),
+            tenders: childLister(http, (orderId) => `/v1/orders/${id(orderId)}/tenders`),
+            createTender: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/tenders`, {
+                body,
+                ...options,
+            }),
+            complete: (orderId, body = {}, options) => http.request("POST", `/v1/orders/${id(orderId)}/complete`, { body, ...options }),
+            /** Lines back from a completed order, refunded to their tenders. */
+            createReturn: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/returns`, {
+                body,
+                ...options,
+            }),
+            /** What a return of these lines would refund, writing nothing. */
+            previewReturn: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/returns/preview`, {
+                body,
+                ...options,
+            }),
+            /** A store order's delivery address, while it has not shipped. */
+            changeDeliveryAddress: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/delivery_address`, {
+                body,
+                ...options,
+            }),
+            /** Release the hold on a store order's sending, so it can be packed and sent (92-11b). */
+            releaseHold: (orderId, options) => http.request("POST", `/v1/orders/${id(orderId)}/release_hold`, {
+                body: {},
+                ...options,
+            }),
+            resendConfirmation: (orderId, options) => http.request("POST", `/v1/orders/${id(orderId)}/resend_confirmation`, { body: {}, ...options }),
+            setEReceipt: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/e_receipt`, {
+                body,
+                ...options,
+            }),
+            retrieveReceipt: (orderId, params = {}, options) => http.request("GET", `/v1/orders/${id(orderId)}/receipt`, {
+                query: params,
+                ...options,
+            }),
+            sendReceipt: (orderId, body, options) => http.request("POST", `/v1/orders/${id(orderId)}/receipts`, {
+                body,
+                ...options,
+            }),
+            reprint: (orderId, options) => http.request("POST", `/v1/orders/${id(orderId)}/reprint`, {
+                body: {},
+                ...options,
+            }),
+        },
+        /** The store's policy pages: generated, put in your own words, approved by a person. */
+        sitePolicies: {
+            list: (params = {}, options) => http.request("GET", "/v1/site_policies", { query: params, ...options }),
+            /** Drafts every policy the site needs from what it sells and where; nothing goes live. */
+            generate: (body, options) => http.request("POST", "/v1/site_policies/generate", { body, ...options }),
+            retrieve: (policyId, options) => http.request("GET", `/v1/site_policies/${id(policyId)}`, options),
+            versions: (policyId, options) => http.request("GET", `/v1/site_policies/${id(policyId)}/versions`, options),
+            /** A new version in your own words, to approve. */
+            setOwnWords: (policyId, body, options) => http.request("POST", `/v1/site_policies/${id(policyId)}/own_words`, {
+                body,
+                ...options,
+            }),
+            retrieveVersion: (versionId, options) => http.request("GET", `/v1/site_policy_versions/${id(versionId)}`, options),
+            /** A person approves the version; it goes live on the store. */
+            approveVersion: (versionId, options) => http.request("POST", `/v1/site_policy_versions/${id(versionId)}/approve`, {
+                body: {},
+                ...options,
+            }),
+        },
+        /** Shoppers' requests to see or erase their data, to complete within the legal time. */
+        storePrivacyRequests: {
+            ...lister(http, "/v1/store_privacy_requests"),
+            retrieve: (requestId, options) => http.request("GET", `/v1/store_privacy_requests/${id(requestId)}`, options),
+            complete: (requestId, options) => http.request("POST", `/v1/store_privacy_requests/${id(requestId)}/complete`, { body: {}, ...options }),
+        },
+        /** Your own say over "you might also like": products pinned first, or never shown (91-03). */
+        recommendationRules: {
+            ...lister(http, "/v1/recommendation_rules"),
+            create: (body, options) => http.request("POST", "/v1/recommendation_rules", { body, ...options }),
+            retrieve: (ruleId, options) => http.request("GET", `/v1/recommendation_rules/${id(ruleId)}`, options),
+            update: (ruleId, body, options) => http.request("POST", `/v1/recommendation_rules/${id(ruleId)}`, {
+                body,
+                ...options,
+            }),
+            /** Takes the rule away: recommendations go back to the store's own. */
+            del: (ruleId, options) => http.request("DELETE", `/v1/recommendation_rules/${id(ruleId)}`, options),
+        },
+        /** Subscribe and save: a product on repeat for less, priced at each order (91-08). */
+        subscriptionOffers: {
+            ...lister(http, "/v1/subscription_offers"),
+            create: (body, options) => http.request("POST", "/v1/subscription_offers", { body, ...options }),
+            retrieve: (offerId, options) => http.request("GET", `/v1/subscription_offers/${id(offerId)}`, options),
+            /** Turn it off with `active: false`: offers are never deleted. */
+            update: (offerId, body, options) => http.request("POST", `/v1/subscription_offers/${id(offerId)}`, {
+                body,
+                ...options,
+            }),
+        },
+        /**
+         * Store campaigns (91-09b): a one-off email to a segment of the customers who said yes.
+         * Who it goes to is worked out when it sends; no method takes a list of people.
+         */
+        storeCampaigns: {
+            ...lister(http, "/v1/store_campaigns"),
+            create: (body, options) => http.request("POST", "/v1/store_campaigns", { body, ...options }),
+            retrieve: (campaignId, options) => http.request("GET", `/v1/store_campaigns/${id(campaignId)}`, options),
+            /** A draft only: only what is sent changes. */
+            update: (campaignId, body, options) => http.request("POST", `/v1/store_campaigns/${id(campaignId)}`, {
+                body,
+                ...options,
+            }),
+            /** How many it would reach now, a few first names, and the words. */
+            preview: (campaignId, options) => http.request("GET", `/v1/store_campaigns/${id(campaignId)}/preview`, options),
+            /** To the signed-in person's own email only (a dashboard session, not an API key). */
+            test: (campaignId, options) => http.request("POST", `/v1/store_campaigns/${id(campaignId)}/test`, options),
+            /** `send_at` on the business's clock, `YYYY-MM-DDTHH:MM`, or null for now. */
+            schedule: (campaignId, body = {}, options) => http.request("POST", `/v1/store_campaigns/${id(campaignId)}/schedule`, {
+                body,
+                ...options,
+            }),
+            unschedule: (campaignId, options) => http.request("POST", `/v1/store_campaigns/${id(campaignId)}/unschedule`, options),
+            results: (campaignId, options) => http.request("GET", `/v1/store_campaigns/${id(campaignId)}/results`, options),
+        },
+        /**
+         * Store flows (91-17): the six emails that go on their own to customers who said yes. Turn one
+         * off, change its words, or turn it back on after the guardrail paused it.
+         */
+        storeFlows: {
+            list: (options) => http.request("GET", "/v1/store_flows", options),
+            retrieve: (flowId, options) => http.request("GET", `/v1/store_flows/${id(flowId)}`, options),
+            /** `enabled`, `copy` (one for each message) or `use_default_copy`. */
+            update: (flowId, body, options) => http.request("POST", `/v1/store_flows/${id(flowId)}`, { body, ...options }),
+            /** After reviewing its email: only sends from now count towards the next pause. */
+            resume: (flowId, options) => http.request("POST", `/v1/store_flows/${id(flowId)}/resume`, options),
+        },
+        /** The store's connections to other places it sells: marketplaces, social shops, feeds (M90). */
+        salesChannels: {
+            ...lister(http, "/v1/sales_channels"),
+            retrieve: (channelId, options) => http.request("GET", `/v1/sales_channels/${id(channelId)}`, options),
+            /** Nothing is sent to the channel until it resumes. */
+            pause: (channelId, options) => http.request("POST", `/v1/sales_channels/${id(channelId)}/pause`, {
+                body: {},
+                ...options,
+            }),
+            /** What changed while paused is sent. */
+            resume: (channelId, options) => http.request("POST", `/v1/sales_channels/${id(channelId)}/resume`, {
+                body: {},
+                ...options,
+            }),
+        },
+        /** Each variant's place on a channel, with its state and the channel's issues (M90). */
+        listings: {
+            ...lister(http, "/v1/listings"),
+            retrieve: (listingId, options) => http.request("GET", `/v1/listings/${id(listingId)}`, options),
+            /** Keeps this variant off the channel; it stays on the store. */
+            exclude: (listingId, options) => http.request("POST", `/v1/listings/${id(listingId)}/exclude`, {
+                body: {},
+                ...options,
+            }),
+            /** Lists this variant on the channel again. */
+            include: (listingId, options) => http.request("POST", `/v1/listings/${id(listingId)}/include`, {
+                body: {},
+                ...options,
+            }),
+        },
+        /** The store inbox: shoppers' conversations with the store, by chat and email (91-10). */
+        storeThreads: {
+            ...lister(http, "/v1/store_threads"),
+            /** With its messages. */
+            retrieve: (threadId, options) => http.request("GET", `/v1/store_threads/${id(threadId)}`, options),
+            /** `status` and `assignee` (a team member's `usr_` id, or null). */
+            update: (threadId, body, options) => http.request("POST", `/v1/store_threads/${id(threadId)}`, {
+                body,
+                ...options,
+            }),
+            /** By email from the store's sender when the shopper left an address. */
+            reply: (threadId, body, options) => http.request("POST", `/v1/store_threads/${id(threadId)}/messages`, {
+                body,
+                ...options,
+            }),
+            /** A WhatsApp conversation's approved templates (91-11). */
+            templates: (threadId, options) => http.request("GET", `/v1/store_threads/${id(threadId)}/templates`, options),
+            /** An approved WhatsApp template: the only reply WhatsApp takes after 24 hours (91-11). */
+            sendTemplate: (threadId, body, options) => http.request("POST", `/v1/store_threads/${id(threadId)}/templates`, {
+                body,
+                ...options,
+            }),
+        },
+        /** Your store's own sending domain: store emails go from it once it verifies (91-13). */
+        merchantSendingDomains: {
+            ...lister(http, "/v1/merchant_sending_domains"),
+            /** `mail.` on your store's own domain, or null. */
+            suggestion: (options) => http.request("GET", "/v1/merchant_sending_domains/suggestion", options),
+            /** The suggestion when `domain` is left out. Answers the records to add. */
+            create: (body = {}, options) => http.request("POST", "/v1/merchant_sending_domains", {
+                body,
+                ...options,
+            }),
+            retrieve: (domainId, options) => http.request("GET", `/v1/merchant_sending_domains/${id(domainId)}`, options),
+            /** Checks the records now. */
+            check: (domainId, options) => http.request("POST", `/v1/merchant_sending_domains/${id(domainId)}/check`, options),
+            /** Store emails go from Tuppence in your name again. */
+            remove: (domainId, options) => http.request("DELETE", `/v1/merchant_sending_domains/${id(domainId)}`, options),
+        },
+    };
+}