@hanzo/commerce 7.8.3 → 7.9.1

package/dist/client.js

@@ -1,392 +1,1016 @@
 /**
- * @hanzo/commerce/client
+ * @hanzo/commerce/client — the Commerce and Billing API, as the document
+ * describes it.
  *
- * Universal TypeScript client for the Hanzo Commerce API.
- * Works in browser, Node.js, and edge runtimes — no backend required.
- * Covers billing, subscriptions, payments, checkout, coupons,
- * referrals, affiliates, usage, and plans.
+ * GENERATED from `cloud/openapi.yaml`. Do not hand-edit: a method here exists
+ * because an operation exists, and it is named by that operation's own id. The
+ * previous client was written by hand and eleven of its twenty-six addresses had
+ * stopped existing, which nothing reported until a call 404'd.
  *
- * @example
- * ```ts
- * import { Commerce } from '@hanzo/commerce/client'
+ * Two surfaces, orthogonal and both here because a store needs both: `commerce`
+ * is the storefront — cart, catalog, product, variant, discount, store — and
+ * `billing` is the ledger — balance, credits, invoices, methods, subscriptions,
+ * usage. They share one noun, `plans`.
  *
- * const commerce = new Commerce({ baseUrl: 'https://api.hanzo.ai', token: iamToken })
- *
- * // Validate a coupon before checkout
- * const coupon = await commerce.validateCoupon('LAUNCH50')
- *
- * // Create a checkout session
- * const session = await commerce.createCheckoutSession({
- *   items: [{ id: 'plan_pro', quantity: 1 }],
- *   couponCode: 'LAUNCH50',
- *   referrerId: 'ref_abc123',
- *   successUrl: 'https://app.example.com/success',
- *   cancelUrl: 'https://app.example.com/cancel',
- * })
- * window.location.href = session.checkoutUrl
+ *   const commerce = new Commerce({ baseUrl: 'https://api.hanzo.ai', token })
+ *   const balance = await commerce.getBillingBalance()
+ */
+/**
+ * A refusal, carrying what the service said about it.
  *
- * // Subscribe
- * const sub = await commerce.subscribe({ planId: 'pro', userId: 'user_xyz' })
- * ```
+ * RFC 9457 problem documents are what this API answers with, so `detail` is the
+ * member to read; `status` is the code. The raw body is kept because a problem
+ * document may carry extension members this class does not name.
  */
-// ---------------------------------------------------------------------------
-// Client
-// ---------------------------------------------------------------------------
-const DEFAULT_BASE_URL = 'https://api.hanzo.ai';
-const DEFAULT_TIMEOUT_MS = 15000;
+export class CommerceApiError extends Error {
+    constructor(status, detail, body) {
+        super(detail || `commerce: ${status}`);
+        this.status = status;
+        this.detail = detail;
+        this.body = body;
+        this.name = 'CommerceApiError';
+    }
+}
+export const DEFAULT_BASE_URL = 'https://api.hanzo.ai';
 export class Commerce {
     constructor(config = {}) {
-        this.baseUrl = (config.baseUrl ?? config.commerceUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, '');
         this.token = config.token;
-        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.timeoutMs = config.timeoutMs ?? 30000;
     }
-    /** Update the auth token (e.g. after IAM token refresh). */
+    /** Use this token from now on — after a sign-in, or a refresh. */
     setToken(token) {
         this.token = token;
     }
-    async request(path, opts) {
-        const url = new URL(path, this.baseUrl);
-        if (opts?.params) {
-            for (const [k, v] of Object.entries(opts.params)) {
-                url.searchParams.set(k, v);
-            }
-        }
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-        const headers = { Accept: 'application/json' };
-        const authToken = opts?.token ?? this.token;
-        if (authToken)
-            headers['Authorization'] = `Bearer ${authToken}`;
-        if (opts?.body)
-            headers['Content-Type'] = 'application/json';
-        if (opts?.headers)
-            Object.assign(headers, opts.headers);
-        try {
-            const res = await fetch(url.toString(), {
-                method: opts?.method ?? 'GET',
-                headers,
-                body: opts?.body ? JSON.stringify(opts.body) : undefined,
-                signal: controller.signal,
-            });
-            if (!res.ok) {
-                const text = await res.text().catch(() => '');
-                throw new CommerceApiError(res.status, `${res.statusText}: ${text}`.trim());
-            }
-            return (await res.json());
+    /**
+     * One request, one place.
+     *
+     * A per-call token overrides the client's, which is what a server rendering
+     * for one user among many needs: the client is shared, the identity is not.
+     *
+     * Public because a few addresses this API serves are in neither document.
+     * Everything the documents DO describe has a method below; reach for this only
+     * when nothing there fits, and say why at the call site.
+     */
+    async request(method, path, opts = {}) {
+        const url = new URL(this.baseUrl + path);
+        for (const [k, v] of Object.entries(opts.query ?? {})) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
         }
-        finally {
-            clearTimeout(timer);
+        const token = opts.token ?? this.token;
+        const timer = AbortSignal.timeout(this.timeoutMs);
+        const res = await fetch(url, {
+            method,
+            signal: timer,
+            headers: {
+                accept: 'application/json',
+                ...(opts.body !== undefined ? { 'content-type': 'application/json' } : {}),
+                ...(token ? { authorization: `Bearer ${token}` } : {}),
+                ...opts.headers,
+            },
+            ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+        });
+        if (res.status === 204)
+            return undefined;
+        const text = await res.text();
+        const body = text ? safeJson(text) : undefined;
+        if (!res.ok) {
+            const d = body;
+            throw new CommerceApiError(res.status, d?.detail ?? d?.title ?? d?.msg ?? text.slice(0, 200), body);
         }
+        // The /v1 envelope carries the value under `data`; a typed body is itself.
+        const env = body;
+        return (env && typeof env === 'object' && 'data' in env ? env.data : body);
     }
-    // -----------------------------------------------------------------------
-    // Balance
-    // -----------------------------------------------------------------------
-    async getBalance(user, currency = 'usd', token, headers) {
-        return this.request('/v1/billing/balance', {
-            params: { user, currency }, token, headers,
-        });
+    /** Answers the caller's billing accounts: the org itself, its currency, when it was opened, and the caller's own standing in it. */
+    getBillingAccounts(opts = {}) {
+        return this.request('GET', `/v1/billing/accounts`, opts);
     }
-    async getAllBalances(user, token) {
-        return this.request('/v1/billing/balance/all', {
-            params: { user }, token,
-        });
+    /** Answers one billing account's roster. */
+    getBillingAccountsByIdMembers(id, opts = {}) {
+        return this.request('GET', `/v1/billing/accounts/${encodeURIComponent(id)}/members`, opts);
     }
-    /**
-     * Tier-aware balance: prepaid available plus the tenant's included plan
-     * allotment (effectiveAvailable). Use this for the metering gate when you
-     * want included usage (e.g. free-tier daily credit) honored before prepaid
-     * funds are drawn down.
-     */
-    async getTier(user, opts) {
-        return this.request('/v1/billing/tier', {
-            params: { user }, token: opts?.token, headers: opts?.headers,
-        });
+    /** Lists this org's spend caps: the ceiling, its scope, whether it enforces, and how much of it has been spent this period. */
+    getBillingAlerts(opts = {}) {
+        return this.request('GET', `/v1/billing/alerts`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Usage
-    // -----------------------------------------------------------------------
-    async addUsageRecord(record, token, headers) {
-        return this.request('/v1/billing/usage', {
-            method: 'POST', body: record, token, headers,
-        });
+    /** Opens a spend cap on the caller's own org. */
+    postBillingAlerts(opts = {}) {
+        return this.request('POST', `/v1/billing/alerts`, opts);
     }
-    async getUsageRecords(user, currency = 'usd', token) {
-        return this.request('/v1/billing/usage', {
-            params: { user, currency }, token,
-        });
+    /** Answers whether one proposed spend fits inside this org's caps. */
+    getBillingAlertsAuthorize(opts = {}) {
+        return this.request('GET', `/v1/billing/alerts/authorize`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Deposits / Credits
-    // -----------------------------------------------------------------------
-    async addDeposit(params, token) {
-        return this.request('/v1/billing/crypto/deposit', {
-            method: 'POST', body: params, token,
-        });
+    /** Removes one of the caller's spend caps and answers 204. */
+    deleteBillingAlertsById(id, opts = {}) {
+        return this.request('DELETE', `/v1/billing/alerts/${encodeURIComponent(id)}`, opts);
     }
-    async grantStarterCredit(user, token) {
-        return this.request('/v1/billing/credits', {
-            method: 'POST', body: { user }, token,
-        });
+    /** Changes one spend cap: raise or lower the ceiling, flip enforcement, retune the rate limit. */
+    patchBillingAlertsById(id, opts = {}) {
+        return this.request('PATCH', `/v1/billing/alerts/${encodeURIComponent(id)}`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Plans
-    // -----------------------------------------------------------------------
-    async getPlans(token) {
-        return this.request('/v1/billing/plans', { token });
+    /** Prepaid credit the caller's org can still spend */
+    getBillingBalance(opts = {}) {
+        return this.request('GET', `/v1/billing/balance`, opts);
     }
-    async getPlan(planId, token) {
-        try {
-            return await this.request(`/v1/billing/plans/${planId}`, { token });
-        }
-        catch {
-            return null;
-        }
+    /** Answers what the caller can spend right now, one entry per currency. */
+    getBillingCreditBalance(opts = {}) {
+        return this.request('GET', `/v1/billing/credit-balance`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Subscriptions
-    // -----------------------------------------------------------------------
-    async subscribe(params, token) {
-        return this.request('/v1/billing/subscriptions', {
-            method: 'POST', body: params, token,
-        });
+    /** Answers that same spendable credit split by grant tag, with the earliest expiry under each and the total across all of them. */
+    getBillingCreditBalanceBreakdown(opts = {}) {
+        return this.request('GET', `/v1/billing/credit-balance/breakdown`, opts);
     }
-    async getSubscription(subscriptionId, token) {
-        try {
-            return await this.request(`/v1/billing/subscriptions/${subscriptionId}`, { token });
-        }
-        catch {
-            return null;
-        }
+    /** Lists the caller's credit grants — every one of them, spent and lapsed and voided included. */
+    getBillingCredits(opts = {}) {
+        return this.request('GET', `/v1/billing/credits`, opts);
     }
-    async listSubscriptions(params, token) {
-        return this.request('/v1/billing/subscriptions', {
-            params: params, token,
-        });
+    /** Issues a deposit address the caller can send crypto to, on the asset they ask for. */
+    postBillingCryptoDeposit(opts = {}) {
+        return this.request('POST', `/v1/billing/crypto/deposit`, opts);
     }
-    async updateSubscription(subscriptionId, update, token) {
-        return this.request(`/v1/billing/subscriptions/${subscriptionId}`, {
-            method: 'PATCH', body: update, token,
-        });
+    /** Reads one of the caller's own deposit intents back — pending, confirming, or succeeded. */
+    getBillingCryptoDepositById(id, opts = {}) {
+        return this.request('GET', `/v1/billing/crypto/deposit/${encodeURIComponent(id)}`, opts);
     }
-    async cancelSubscription(subscriptionId, immediately = false, token) {
-        return this.request(`/v1/billing/subscriptions/${subscriptionId}/cancel`, {
-            method: 'POST', body: { immediately }, token,
-        });
+    /** Answers which chains and tokens the crypto rail accepts — what an asset picker renders. */
+    getBillingCryptoOptions(opts = {}) {
+        return this.request('GET', `/v1/billing/crypto/options`, opts);
     }
-    async reactivateSubscription(subscriptionId, token) {
-        return this.request(`/v1/billing/subscriptions/${subscriptionId}/reactivate`, {
-            method: 'POST', token,
-        });
+    /** Lists the caller's invoices, newest first, with the count beside them. */
+    getBillingInvoices(opts = {}) {
+        return this.request('GET', `/v1/billing/invoices`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Checkout sessions
-    // -----------------------------------------------------------------------
-    /**
-     * Create a hosted checkout session.
-     * Returns a URL to redirect the customer to for payment.
-     * Supports coupons, referral tracking, and multiple currencies.
-     */
-    async createCheckoutSession(params, token) {
-        return this.request('/v1/checkout/sessions', {
-            method: 'POST', body: params, token,
-        });
+    /** Raise a draft invoice against a customer */
+    raiseInvoice(opts = {}) {
+        return this.request('POST', `/v1/billing/invoices`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Payment methods
-    // -----------------------------------------------------------------------
-    async addPaymentMethod(params, token) {
-        return this.request('/v1/billing/methods', {
-            method: 'POST', body: params, token,
-        });
+    /** Read one invoice */
+    getInvoice(id, opts = {}) {
+        return this.request('GET', `/v1/billing/invoices/${encodeURIComponent(id)}`, opts);
     }
-    async listPaymentMethods(customerId, token) {
-        return this.request('/v1/billing/methods', {
-            params: { customerId }, token,
-        });
+    /** Collect an issued invoice from credits, balance, then card */
+    collectInvoice(id, opts = {}) {
+        return this.request('POST', `/v1/billing/invoices/${encodeURIComponent(id)}/collect`, opts);
     }
-    async removePaymentMethod(paymentMethodId, token) {
-        await this.request(`/v1/billing/methods/${paymentMethodId}`, {
-            method: 'DELETE', token,
-        });
+    /** Issue a draft invoice, making it collectible */
+    issueInvoice(id, opts = {}) {
+        return this.request('POST', `/v1/billing/invoices/${encodeURIComponent(id)}/issue`, opts);
     }
-    async setDefaultPaymentMethod(customerId, paymentMethodId, token) {
-        return this.request(`/v1/billing/customers/${customerId}/default-payment-method`, {
-            method: 'POST', body: { paymentMethodId }, token,
-        });
+    /** Download one invoice as a PDF */
+    getBillingInvoicesByIdPdf(id, opts = {}) {
+        return this.request('GET', `/v1/billing/invoices/${encodeURIComponent(id)}/pdf`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Coupons / Promo codes
-    // -----------------------------------------------------------------------
-    /**
-     * Validate a coupon code.
-     * Optionally pass a subtotalCents to get the calculated discount amount.
-     */
-    async validateCoupon(code, subtotalCents, token) {
-        try {
-            const result = await this.request('/v1/coupon/validate', {
-                method: 'POST',
-                body: { code: code.toUpperCase().trim(), subtotalCents },
-                token,
-            });
-            return { valid: true, coupon: result };
-        }
-        catch (err) {
-            const msg = err instanceof CommerceApiError ? err.message : 'Invalid coupon';
-            return { valid: false, error: msg };
-        }
+    /** Void a draft or issued invoice */
+    voidInvoice(id, opts = {}) {
+        return this.request('POST', `/v1/billing/invoices/${encodeURIComponent(id)}/void`, opts);
     }
-    /**
-     * Redeem a coupon for a user. Creates credit grant records.
-     */
-    async redeemCoupon(code, userId, token) {
-        return this.request('/v1/coupon/redeem', {
-            method: 'POST',
-            body: { code: code.toUpperCase().trim(), userId },
-            token,
-        });
+    /** Answers the org's own postings inside `range=`, each as a signed entry: a DEPOSIT CREDITS the wallet (positive, account `credits:<org>`) and every other posting DEBITS it (negative, account `usage:<org>`), described by its notes or its tags. */
+    getBillingLedger(opts = {}) {
+        return this.request('GET', `/v1/billing/ledger`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Referrals & Affiliates
-    // -----------------------------------------------------------------------
-    /**
-     * Get or create a referrer record for a user.
-     * Returns the referral code/link the user can share.
-     */
-    async getOrCreateReferrer(userId, token) {
-        return this.request('/v1/referral', {
-            method: 'POST', body: { userId }, token,
-        });
+    /** Cards and accounts on file for the caller */
+    getBillingMethods(opts = {}) {
+        return this.request('GET', `/v1/billing/methods`, opts);
     }
-    async getReferrals(userId, token) {
-        return this.request(`/v1/user/${userId}/referrals`, { token });
+    /** Save a card or account for the caller */
+    postBillingMethods(opts = {}) {
+        return this.request('POST', `/v1/billing/methods`, opts);
     }
-    async getReferrers(userId, token) {
-        return this.request(`/v1/user/${userId}/referrers`, { token });
+    /** Removes one card or account the caller has saved. */
+    deleteBillingMethodsById(id, opts = {}) {
+        return this.request('DELETE', `/v1/billing/methods/${encodeURIComponent(id)}`, opts);
     }
-    /**
-     * Get affiliate details for a user.
-     */
-    async getAffiliate(userId, token) {
-        try {
-            return await this.request(`/v1/user/${userId}/affiliate`, { token });
-        }
-        catch {
-            return null;
-        }
+    /** Moves this org between sandbox money and real money. */
+    postBillingMode(opts = {}) {
+        return this.request('POST', `/v1/billing/mode`, opts);
     }
-    /**
-     * Create an affiliate account for a user.
-     * After creation, user can connect their bank via the returnedconnectUrl.
-     */
-    async createAffiliate(userId, token) {
-        return this.request('/v1/affiliate', {
-            method: 'POST', body: { userId }, token,
-        });
+    /** Answers the org's outbound payouts, newest first — amount, destination, status, and the failure reason where one applies. */
+    getBillingPayouts(opts = {}) {
+        return this.request('GET', `/v1/billing/payouts`, opts);
     }
-    async getAffiliateReferrals(affiliateId, token) {
-        return this.request(`/v1/affiliate/${affiliateId}/referrals`, { token });
+    /** The plan catalog, priced with whatever offer is in force */
+    getBillingPlans(opts = {}) {
+        return this.request('GET', `/v1/billing/plans`, opts);
     }
-    async getAffiliateOrders(affiliateId, token) {
-        return this.request(`/v1/affiliate/${affiliateId}/orders`, { token });
+    /** Cards and accounts on file for the caller */
+    getBillingPortalMethods(opts = {}) {
+        return this.request('GET', `/v1/billing/portal/methods`, opts);
     }
-    async getAffiliateTransactions(affiliateId, token) {
-        return this.request(`/v1/affiliate/${affiliateId}/transactions`, { token });
+    /** Save a card or account for the caller */
+    postBillingPortalMethods(opts = {}) {
+        return this.request('POST', `/v1/billing/portal/methods`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Legacy checkout (order-based)
-    // -----------------------------------------------------------------------
-    async authorize(orderId, token) {
-        return this.request(`/v1/authorize/${orderId}`, { method: 'POST', token });
+    /** DetachPortalMethod is DetachMethod at the address a hosted checkout addresses it by. */
+    deleteBillingPortalMethodsById(id, opts = {}) {
+        return this.request('DELETE', `/v1/billing/portal/methods/${encodeURIComponent(id)}`, opts);
     }
-    async capture(orderId, token) {
-        return this.request(`/v1/capture/${orderId}`, { method: 'POST', token });
+    /** Reads the caller's auto-reload rule: top the balance up by `amountCents` whenever it falls below `thresholdCents`, charging the card on file off-session. */
+    getBillingRecharge(opts = {}) {
+        return this.request('GET', `/v1/billing/recharge`, opts);
     }
-    async charge(orderId, token) {
-        return this.request(`/v1/charge/${orderId}`, { method: 'POST', token });
+    /** Sets the caller's auto-reload rule, and answers with the rule as stored. */
+    putBillingRecharge(opts = {}) {
+        return this.request('PUT', `/v1/billing/recharge`, opts);
     }
-    async refund(paymentId, token) {
-        return this.request(`/v1/refund/${paymentId}`, { method: 'POST', token });
+    /** Sweeps every org's auto-recharge and answers what it did. */
+    postBillingRechargeRunAll(opts = {}) {
+        return this.request('POST', `/v1/billing/recharge/run-all`, opts);
     }
-    async billingRefund(params, token) {
-        return this.request('/v1/billing/refund', {
-            method: 'POST', body: params, token,
-        });
+    /** Answers the PUBLIC half of this org's processor configuration — the ids a browser needs to tokenize a card, and the environment it must tokenize against. */
+    getBillingSettings(opts = {}) {
+        return this.request('GET', `/v1/billing/settings`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Crypto wallet deposit address
-    // -----------------------------------------------------------------------
-    /**
-     * Get or create a deposit address for a given chain.
-     * Used for crypto top-up — user sends funds to this address.
-     */
-    async getWalletAddress(params, token) {
-        return this.request('/api/wallet/account', {
-            method: 'POST',
-            body: { name: `${params.userId}-${params.chain}`, blockchainType: params.chain },
-            token,
-        });
+    /** Buy a plan with a card */
+    postBillingSubscribeCard(opts = {}) {
+        return this.request('POST', `/v1/billing/subscribe/card`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Bank account (ACH) and crypto payment methods
-    // -----------------------------------------------------------------------
-    /**
-     * Add a bank account payment method (ACH).
-     * plaidToken from Plaid Link or Square bank OAuth.
-     */
-    async addBankAccount(params, token) {
-        return this.request('/v1/billing/methods', {
-            method: 'POST',
-            body: { customerId: params.customerId, type: 'bank_account', plaidToken: params.plaidToken, bankName: params.bankName, accountType: params.accountType },
-            token,
-        });
+    /** Lists the plans the caller holds, with the count beside them. */
+    getBillingSubscriptions(opts = {}) {
+        return this.request('GET', `/v1/billing/subscriptions`, opts);
     }
-    async addCryptoWallet(params, token) {
-        return this.request('/v1/billing/methods', {
-            method: 'POST',
-            body: { customerId: params.customerId, type: 'crypto', chain: params.chain, address: params.address, label: params.label },
-            token,
-        });
+    /** End a subscription */
+    cancelSubscription(id, opts = {}) {
+        return this.request('POST', `/v1/billing/subscriptions/${encodeURIComponent(id)}/cancel`, opts);
     }
-    // -----------------------------------------------------------------------
-    // Top-up
-    // -----------------------------------------------------------------------
-    /**
-     * Convenience: charge a saved payment method and deposit credits.
-     * amount is in cents.
-     */
-    async topup(params, token) {
-        return this.request('/v1/billing/topup', {
-            method: 'POST',
-            body: params,
-            token,
-        });
+    /** Put a canceled subscription back on its plan */
+    reactivateSubscription(id, opts = {}) {
+        return this.request('POST', `/v1/billing/subscriptions/${encodeURIComponent(id)}/reactivate`, opts);
+    }
+    /** Answers which tier the caller is on, what it allows, and what is left to spend. */
+    getBillingTier(opts = {}) {
+        return this.request('GET', `/v1/billing/tier`, opts);
+    }
+    /** Charges a card the caller already saved and credits the balance. */
+    postBillingTopup(opts = {}) {
+        return this.request('POST', `/v1/billing/topup`, opts);
+    }
+    /** Charges a single-use card token and credits the caller's balance. */
+    postBillingTopupToken(opts = {}) {
+        return this.request('POST', `/v1/billing/topup/token`, opts);
+    }
+    /** Answers one page of the caller's own ledger, newest first: what moved, how much, when, and what it was tagged with. */
+    getBillingTransactions(opts = {}) {
+        return this.request('GET', `/v1/billing/transactions`, opts);
+    }
+    /** Reads one ledger entry by its id. */
+    getBillingTransactionsById(id, opts = {}) {
+        return this.request('GET', `/v1/billing/transactions/${encodeURIComponent(id)}`, opts);
+    }
+    /** Every billed call the caller's org made, attributed to a product */
+    getBillingUsage(opts = {}) {
+        return this.request('GET', `/v1/billing/usage`, opts);
+    }
+    /** Answers per-account totals for the linked provider accounts the gateway ROUTED this caller's traffic through — requests, prompt and completion tokens, recorded cost — plus their honest sum. */
+    getBillingUsageAccounts(opts = {}) {
+        return this.request('GET', `/v1/billing/usage/accounts`, opts);
+    }
+    /** Answers the caller's month: what their plan includes, what has been consumed against it, and the wallet beside it. */
+    getBillingUsageRollup(opts = {}) {
+        return this.request('GET', `/v1/billing/usage/rollup`, opts);
+    }
+    /** Answers where to send a wire top-up: the receiving bank details, with the caller's own payment reference. */
+    getBillingWire(opts = {}) {
+        return this.request('GET', `/v1/billing/wire`, opts);
+    }
+    /** The catalog projection with cost and margin included */
+    getCommerceAdminCatalog(opts = {}) {
+        return this.request('GET', `/v1/commerce/admin/catalog`, opts);
+    }
+    /** Open a cart for a shopper to fill */
+    openCart(opts = {}) {
+        return this.request('POST', `/v1/commerce/cart`, opts);
+    }
+    /** Read one cart with its lines and totals */
+    getCart(id, opts = {}) {
+        return this.request('GET', `/v1/commerce/cart/${encodeURIComponent(id)}`, opts);
+    }
+    /** Discard a cart the shopper abandoned */
+    discardCart(id, opts = {}) {
+        return this.request('POST', `/v1/commerce/cart/${encodeURIComponent(id)}/discard`, opts);
+    }
+    /** Set one item's quantity in a cart; zero removes it */
+    setCartItem(id, opts = {}) {
+        return this.request('POST', `/v1/commerce/cart/${encodeURIComponent(id)}/item`, opts);
+    }
+    /** The public product catalog projection for a brand */
+    getCommerceCatalog(opts = {}) {
+        return this.request('GET', `/v1/commerce/catalog`, opts);
+    }
+    /** The raw catalog entries, including the unpublished ones */
+    getCommerceCatalogEntries(opts = {}) {
+        return this.request('GET', `/v1/commerce/catalog/entries`, opts);
+    }
+    /** Add a catalog entry */
+    postCommerceCatalogEntries(opts = {}) {
+        return this.request('POST', `/v1/commerce/catalog/entries`, opts);
+    }
+    /** Land a syncer's view of the model catalog: upstream costs and machine facts */
+    postCommerceCatalogModels(opts = {}) {
+        return this.request('POST', `/v1/commerce/catalog/models`, opts);
+    }
+    /** Refresh the model catalog by reading the upstream provider */
+    postCommerceCatalogModelsRefresh(opts = {}) {
+        return this.request('POST', `/v1/commerce/catalog/models/refresh`, opts);
+    }
+    /** Seed the embedded catalog, without disturbing edits already made */
+    postCommerceCatalogSeed(opts = {}) {
+        return this.request('POST', `/v1/commerce/catalog/seed`, opts);
+    }
+    /** List your org's collections, as a page */
+    getCommerceCollection(opts = {}) {
+        return this.request('GET', `/v1/commerce/collection/`, opts);
+    }
+    /** Create a collection */
+    postCommerceCollection(opts = {}) {
+        return this.request('POST', `/v1/commerce/collection/`, opts);
+    }
+    /** Delete a collection, keeping a recoverable copy */
+    deleteCommerceCollectionByCollectionid(collectionid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/collection/${encodeURIComponent(collectionid)}`, opts);
+    }
+    /** Fetch one collection */
+    getCommerceCollectionByCollectionid(collectionid, opts = {}) {
+        return this.request('GET', `/v1/commerce/collection/${encodeURIComponent(collectionid)}`, opts);
+    }
+    /** Change part of a collection */
+    patchCommerceCollectionByCollectionid(collectionid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/collection/${encodeURIComponent(collectionid)}`, opts);
+    }
+    /** Method-override tunnel for a collection — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceCollectionByCollectionid(collectionid, opts = {}) {
+        return this.request('POST', `/v1/commerce/collection/${encodeURIComponent(collectionid)}`, opts);
+    }
+    /** Replace a collection outright */
+    putCommerceCollectionByCollectionid(collectionid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/collection/${encodeURIComponent(collectionid)}`, opts);
+    }
+    /** The reference currency list the price and settings pickers render */
+    getCommerceCurrencies(opts = {}) {
+        return this.request('GET', `/v1/commerce/currencies`, opts);
+    }
+    /** Read the crypto deposit watcher's runtime state, asset by asset */
+    getCommerceDeposits(opts = {}) {
+        return this.request('GET', `/v1/commerce/deposits`, opts);
+    }
+    /** List your org's disclosures, as a page */
+    getCommerceDisclosure(opts = {}) {
+        return this.request('GET', `/v1/commerce/disclosure/`, opts);
+    }
+    /** Create a disclosure */
+    postCommerceDisclosure(opts = {}) {
+        return this.request('POST', `/v1/commerce/disclosure/`, opts);
+    }
+    /** Delete a disclosure, keeping a recoverable copy */
+    deleteCommerceDisclosureByDisclosureid(disclosureid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/disclosure/${encodeURIComponent(disclosureid)}`, opts);
+    }
+    /** Fetch one disclosure */
+    getCommerceDisclosureByDisclosureid(disclosureid, opts = {}) {
+        return this.request('GET', `/v1/commerce/disclosure/${encodeURIComponent(disclosureid)}`, opts);
+    }
+    /** Change part of a disclosure */
+    patchCommerceDisclosureByDisclosureid(disclosureid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/disclosure/${encodeURIComponent(disclosureid)}`, opts);
+    }
+    /** Method-override tunnel for a disclosure — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceDisclosureByDisclosureid(disclosureid, opts = {}) {
+        return this.request('POST', `/v1/commerce/disclosure/${encodeURIComponent(disclosureid)}`, opts);
+    }
+    /** Replace a disclosure outright */
+    putCommerceDisclosureByDisclosureid(disclosureid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/disclosure/${encodeURIComponent(disclosureid)}`, opts);
+    }
+    /** List your org's discounts, as a page */
+    getCommerceDiscount(opts = {}) {
+        return this.request('GET', `/v1/commerce/discount/`, opts);
+    }
+    /** Create a discount */
+    postCommerceDiscount(opts = {}) {
+        return this.request('POST', `/v1/commerce/discount/`, opts);
+    }
+    /** Delete a discount, keeping a recoverable copy */
+    deleteCommerceDiscountByDiscountid(discountid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/discount/${encodeURIComponent(discountid)}`, opts);
+    }
+    /** Fetch one discount */
+    getCommerceDiscountByDiscountid(discountid, opts = {}) {
+        return this.request('GET', `/v1/commerce/discount/${encodeURIComponent(discountid)}`, opts);
+    }
+    /** Change part of a discount */
+    patchCommerceDiscountByDiscountid(discountid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/discount/${encodeURIComponent(discountid)}`, opts);
+    }
+    /** Method-override tunnel for a discount — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceDiscountByDiscountid(discountid, opts = {}) {
+        return this.request('POST', `/v1/commerce/discount/${encodeURIComponent(discountid)}`, opts);
+    }
+    /** Replace a discount outright */
+    putCommerceDiscountByDiscountid(discountid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/discount/${encodeURIComponent(discountid)}`, opts);
+    }
+    /** Answers ok whenever the commerce subsystem is mounted. */
+    getCommerceHealth(opts = {}) {
+        return this.request('GET', `/v1/commerce/health`, opts);
+    }
+    /** List your org's movies, as a page */
+    getCommerceMovie(opts = {}) {
+        return this.request('GET', `/v1/commerce/movie/`, opts);
+    }
+    /** Create a movie */
+    postCommerceMovie(opts = {}) {
+        return this.request('POST', `/v1/commerce/movie/`, opts);
+    }
+    /** Delete a movie, keeping a recoverable copy */
+    deleteCommerceMovieByMovieid(movieid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/movie/${encodeURIComponent(movieid)}`, opts);
+    }
+    /** Fetch one movie */
+    getCommerceMovieByMovieid(movieid, opts = {}) {
+        return this.request('GET', `/v1/commerce/movie/${encodeURIComponent(movieid)}`, opts);
+    }
+    /** Change part of a movie */
+    patchCommerceMovieByMovieid(movieid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/movie/${encodeURIComponent(movieid)}`, opts);
+    }
+    /** Method-override tunnel for a movie — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceMovieByMovieid(movieid, opts = {}) {
+        return this.request('POST', `/v1/commerce/movie/${encodeURIComponent(movieid)}`, opts);
+    }
+    /** Replace a movie outright */
+    putCommerceMovieByMovieid(movieid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/movie/${encodeURIComponent(movieid)}`, opts);
+    }
+    /** List your org's notes, as a page */
+    getCommerceNote(opts = {}) {
+        return this.request('GET', `/v1/commerce/note/`, opts);
+    }
+    /** Create a note */
+    postCommerceNote(opts = {}) {
+        return this.request('POST', `/v1/commerce/note/`, opts);
+    }
+    /** Delete a note, keeping a recoverable copy */
+    deleteCommerceNoteByNoteid(noteid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/note/${encodeURIComponent(noteid)}`, opts);
+    }
+    /** Fetch one note */
+    getCommerceNoteByNoteid(noteid, opts = {}) {
+        return this.request('GET', `/v1/commerce/note/${encodeURIComponent(noteid)}`, opts);
+    }
+    /** Change part of a note */
+    patchCommerceNoteByNoteid(noteid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/note/${encodeURIComponent(noteid)}`, opts);
+    }
+    /** Method-override tunnel for a note — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceNoteByNoteid(noteid, opts = {}) {
+        return this.request('POST', `/v1/commerce/note/${encodeURIComponent(noteid)}`, opts);
+    }
+    /** Replace a note outright */
+    putCommerceNoteByNoteid(noteid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/note/${encodeURIComponent(noteid)}`, opts);
+    }
+    /** The public org configuration a checkout page boots from */
+    getCommerceOrg(opts = {}) {
+        return this.request('GET', `/v1/commerce/org`, opts);
+    }
+    /** The raw plan authority rows */
+    getCommercePlansEntries(opts = {}) {
+        return this.request('GET', `/v1/commerce/plans/entries`, opts);
+    }
+    /** Add a subscription plan */
+    postCommercePlansEntries(opts = {}) {
+        return this.request('POST', `/v1/commerce/plans/entries`, opts);
+    }
+    /** Remove a plan from the authority */
+    deleteCommercePlansEntriesBySlug(slug, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/plans/entries/${encodeURIComponent(slug)}`, opts);
+    }
+    /** Edit a plan, leaving the fields you omit alone */
+    putCommercePlansEntriesBySlug(slug, opts = {}) {
+        return this.request('PUT', `/v1/commerce/plans/entries/${encodeURIComponent(slug)}`, opts);
+    }
+    /** Seed the embedded plan catalog, without overwriting administrative edits */
+    postCommercePlansSeed(opts = {}) {
+        return this.request('POST', `/v1/commerce/plans/seed`, opts);
+    }
+    /** List your org's products, as a page */
+    getCommerceProduct(opts = {}) {
+        return this.request('GET', `/v1/commerce/product/`, opts);
+    }
+    /** Create a product */
+    postCommerceProduct(opts = {}) {
+        return this.request('POST', `/v1/commerce/product/`, opts);
+    }
+    /** Delete a product, keeping a recoverable copy */
+    deleteCommerceProductByProductid(productid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/product/${encodeURIComponent(productid)}`, opts);
+    }
+    /** Fetch one product */
+    getCommerceProductByProductid(productid, opts = {}) {
+        return this.request('GET', `/v1/commerce/product/${encodeURIComponent(productid)}`, opts);
+    }
+    /** Change part of a product */
+    patchCommerceProductByProductid(productid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/product/${encodeURIComponent(productid)}`, opts);
+    }
+    /** Method-override tunnel for a product — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceProductByProductid(productid, opts = {}) {
+        return this.request('POST', `/v1/commerce/product/${encodeURIComponent(productid)}`, opts);
+    }
+    /** Replace a product outright */
+    putCommerceProductByProductid(productid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/product/${encodeURIComponent(productid)}`, opts);
+    }
+    /** List what one unit of each metered thing costs */
+    getCommerceRatesEntries(opts = {}) {
+        return this.request('GET', `/v1/commerce/rates/entries`, opts);
+    }
+    /** Add a rate */
+    postCommerceRatesEntries(opts = {}) {
+        return this.request('POST', `/v1/commerce/rates/entries`, opts);
+    }
+    /** Remove a rate outright */
+    deleteCommerceRatesEntriesByProductByMeter(product, meter, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/rates/entries/${encodeURIComponent(product)}/${encodeURIComponent(meter)}`, opts);
+    }
+    /** Edit a rate, and mark it as operator-set */
+    putCommerceRatesEntriesByProductByMeter(product, meter, opts = {}) {
+        return this.request('PUT', `/v1/commerce/rates/entries/${encodeURIComponent(product)}/${encodeURIComponent(meter)}`, opts);
+    }
+    /** Load the published price document, reconciling rather than replacing */
+    postCommerceRatesImport(opts = {}) {
+        return this.request('POST', `/v1/commerce/rates/import`, opts);
+    }
+    /** List your org's returns, as a page */
+    getCommerceReturn(opts = {}) {
+        return this.request('GET', `/v1/commerce/return/`, opts);
+    }
+    /** Create a return */
+    postCommerceReturn(opts = {}) {
+        return this.request('POST', `/v1/commerce/return/`, opts);
+    }
+    /** Delete a return, keeping a recoverable copy */
+    deleteCommerceReturnByReturnid(returnid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/return/${encodeURIComponent(returnid)}`, opts);
+    }
+    /** Fetch one return */
+    getCommerceReturnByReturnid(returnid, opts = {}) {
+        return this.request('GET', `/v1/commerce/return/${encodeURIComponent(returnid)}`, opts);
+    }
+    /** Change part of a return */
+    patchCommerceReturnByReturnid(returnid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/return/${encodeURIComponent(returnid)}`, opts);
+    }
+    /** Method-override tunnel for a return — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceReturnByReturnid(returnid, opts = {}) {
+        return this.request('POST', `/v1/commerce/return/${encodeURIComponent(returnid)}`, opts);
+    }
+    /** Replace a return outright */
+    putCommerceReturnByReturnid(returnid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/return/${encodeURIComponent(returnid)}`, opts);
+    }
+    /** List your org's sales channels, as a page */
+    getCommerceSaleschannel(opts = {}) {
+        return this.request('GET', `/v1/commerce/saleschannel/`, opts);
+    }
+    /** Create a sales channel */
+    postCommerceSaleschannel(opts = {}) {
+        return this.request('POST', `/v1/commerce/saleschannel/`, opts);
+    }
+    /** Delete a sales channel, keeping a recoverable copy */
+    deleteCommerceSaleschannelBySaleschannelid(saleschannelid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/saleschannel/${encodeURIComponent(saleschannelid)}`, opts);
+    }
+    /** Fetch one sales channel */
+    getCommerceSaleschannelBySaleschannelid(saleschannelid, opts = {}) {
+        return this.request('GET', `/v1/commerce/saleschannel/${encodeURIComponent(saleschannelid)}`, opts);
+    }
+    /** Change part of a sales channel */
+    patchCommerceSaleschannelBySaleschannelid(saleschannelid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/saleschannel/${encodeURIComponent(saleschannelid)}`, opts);
+    }
+    /** Method-override tunnel for a sales channel — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceSaleschannelBySaleschannelid(saleschannelid, opts = {}) {
+        return this.request('POST', `/v1/commerce/saleschannel/${encodeURIComponent(saleschannelid)}`, opts);
+    }
+    /** Replace a sales channel outright */
+    putCommerceSaleschannelBySaleschannelid(saleschannelid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/saleschannel/${encodeURIComponent(saleschannelid)}`, opts);
+    }
+    /** List your org's stock locations, as a page */
+    getCommerceStocklocation(opts = {}) {
+        return this.request('GET', `/v1/commerce/stocklocation/`, opts);
+    }
+    /** Create a stock location */
+    postCommerceStocklocation(opts = {}) {
+        return this.request('POST', `/v1/commerce/stocklocation/`, opts);
+    }
+    /** Delete a stock location, keeping a recoverable copy */
+    deleteCommerceStocklocationByStocklocationid(stocklocationid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/stocklocation/${encodeURIComponent(stocklocationid)}`, opts);
+    }
+    /** Fetch one stock location */
+    getCommerceStocklocationByStocklocationid(stocklocationid, opts = {}) {
+        return this.request('GET', `/v1/commerce/stocklocation/${encodeURIComponent(stocklocationid)}`, opts);
+    }
+    /** Change part of a stock location */
+    patchCommerceStocklocationByStocklocationid(stocklocationid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/stocklocation/${encodeURIComponent(stocklocationid)}`, opts);
+    }
+    /** Method-override tunnel for a stock location — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceStocklocationByStocklocationid(stocklocationid, opts = {}) {
+        return this.request('POST', `/v1/commerce/stocklocation/${encodeURIComponent(stocklocationid)}`, opts);
+    }
+    /** Replace a stock location outright */
+    putCommerceStocklocationByStocklocationid(stocklocationid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/stocklocation/${encodeURIComponent(stocklocationid)}`, opts);
+    }
+    /** List your org's storefronts as a page */
+    getCommerceStore(opts = {}) {
+        return this.request('GET', `/v1/commerce/store/`, opts);
+    }
+    /** Create a storefront */
+    postCommerceStore(opts = {}) {
+        return this.request('POST', `/v1/commerce/store/`, opts);
+    }
+    /** Whether a store is entitled to trade, and why */
+    getCommerceStoreAccess(opts = {}) {
+        return this.request('GET', `/v1/commerce/store/access`, opts);
+    }
+    /** Resolve your org's active storefront without naming an id */
+    getCommerceStoreCurrent(opts = {}) {
+        return this.request('GET', `/v1/commerce/store/current`, opts);
+    }
+    /** Mint your org's least-privilege storefront read key */
+    postCommerceStoreToken(opts = {}) {
+        return this.request('POST', `/v1/commerce/store/token`, opts);
+    }
+    /** Delete a storefront, keeping a recoverable copy */
+    deleteCommerceStoreByStoreid(storeid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/store/${encodeURIComponent(storeid)}`, opts);
+    }
+    /** Fetch one storefront */
+    getCommerceStoreByStoreid(storeid, opts = {}) {
+        return this.request('GET', `/v1/commerce/store/${encodeURIComponent(storeid)}`, opts);
+    }
+    /** Change part of a storefront */
+    patchCommerceStoreByStoreid(storeid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/store/${encodeURIComponent(storeid)}`, opts);
+    }
+    /** Method-override tunnel for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceStoreByStoreid(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}`, opts);
+    }
+    /** Replace a storefront outright */
+    putCommerceStoreByStoreid(storeid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/store/${encodeURIComponent(storeid)}`, opts);
+    }
+    /** Authorize a new order against a storefront, holding the funds without settling them */
+    postCommerceStoreByStoreidAuthorize(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/authorize`, opts);
+    }
+    /** Authorize an order that already exists, holding the funds without settling them */
+    postCommerceStoreByStoreidAuthorizeByOrderid(storeid, orderid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/authorize/${encodeURIComponent(orderid)}`, opts);
+    }
+    /** Fetch a bundle as this storefront sells it */
+    getCommerceStoreByStoreidBundleByKey(storeid, key, opts = {}) {
+        return this.request('GET', `/v1/commerce/store/${encodeURIComponent(storeid)}/bundle/${encodeURIComponent(key)}`, opts);
+    }
+    /** Capture a previously authorized order and settle the payment */
+    postCommerceStoreByStoreidCaptureByOrderid(storeid, orderid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/capture/${encodeURIComponent(orderid)}`, opts);
+    }
+    /** Authorize and capture a new order in one call */
+    postCommerceStoreByStoreidCharge(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/charge`, opts);
+    }
+    /** Authorize a new order against a storefront, holding the funds — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutAuthorize(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/authorize`, opts);
+    }
+    /** Authorize an existing order, holding the funds — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutAuthorizeByOrderid(storeid, orderid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/authorize/${encodeURIComponent(orderid)}`, opts);
+    }
+    /** Capture a previously authorized order and settle it — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutCaptureByOrderid(storeid, orderid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/capture/${encodeURIComponent(orderid)}`, opts);
+    }
+    /** Authorize and capture a new order in one call — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutCharge(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/charge`, opts);
+    }
+    /** PayPal cancel by pay key — refuses, exactly as the unprefixed address does */
+    postCommerceStoreByStoreidCheckoutPaypalCancelByPaykey(storeid, payKey, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/paypal/cancel/${encodeURIComponent(payKey)}`, opts);
+    }
+    /** PayPal confirm by pay key — refuses, exactly as the unprefixed address does */
+    postCommerceStoreByStoreidCheckoutPaypalConfirmByPaykey(storeid, payKey, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/paypal/confirm/${encodeURIComponent(payKey)}`, opts);
+    }
+    /** Start a PayPal authorization for a new order — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutPaypalPay(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/checkout/paypal/pay`, opts);
+    }
+    /** The storefront's whole listing override map */
+    getCommerceStoreByStoreidListing(storeid, opts = {}) {
+        return this.request('GET', `/v1/commerce/store/${encodeURIComponent(storeid)}/listing`, opts);
+    }
+    /** Remove a listing override */
+    deleteCommerceStoreByStoreidListingByKey(storeid, key, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/store/${encodeURIComponent(storeid)}/listing/${encodeURIComponent(key)}`, opts);
+    }
+    /** Fetch one listing override, by item id or by its slug or SKU */
+    getCommerceStoreByStoreidListingByKey(storeid, key, opts = {}) {
+        return this.request('GET', `/v1/commerce/store/${encodeURIComponent(storeid)}/listing/${encodeURIComponent(key)}`, opts);
+    }
+    /** Confirm a listing override exists and re-save the store */
+    patchCommerceStoreByStoreidListingByKey(storeid, key, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/store/${encodeURIComponent(storeid)}/listing/${encodeURIComponent(key)}`, opts);
+    }
+    /** Add a listing override under a new key */
+    postCommerceStoreByStoreidListingByKey(storeid, key, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/listing/${encodeURIComponent(key)}`, opts);
+    }
+    /** Upsert a listing override */
+    putCommerceStoreByStoreidListingByKey(storeid, key, opts = {}) {
+        return this.request('PUT', `/v1/commerce/store/${encodeURIComponent(storeid)}/listing/${encodeURIComponent(key)}`, opts);
+    }
+    /** PayPal cancel by pay key — refuses, because a pay key alone does not identify the order */
+    postCommerceStoreByStoreidPaypalCancelByPaykey(storeid, payKey, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/paypal/cancel/${encodeURIComponent(payKey)}`, opts);
+    }
+    /** PayPal confirm by pay key — refuses, because a pay key alone does not identify the order */
+    postCommerceStoreByStoreidPaypalConfirmByPaykey(storeid, payKey, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/paypal/confirm/${encodeURIComponent(payKey)}`, opts);
+    }
+    /** Start a PayPal authorization for a new order */
+    postCommerceStoreByStoreidPaypalPay(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/paypal/pay`, opts);
+    }
+    /** Fetch a product as this storefront sells it */
+    getCommerceStoreByStoreidProductByKey(storeid, key, opts = {}) {
+        return this.request('GET', `/v1/commerce/store/${encodeURIComponent(storeid)}/product/${encodeURIComponent(key)}`, opts);
+    }
+    /** Start this store's no-card trial on the entry plan */
+    postCommerceStoreByStoreidTrial(storeid, opts = {}) {
+        return this.request('POST', `/v1/commerce/store/${encodeURIComponent(storeid)}/trial`, opts);
+    }
+    /** Fetch a variant as this storefront sells it */
+    getCommerceStoreByStoreidVariantByKey(storeid, key, opts = {}) {
+        return this.request('GET', `/v1/commerce/store/${encodeURIComponent(storeid)}/variant/${encodeURIComponent(key)}`, opts);
+    }
+    /** List your org's submissions, as a page */
+    getCommerceSubmission(opts = {}) {
+        return this.request('GET', `/v1/commerce/submission/`, opts);
+    }
+    /** Create a submission */
+    postCommerceSubmission(opts = {}) {
+        return this.request('POST', `/v1/commerce/submission/`, opts);
+    }
+    /** Delete a submission, keeping a recoverable copy */
+    deleteCommerceSubmissionBySubmissionid(submissionid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/submission/${encodeURIComponent(submissionid)}`, opts);
+    }
+    /** Fetch one submission */
+    getCommerceSubmissionBySubmissionid(submissionid, opts = {}) {
+        return this.request('GET', `/v1/commerce/submission/${encodeURIComponent(submissionid)}`, opts);
+    }
+    /** Change part of a submission */
+    patchCommerceSubmissionBySubmissionid(submissionid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/submission/${encodeURIComponent(submissionid)}`, opts);
+    }
+    /** Method-override tunnel for a submission — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceSubmissionBySubmissionid(submissionid, opts = {}) {
+        return this.request('POST', `/v1/commerce/submission/${encodeURIComponent(submissionid)}`, opts);
+    }
+    /** Replace a submission outright */
+    putCommerceSubmissionBySubmissionid(submissionid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/submission/${encodeURIComponent(submissionid)}`, opts);
+    }
+    /** List your org's subscribers, as a page */
+    getCommerceSubscriber(opts = {}) {
+        return this.request('GET', `/v1/commerce/subscriber/`, opts);
+    }
+    /** Create a subscriber */
+    postCommerceSubscriber(opts = {}) {
+        return this.request('POST', `/v1/commerce/subscriber/`, opts);
+    }
+    /** Delete a subscriber, keeping a recoverable copy */
+    deleteCommerceSubscriberBySubscriberid(subscriberid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/subscriber/${encodeURIComponent(subscriberid)}`, opts);
+    }
+    /** Fetch one subscriber */
+    getCommerceSubscriberBySubscriberid(subscriberid, opts = {}) {
+        return this.request('GET', `/v1/commerce/subscriber/${encodeURIComponent(subscriberid)}`, opts);
+    }
+    /** Change part of a subscriber */
+    patchCommerceSubscriberBySubscriberid(subscriberid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/subscriber/${encodeURIComponent(subscriberid)}`, opts);
+    }
+    /** Method-override tunnel for a subscriber — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceSubscriberBySubscriberid(subscriberid, opts = {}) {
+        return this.request('POST', `/v1/commerce/subscriber/${encodeURIComponent(subscriberid)}`, opts);
+    }
+    /** Replace a subscriber outright */
+    putCommerceSubscriberBySubscriberid(subscriberid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/subscriber/${encodeURIComponent(subscriberid)}`, opts);
+    }
+    /** List your org's token transactions, as a page */
+    getCommerceTokentransaction(opts = {}) {
+        return this.request('GET', `/v1/commerce/tokentransaction/`, opts);
+    }
+    /** Create a token transaction */
+    postCommerceTokentransaction(opts = {}) {
+        return this.request('POST', `/v1/commerce/tokentransaction/`, opts);
+    }
+    /** Delete a token transaction, keeping a recoverable copy */
+    deleteCommerceTokentransactionByTokentransactionid(tokentransactionid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/tokentransaction/${encodeURIComponent(tokentransactionid)}`, opts);
+    }
+    /** Fetch one token transaction */
+    getCommerceTokentransactionByTokentransactionid(tokentransactionid, opts = {}) {
+        return this.request('GET', `/v1/commerce/tokentransaction/${encodeURIComponent(tokentransactionid)}`, opts);
+    }
+    /** Change part of a token transaction */
+    patchCommerceTokentransactionByTokentransactionid(tokentransactionid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/tokentransaction/${encodeURIComponent(tokentransactionid)}`, opts);
+    }
+    /** Method-override tunnel for a token transaction — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceTokentransactionByTokentransactionid(tokentransactionid, opts = {}) {
+        return this.request('POST', `/v1/commerce/tokentransaction/${encodeURIComponent(tokentransactionid)}`, opts);
+    }
+    /** Replace a token transaction outright */
+    putCommerceTokentransactionByTokentransactionid(tokentransactionid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/tokentransaction/${encodeURIComponent(tokentransactionid)}`, opts);
+    }
+    /** List your org's transfers, as a page */
+    getCommerceTransfer(opts = {}) {
+        return this.request('GET', `/v1/commerce/transfer/`, opts);
+    }
+    /** Create a transfer */
+    postCommerceTransfer(opts = {}) {
+        return this.request('POST', `/v1/commerce/transfer/`, opts);
+    }
+    /** Delete a transfer, keeping a recoverable copy */
+    deleteCommerceTransferByTransferid(transferid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/transfer/${encodeURIComponent(transferid)}`, opts);
+    }
+    /** Fetch one transfer */
+    getCommerceTransferByTransferid(transferid, opts = {}) {
+        return this.request('GET', `/v1/commerce/transfer/${encodeURIComponent(transferid)}`, opts);
+    }
+    /** Change part of a transfer */
+    patchCommerceTransferByTransferid(transferid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/transfer/${encodeURIComponent(transferid)}`, opts);
+    }
+    /** Method-override tunnel for a transfer — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceTransferByTransferid(transferid, opts = {}) {
+        return this.request('POST', `/v1/commerce/transfer/${encodeURIComponent(transferid)}`, opts);
+    }
+    /** Replace a transfer outright */
+    putCommerceTransferByTransferid(transferid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/transfer/${encodeURIComponent(transferid)}`, opts);
+    }
+    /** List your org's variants, as a page */
+    getCommerceVariant(opts = {}) {
+        return this.request('GET', `/v1/commerce/variant/`, opts);
+    }
+    /** Create a variant */
+    postCommerceVariant(opts = {}) {
+        return this.request('POST', `/v1/commerce/variant/`, opts);
+    }
+    /** Delete a variant, keeping a recoverable copy */
+    deleteCommerceVariantByVariantid(variantid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/variant/${encodeURIComponent(variantid)}`, opts);
+    }
+    /** Fetch one variant */
+    getCommerceVariantByVariantid(variantid, opts = {}) {
+        return this.request('GET', `/v1/commerce/variant/${encodeURIComponent(variantid)}`, opts);
+    }
+    /** Change part of a variant */
+    patchCommerceVariantByVariantid(variantid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/variant/${encodeURIComponent(variantid)}`, opts);
+    }
+    /** Method-override tunnel for a variant — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceVariantByVariantid(variantid, opts = {}) {
+        return this.request('POST', `/v1/commerce/variant/${encodeURIComponent(variantid)}`, opts);
+    }
+    /** Replace a variant outright */
+    putCommerceVariantByVariantid(variantid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/variant/${encodeURIComponent(variantid)}`, opts);
+    }
+    /** List your org's wallets, as a page */
+    getCommerceWallet(opts = {}) {
+        return this.request('GET', `/v1/commerce/wallet/`, opts);
+    }
+    /** Create a wallet */
+    postCommerceWallet(opts = {}) {
+        return this.request('POST', `/v1/commerce/wallet/`, opts);
+    }
+    /** Delete a wallet, keeping a recoverable copy */
+    deleteCommerceWalletByWalletid(walletid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/wallet/${encodeURIComponent(walletid)}`, opts);
+    }
+    /** Fetch one wallet */
+    getCommerceWalletByWalletid(walletid, opts = {}) {
+        return this.request('GET', `/v1/commerce/wallet/${encodeURIComponent(walletid)}`, opts);
+    }
+    /** Change part of a wallet */
+    patchCommerceWalletByWalletid(walletid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/wallet/${encodeURIComponent(walletid)}`, opts);
+    }
+    /** Method-override tunnel for a wallet — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceWalletByWalletid(walletid, opts = {}) {
+        return this.request('POST', `/v1/commerce/wallet/${encodeURIComponent(walletid)}`, opts);
+    }
+    /** Replace a wallet outright */
+    putCommerceWalletByWalletid(walletid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/wallet/${encodeURIComponent(walletid)}`, opts);
+    }
+    /** List your org's watchlists, as a page */
+    getCommerceWatchlist(opts = {}) {
+        return this.request('GET', `/v1/commerce/watchlist/`, opts);
+    }
+    /** Create a watchlist */
+    postCommerceWatchlist(opts = {}) {
+        return this.request('POST', `/v1/commerce/watchlist/`, opts);
+    }
+    /** Delete a watchlist, keeping a recoverable copy */
+    deleteCommerceWatchlistByWatchlistid(watchlistid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/watchlist/${encodeURIComponent(watchlistid)}`, opts);
+    }
+    /** Fetch one watchlist */
+    getCommerceWatchlistByWatchlistid(watchlistid, opts = {}) {
+        return this.request('GET', `/v1/commerce/watchlist/${encodeURIComponent(watchlistid)}`, opts);
+    }
+    /** Change part of a watchlist */
+    patchCommerceWatchlistByWatchlistid(watchlistid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/watchlist/${encodeURIComponent(watchlistid)}`, opts);
+    }
+    /** Method-override tunnel for a watchlist — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceWatchlistByWatchlistid(watchlistid, opts = {}) {
+        return this.request('POST', `/v1/commerce/watchlist/${encodeURIComponent(watchlistid)}`, opts);
+    }
+    /** Replace a watchlist outright */
+    putCommerceWatchlistByWatchlistid(watchlistid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/watchlist/${encodeURIComponent(watchlistid)}`, opts);
+    }
+    /** List your org's webhooks, as a page */
+    getCommerceWebhook(opts = {}) {
+        return this.request('GET', `/v1/commerce/webhook/`, opts);
+    }
+    /** Create a webhook */
+    postCommerceWebhook(opts = {}) {
+        return this.request('POST', `/v1/commerce/webhook/`, opts);
+    }
+    /** Delete a webhook, keeping a recoverable copy */
+    deleteCommerceWebhookByWebhookid(webhookid, opts = {}) {
+        return this.request('DELETE', `/v1/commerce/webhook/${encodeURIComponent(webhookid)}`, opts);
+    }
+    /** Fetch one webhook */
+    getCommerceWebhookByWebhookid(webhookid, opts = {}) {
+        return this.request('GET', `/v1/commerce/webhook/${encodeURIComponent(webhookid)}`, opts);
+    }
+    /** Change part of a webhook */
+    patchCommerceWebhookByWebhookid(webhookid, opts = {}) {
+        return this.request('PATCH', `/v1/commerce/webhook/${encodeURIComponent(webhookid)}`, opts);
+    }
+    /** Method-override tunnel for a webhook — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceWebhookByWebhookid(webhookid, opts = {}) {
+        return this.request('POST', `/v1/commerce/webhook/${encodeURIComponent(webhookid)}`, opts);
+    }
+    /** Replace a webhook outright */
+    putCommerceWebhookByWebhookid(webhookid, opts = {}) {
+        return this.request('PUT', `/v1/commerce/webhook/${encodeURIComponent(webhookid)}`, opts);
+    }
+    /** Payment-provider webhook intake for settlement and subscription lifecycle events */
+    postCommerceWebhooksByProvider(provider, opts = {}) {
+        return this.request('POST', `/v1/commerce/webhooks/${encodeURIComponent(provider)}`, opts);
     }
 }
-// ---------------------------------------------------------------------------
-// Standalone factory helpers — import these for quick setup
-// ---------------------------------------------------------------------------
+/** A body that is not JSON is still evidence; keep it rather than throwing. */
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+let shared;
 /**
- * Create a commerce client pre-configured for api.hanzo.ai.
- * Pass your IAM access token (read from localStorage or cookie).
+ * The process-wide client.
  *
- * @example
- * ```ts
- * import { hanzoCommerce } from '@hanzo/commerce/client'
- * const commerce = hanzoCommerce(localStorage.getItem('hanzo-auth-token') ?? undefined)
- * const plans = await commerce.getPlans()
- * ```
+ * One instance because the base url and the timeout are properties of the
+ * deployment, not of a call. Pass a token per call where the identity varies.
  */
-export function hanzoCommerce(token) {
-    return new Commerce({ token });
-}
-// ---------------------------------------------------------------------------
-// Error
-// ---------------------------------------------------------------------------
-export class CommerceApiError extends Error {
-    constructor(status, message) {
-        super(message);
-        this.name = 'CommerceApiError';
-        this.status = status;
-    }
+export function hanzoCommerce(config = {}) {
+    if (!shared)
+        shared = new Commerce(config);
+    return shared;
 }
 //# sourceMappingURL=client.js.map