@tuppence/node 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2719 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AGENT_PROOF_HEADER: () => AGENT_PROOF_HEADER,
+  ApiError: () => ApiError,
+  AuthenticationError: () => AuthenticationError,
+  CardError: () => CardError,
+  ConnectionError: () => ConnectionError,
+  DEFAULT_API_VERSION: () => DEFAULT_API_VERSION,
+  DEFAULT_TOLERANCE_SECONDS: () => DEFAULT_TOLERANCE_SECONDS,
+  IdempotencyError: () => IdempotencyError,
+  InvalidRequestError: () => InvalidRequestError,
+  PermissionError: () => PermissionError,
+  RateLimitError: () => RateLimitError,
+  SIGNATURE_HEADER: () => SIGNATURE_HEADER,
+  SignatureVerificationError: () => SignatureVerificationError,
+  Tuppence: () => Tuppence,
+  TuppenceError: () => TuppenceError,
+  VERSION: () => VERSION,
+  constructEvent: () => constructEvent,
+  default: () => index_default,
+  signAgentProof: () => signAgentProof
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var TuppenceError = class extends Error {
+  type;
+  code;
+  status;
+  param;
+  declineCode;
+  requestId;
+  /**
+   * The whole error object — e.g. `balance` and `topup_url` on `insufficient_credits`; `limit`,
+   * `used`, `max`, `resets_at` and `increase_url` on `issuing_card_limit`; `missing_evidence` on
+   * `dispute_evidence_incomplete`; `country`, `country_label`, `coming_soon` and `waitlist_url` on
+   * `country_not_supported` and `region_unavailable`.
+   */
+  raw;
+  constructor(body, status) {
+    super(body.message ?? "The Tuppence API returned an error.");
+    this.name = new.target.name;
+    this.type = body.type ?? "api_error";
+    this.code = body.code ?? "unknown_error";
+    this.status = status;
+    this.param = body.param;
+    this.declineCode = body.decline_code;
+    this.requestId = body.request_id;
+    this.raw = body;
+  }
+  /** The right subclass for an error envelope. */
+  static from(body, status) {
+    const Kind = {
+      invalid_request_error: InvalidRequestError,
+      authentication_error: AuthenticationError,
+      permission_error: PermissionError,
+      rate_limit_error: RateLimitError,
+      idempotency_error: IdempotencyError,
+      card_error: CardError
+    }[body.type ?? ""] ?? ApiError;
+    return new Kind(body, status);
+  }
+};
+var InvalidRequestError = class extends TuppenceError {
+};
+var AuthenticationError = class extends TuppenceError {
+};
+var PermissionError = class extends TuppenceError {
+};
+var RateLimitError = class extends TuppenceError {
+};
+var IdempotencyError = class extends TuppenceError {
+};
+var CardError = class extends TuppenceError {
+};
+var ApiError = class extends TuppenceError {
+};
+var ConnectionError = class extends TuppenceError {
+  constructor(message, cause) {
+    super({ type: "connection_error", code: "connection_failed", message });
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var SignatureVerificationError = class extends TuppenceError {
+  constructor(code, message) {
+    super({ type: "signature_verification_error", code, message });
+  }
+};
+
+// src/http.ts
+var VERSION = "0.1.0";
+var DEFAULT_API_VERSION = "2026-09-20";
+var EncodedBody = class {
+  constructor(bytes, contentType) {
+    this.bytes = bytes;
+    this.contentType = contentType;
+  }
+};
+var RETRY_BASE_MS = 500;
+var RETRY_MAX_MS = 8e3;
+var backoff = (attempt) => Math.random() * Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** attempt);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var HttpClient = class {
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+    if (!apiKey || typeof apiKey !== "string") {
+      throw new TypeError("new Tuppence(apiKey): an API key (sk_test_\u2026 or sk_live_\u2026) is required.");
+    }
+    this.baseUrl = (options.baseUrl ?? globalThis.process?.env?.TUPPENCE_API_URL ?? "https://api.tuppence.ai").replace(/\/+$/, "");
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (!fetcher)
+      throw new TypeError("fetch is not available: use Node 18+ or pass options.fetch.");
+    this.fetch = fetcher;
+  }
+  baseUrl;
+  fetch;
+  async request(method, path, { body, query, ...options } = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+    }
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "application/json",
+      "User-Agent": `tuppence-node/${VERSION}`
+    };
+    const version = options.apiVersion ?? this.options.apiVersion;
+    if (version) headers["Tuppence-Version"] = version;
+    const account = options.tuppenceAccount ?? this.options.tuppenceAccount;
+    if (account) headers["Tuppence-Account"] = account;
+    const encoded = body instanceof EncodedBody ? body : void 0;
+    if (encoded) headers["Content-Type"] = encoded.contentType;
+    else if (body !== void 0) headers["Content-Type"] = "application/json";
+    if (method === "POST")
+      headers["Idempotency-Key"] = options.idempotencyKey ?? crypto.randomUUID();
+    const retries = options.maxRetries ?? this.options.maxRetries ?? 2;
+    const timeoutMs = options.timeoutMs ?? this.options.timeoutMs ?? 3e4;
+    for (let attempt = 0; ; attempt += 1) {
+      let response;
+      try {
+        response = await this.fetch(url, {
+          method,
+          headers,
+          body: encoded ? encoded.bytes : body === void 0 ? void 0 : JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (error2) {
+        if (attempt < retries) {
+          await sleep(backoff(attempt));
+          continue;
+        }
+        const timedOut = error2.name === "TimeoutError";
+        throw new ConnectionError(
+          timedOut ? `No answer from Tuppence within ${timeoutMs} ms (${retries + 1} attempts).` : `Could not reach Tuppence (${retries + 1} attempts): ${error2.message}`,
+          error2
+        );
+      }
+      if (response.ok) {
+        this.notice(response.headers.get("tuppence-notice"));
+        return response.status === 204 ? void 0 : await response.json();
+      }
+      const text = await response.text();
+      let error;
+      try {
+        error = JSON.parse(text).error ?? { message: text };
+      } catch {
+        error = { message: text || `HTTP ${response.status}` };
+      }
+      error.request_id ??= response.headers.get("request-id") ?? void 0;
+      if (attempt < retries && retryable(response.status, error)) {
+        const after = Number(response.headers.get("retry-after"));
+        await sleep(
+          Number.isFinite(after) && after > 0 ? Math.min(after * 1e3, RETRY_MAX_MS) : backoff(attempt)
+        );
+        continue;
+      }
+      throw TuppenceError.from(error, response.status);
+    }
+  }
+  noticed = /* @__PURE__ */ new Set();
+  /** `code; message` — said once per code, and never twice for the same kind of request. */
+  notice(header) {
+    if (!header) return;
+    const [code = "", ...rest] = header.split(";");
+    const message = rest.join(";").trim();
+    if (!code || this.noticed.has(code)) return;
+    this.noticed.add(code);
+    const handler = this.options.onNotice;
+    if (handler) handler({ code, message });
+    else console.warn(`Tuppence: ${message || code}`);
+  }
+};
+function retryable(status, error) {
+  return status >= 500 || status === 429 || status === 409 && error.code === "idempotency_in_progress";
+}
+
+// src/resources.ts
+var id = (value) => encodeURIComponent(value);
+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))
+  };
+}
+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)
+  };
+}
+async function multipart(fields, { file, filename }) {
+  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"
+  );
+}
+function resources(http) {
+  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 !== void 0).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 !== void 0 ? { 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 !== void 0).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
+      )
+    }
+  };
+}
+
+// src/webhooks.ts
+var import_node_crypto = require("node:crypto");
+var SIGNATURE_HEADER = "Tuppence-Signature";
+var DEFAULT_TOLERANCE_SECONDS = 300;
+var hmac = (secret, timestamp, payload) => (0, import_node_crypto.createHmac)("sha256", secret).update(`${timestamp}.${payload}`, "utf8").digest("hex");
+function constructEvent(payload, header, secret, options = {}) {
+  const body = typeof payload === "string" ? payload : payload.toString("utf8");
+  const value = Array.isArray(header) ? header[0] : header;
+  if (!value) {
+    throw new SignatureVerificationError("malformed_header", `No ${SIGNATURE_HEADER} header.`);
+  }
+  let timestamp;
+  const signatures = [];
+  for (const part of value.split(",")) {
+    const index = part.indexOf("=");
+    if (index < 1)
+      throw new SignatureVerificationError(
+        "malformed_header",
+        "The signature header is malformed."
+      );
+    const key = part.slice(0, index).trim();
+    const v = part.slice(index + 1).trim();
+    if (key === "t" && /^\d{1,12}$/.test(v)) timestamp = Number(v);
+    else if (key === "v1") signatures.push(v);
+  }
+  if (timestamp === void 0 || signatures.length === 0) {
+    throw new SignatureVerificationError("malformed_header", "The signature header is malformed.");
+  }
+  const expected = Buffer.from(hmac(secret, timestamp, body), "hex");
+  const matched = signatures.some(
+    (candidate) => /^[0-9a-f]{64}$/i.test(candidate) && (0, import_node_crypto.timingSafeEqual)(Buffer.from(candidate, "hex"), expected)
+  );
+  if (!matched) {
+    throw new SignatureVerificationError(
+      "no_matching_signature",
+      "The signature does not match: check the endpoint's signing secret, and that you passed the raw body."
+    );
+  }
+  const now = options.nowSeconds ?? Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - timestamp) > (options.toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS)) {
+    throw new SignatureVerificationError(
+      "timestamp_out_of_tolerance",
+      "The webhook's timestamp is too old (or your clock is wrong): refusing a possible replay."
+    );
+  }
+  return JSON.parse(body);
+}
+function generateTestHeader(payload, secret, timestamp = Math.floor(Date.now() / 1e3)) {
+  return `t=${timestamp},v1=${hmac(secret, timestamp, payload)}`;
+}
+
+// src/agent-proof.ts
+var import_node_crypto2 = require("node:crypto");
+var b64url = (value) => (Buffer.isBuffer(value) ? value : Buffer.from(JSON.stringify(value))).toString("base64url");
+function keyOf(key) {
+  if (typeof key === "string") return (0, import_node_crypto2.createPrivateKey)(key);
+  if (typeof key === "object" && "d" in key) return (0, import_node_crypto2.createPrivateKey)({ key, format: "jwk" });
+  return key;
+}
+function canonical(url) {
+  const parsed = new URL(url);
+  parsed.hash = "";
+  return parsed.search === "?" ? parsed.toString().replace(/\?$/, "") : parsed.toString();
+}
+function signAgentProof(input) {
+  const now = input.nowSeconds ?? Math.floor(Date.now() / 1e3);
+  const header = { alg: "EdDSA", typ: "agent-proof+jwt", kid: input.kid };
+  const claims = {
+    iss: input.agent,
+    htm: input.method.toUpperCase(),
+    htu: canonical(input.url),
+    iat: now,
+    exp: now + (input.lifetimeSeconds ?? 60),
+    jti: (0, import_node_crypto2.randomUUID)(),
+    ...input.body === void 0 ? {} : { bh: (0, import_node_crypto2.createHash)("sha256").update(input.body).digest("base64url") },
+    ...input.audience === void 0 ? {} : { aud: input.audience }
+  };
+  const signed = `${b64url(header)}.${b64url(claims)}`;
+  return `${signed}.${b64url((0, import_node_crypto2.sign)(null, Buffer.from(signed), keyOf(input.privateKey)))}`;
+}
+var AGENT_PROOF_HEADER = "Tuppence-Agent-Proof";
+
+// src/index.ts
+var Tuppence = class _Tuppence {
+  http;
+  // Kept for `as()`, out of sight: never enumerable, printed or serialised.
+  #apiKey;
+  #options;
+  account;
+  /** Bacs Direct Debit by application: its status, applying, and asking for higher limits. */
+  directDebit;
+  /** Tuppence Connect: your connected accounts, and their people, banks and capabilities. */
+  accounts;
+  accountLinks;
+  files;
+  /** Your fees on your connected accounts' payments, and the refunds of them. */
+  applicationFees;
+  /** Money from your Connect balance to your connected accounts, and its reversals. */
+  transfers;
+  plans;
+  subscriptions;
+  paymentLinks;
+  payments;
+  refunds;
+  customers;
+  balance;
+  payouts;
+  disputes;
+  events;
+  /** Tuppence Events: `ticketing.events`, `.promoCodes`, `.fundsHolds`, `.reports`. */
+  ticketing;
+  ticketTypes;
+  ticketOrders;
+  tickets;
+  webhookEndpoints;
+  paymentMethodDomains;
+  meters;
+  credits;
+  meterEvents;
+  agents;
+  cardholders;
+  spendPolicies;
+  cards;
+  cardAuthorizations;
+  cardTransactions;
+  /** Disputing a card purchase: a draft, its evidence and files, then submitted by a person. */
+  cardDisputes;
+  /**
+   * The cards' own balance and its top-ups — `issuing.balance`, `issuing.topups`,
+   * `issuing.fundingInstructions` — and Issuing's limits for the account's tier (`issuing.limits`).
+   */
+  issuing;
+  /** TEST MODE only: `testHelpers.issuing.topups.arrive(id)`. */
+  testHelpers;
+  approvals;
+  locations;
+  countryPacks;
+  serviceCategories;
+  services;
+  staff;
+  scheduleExceptions;
+  resources;
+  bookingPolicy;
+  bookingPage;
+  availability;
+  bookings;
+  classSessions;
+  bookingSeries;
+  waitlist;
+  // The store (94-02).
+  reviews;
+  changeSets;
+  storeImports;
+  assistantJobs;
+  channelReports;
+  storeBriefs;
+  sites;
+  store;
+  fulfilments;
+  returns;
+  shippingManifests;
+  carrierPickups;
+  postage;
+  carrierAccounts;
+  shippingProfiles;
+  shippingPackages;
+  shippingServices;
+  media;
+  digitalAssets;
+  imageStudio;
+  collections;
+  drops;
+  products;
+  orders;
+  sitePolicies;
+  storePrivacyRequests;
+  recommendationRules;
+  subscriptionOffers;
+  storeCampaigns;
+  storeFlows;
+  salesChannels;
+  listings;
+  storeThreads;
+  merchantSendingDomains;
+  webhooks = { constructEvent, generateTestHeader };
+  constructor(apiKey, options = {}) {
+    this.http = new HttpClient(apiKey, options);
+    this.#apiKey = apiKey;
+    this.#options = options;
+    const r = resources(this.http);
+    this.account = r.account;
+    this.directDebit = r.directDebit;
+    this.accounts = r.accounts;
+    this.accountLinks = r.accountLinks;
+    this.files = r.files;
+    this.applicationFees = r.applicationFees;
+    this.transfers = r.transfers;
+    this.plans = r.plans;
+    this.subscriptions = r.subscriptions;
+    this.paymentLinks = r.paymentLinks;
+    this.payments = r.payments;
+    this.refunds = r.refunds;
+    this.customers = r.customers;
+    this.balance = r.balance;
+    this.payouts = r.payouts;
+    this.disputes = r.disputes;
+    this.events = r.events;
+    this.ticketing = r.ticketing;
+    this.ticketTypes = r.ticketTypes;
+    this.ticketOrders = r.ticketOrders;
+    this.tickets = r.tickets;
+    this.webhookEndpoints = r.webhookEndpoints;
+    this.paymentMethodDomains = r.paymentMethodDomains;
+    this.meters = r.meters;
+    this.credits = r.credits;
+    this.meterEvents = r.meterEvents;
+    this.agents = r.agents;
+    this.cardholders = r.cardholders;
+    this.spendPolicies = r.spendPolicies;
+    this.cards = r.cards;
+    this.cardAuthorizations = r.cardAuthorizations;
+    this.cardTransactions = r.cardTransactions;
+    this.cardDisputes = r.cardDisputes;
+    this.issuing = r.issuing;
+    this.testHelpers = r.testHelpers;
+    this.approvals = r.approvals;
+    this.locations = r.locations;
+    this.countryPacks = r.countryPacks;
+    this.serviceCategories = r.serviceCategories;
+    this.services = r.services;
+    this.staff = r.staff;
+    this.scheduleExceptions = r.scheduleExceptions;
+    this.resources = r.resources;
+    this.bookingPolicy = r.bookingPolicy;
+    this.bookingPage = r.bookingPage;
+    this.availability = r.availability;
+    this.bookings = r.bookings;
+    this.classSessions = r.classSessions;
+    this.bookingSeries = r.bookingSeries;
+    this.waitlist = r.waitlist;
+    this.reviews = r.reviews;
+    this.changeSets = r.changeSets;
+    this.storeImports = r.storeImports;
+    this.assistantJobs = r.assistantJobs;
+    this.channelReports = r.channelReports;
+    this.storeBriefs = r.storeBriefs;
+    this.sites = r.sites;
+    this.store = r.store;
+    this.fulfilments = r.fulfilments;
+    this.returns = r.returns;
+    this.shippingManifests = r.shippingManifests;
+    this.carrierPickups = r.carrierPickups;
+    this.postage = r.postage;
+    this.carrierAccounts = r.carrierAccounts;
+    this.shippingProfiles = r.shippingProfiles;
+    this.shippingPackages = r.shippingPackages;
+    this.shippingServices = r.shippingServices;
+    this.media = r.media;
+    this.digitalAssets = r.digitalAssets;
+    this.imageStudio = r.imageStudio;
+    this.collections = r.collections;
+    this.drops = r.drops;
+    this.products = r.products;
+    this.orders = r.orders;
+    this.sitePolicies = r.sitePolicies;
+    this.storePrivacyRequests = r.storePrivacyRequests;
+    this.recommendationRules = r.recommendationRules;
+    this.subscriptionOffers = r.subscriptionOffers;
+    this.storeCampaigns = r.storeCampaigns;
+    this.storeFlows = r.storeFlows;
+    this.salesChannels = r.salesChannels;
+    this.listings = r.listings;
+    this.storeThreads = r.storeThreads;
+    this.merchantSendingDomains = r.merchantSendingDomains;
+  }
+  /**
+   * Tuppence Connect: a client that acts as one of your connected accounts on every request —
+   * the `Tuppence-Account` header, with your key. A NEW client: this one is unchanged, so one
+   * shared client can serve every account. A request's own `tuppenceAccount` still wins.
+   *
+   *   const bella = tuppence.as("acct_…");
+   *   await bella.bookings.create({ … });
+   */
+  as(accountId) {
+    if (!accountId || typeof accountId !== "string") {
+      throw new TypeError('tuppence.as(accountId): a connected account id ("acct_\u2026") is required.');
+    }
+    return new _Tuppence(this.#apiKey, { ...this.#options, tuppenceAccount: accountId });
+  }
+  /** Any endpoint the SDK has no method for yet — same auth, retries and idempotency. */
+  request(method, path, options = {}) {
+    return this.http.request(method, path, options);
+  }
+};
+var index_default = Tuppence;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_PROOF_HEADER,
+  ApiError,
+  AuthenticationError,
+  CardError,
+  ConnectionError,
+  DEFAULT_API_VERSION,
+  DEFAULT_TOLERANCE_SECONDS,
+  IdempotencyError,
+  InvalidRequestError,
+  PermissionError,
+  RateLimitError,
+  SIGNATURE_HEADER,
+  SignatureVerificationError,
+  Tuppence,
+  TuppenceError,
+  VERSION,
+  constructEvent,
+  signAgentProof
+});