@hanzo/commerce 7.8.3 → 7.9.1

package/dist/client.d.ts

@@ -1,432 +1,1276 @@
 /**
- * @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
- *
- * // Subscribe
- * const sub = await commerce.subscribe({ planId: 'pro', userId: 'user_xyz' })
- * ```
+ *   const commerce = new Commerce({ baseUrl: 'https://api.hanzo.ai', token })
+ *   const balance = await commerce.getBillingBalance()
  */
-export type CommerceClientConfig = {
-    /**
-     * Commerce API base URL.
-     * Defaults to https://api.hanzo.ai
-     */
+/** Where to reach the API, and as whom. */
+export interface CommerceClientConfig {
     baseUrl?: string;
-    /** @deprecated use baseUrl */
-    commerceUrl?: string;
-    /** IAM access token for authenticated requests. */
     token?: string;
-    /** Request timeout in milliseconds. Default 15 000. */
+    /** Milliseconds before a request is abandoned. Default 30s. */
     timeoutMs?: number;
-};
-export type Balance = {
-    balance: number;
-    holds: number;
-    available: number;
-};
+}
 /**
- * Tier-aware balance from GET /v1/billing/tier. effectiveAvailable folds the
- * tenant's included plan allotment (e.g. the free-tier daily credit) into the
- * prepaid available balance — gate on this to honor included usage first.
+ * A refusal, carrying what the service said about it.
+ *
+ * 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.
  */
-export type TierResponse = {
-    user: string;
-    tier: {
-        name: string;
-        displayName?: string;
-        maxAgents?: number;
-        unlimitedAgents?: boolean;
-        dailyCreditsCents?: number;
-        allowedModels?: string[];
-    };
-    balance: {
-        currency: string;
-        prepaidAvailable: number;
-        dailyRemaining: number;
-        effectiveAvailable: number;
-    };
-};
-export type Transaction = {
-    id?: string;
-    owner?: string;
-    type: 'hold' | 'hold-removed' | 'transfer' | 'deposit' | 'withdraw';
-    destinationId?: string;
-    destinationKind?: string;
-    sourceId?: string;
-    sourceKind?: string;
-    currency: string;
-    amount: number;
-    tags?: string[];
-    expiresAt?: string;
-    metadata?: Record<string, unknown>;
+export declare class CommerceApiError extends Error {
+    readonly status: number;
+    readonly detail: string;
+    readonly body: unknown;
+    constructor(status: number, detail: string, body: unknown);
+}
+export declare const DEFAULT_BASE_URL = "https://api.hanzo.ai";
+/** From the document. */
+export interface Transaction {
+    amount?: number;
     createdAt?: string;
-};
-export type Subscription = {
+    currency?: string;
+    expiresAt?: string;
     id?: string;
-    planId?: string;
-    userId?: string;
-    customerId?: string;
-    status?: 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid' | string;
-    billingType?: 'charge_automatically' | 'send_invoice';
-    periodStart?: string;
-    periodEnd?: string;
-    trialStart?: string;
-    trialEnd?: string;
-    quantity?: number;
-    createdAt?: string;
+    metadata?: unknown;
+    notes?: string;
+    tags?: string;
+    type?: string;
+}
+/** From the document. */
+export interface Subscription {
     cancelAtPeriodEnd?: boolean;
+    canceledAt?: string;
+    createdAt?: string;
     currentPeriodEnd?: string;
-};
-export type Plan = {
-    id?: string;
-    slug?: string;
-    name?: string;
-    description?: string;
-    price?: number;
-    priceMonthly?: number;
-    priceAnnual?: number;
-    currency?: string;
-    interval?: 'monthly' | 'yearly' | string;
-    intervalCount?: number;
-    trialPeriodDays?: number;
-    features?: string[];
-    popular?: boolean;
-    contactSales?: boolean;
-    metadata?: Record<string, unknown>;
-};
-export type Payment = {
+    currentPeriodStart?: string;
+    defaultPaymentMethod?: string;
+    endedAt?: string;
     id?: string;
-    orderId?: string;
+    mrrCents?: number;
+    plan?: SubscriptionPlan;
+    planId?: string;
+    providerType?: string;
+    quantity?: number;
+    status?: string;
+    trialEnd?: string;
+    trialStart?: string;
+    updatedAt?: string;
     userId?: string;
-    amount?: number;
-    amountRefunded?: number;
-    fee?: number;
-    currency?: string;
-    status?: 'cancelled' | 'credit' | 'disputed' | 'failed' | 'fraudulent' | 'paid' | 'refunded' | 'unpaid' | string;
-    captured?: boolean;
-    live?: boolean;
+}
+/** From the document. */
+export interface CreditGrant {
+    active?: boolean;
+    amountCents?: number;
     createdAt?: string;
-};
-export type UsageRecord = {
-    user: string;
     currency?: string;
-    amount: number;
-    model?: string;
-    provider?: string;
-    tokens?: number;
-    promptTokens?: number;
-    completionTokens?: number;
-};
-export type CouponType = 'Percent' | 'Flat' | 'FreeShipping' | 'FreeItem';
-export type Coupon = {
-    id?: string;
-    code: string;
-    type: CouponType;
-    /** Amount: percentage (0-100) for Percent, cents for Flat */
-    amount: number;
-    description?: string;
-    limit?: number;
-    used?: number;
-    startDate?: string;
-    endDate?: string;
-    enabled?: boolean;
-    /** Calculated discount in cents (returned by validateCoupon) */
-    discountCents?: number;
-};
-export type CouponValidateResult = {
-    valid: boolean;
-    coupon?: Coupon;
-    error?: string;
-    /** Discount in cents for a given subtotal */
-    discountCents?: number;
-};
-export type Discount = {
+    effectiveAt?: string;
+    expiresAt?: string;
     id?: string;
-    type: 'Percent' | 'Flat' | 'FreeShipping' | 'FreeItem' | 'Bulk';
-    amount: number;
-    scope?: 'Product' | 'Variant' | 'Collection' | 'Store';
-    enabled?: boolean;
-    startDate?: string;
-    endDate?: string;
-};
-export type CheckoutItem = {
-    id: string;
-    quantity?: number;
-    /** Price override in cents */
-    price?: number;
     name?: string;
-    description?: string;
-    imageUrl?: string;
-    metadata?: Record<string, unknown>;
-};
-export type CheckoutSessionRequest = {
-    items: CheckoutItem[];
-    successUrl: string;
-    cancelUrl: string;
-    couponCode?: string;
-    referrerId?: string;
-    affiliateId?: string;
-    currency?: string;
-    customer?: {
-        email?: string;
-        name?: string;
-        address?: string;
-        city?: string;
-        zip?: string;
-    };
-    metadata?: Record<string, unknown>;
-};
-export type CheckoutSessionResponse = {
-    checkoutUrl: string;
-    sessionId: string;
-    /** Original total in cents before discount */
-    originalTotal?: number;
-    /** Final total in cents after discount */
-    finalTotal?: number;
-    discount?: {
-        code: string;
-        type: CouponType;
-        amount: number;
-        discountCents: number;
-    };
-};
-export type PaymentMethodType = 'card' | 'bank_account' | 'balance' | 'crypto' | 'wire';
-export type PaymentMethod = {
-    id: string;
-    type: PaymentMethodType;
-    isDefault?: boolean;
-    customerId?: string;
-    card?: {
-        brand: string;
-        last4: string;
-        expMonth: number;
-        expYear: number;
-    };
-    bank_account?: {
-        bankName?: string;
-        last4?: string;
-        accountType?: 'checking' | 'savings';
-        routingNumber?: string;
-    };
-    crypto?: {
-        chain: string;
-        address: string;
-        label?: string;
-    };
-    providerRef?: string;
-    providerType?: string;
-    createdAt?: string;
-};
-export type Referral = {
-    id?: string;
-    userId?: string;
-    referrerId?: string;
-    affiliateId?: string;
-    orderId?: string;
-    fee?: number;
-    createdAt?: string;
-};
-export type Referrer = {
-    id?: string;
-    userId?: string;
-    enabled?: boolean;
-    code?: string;
-    referrals?: Referral[];
-};
-export type Affiliate = {
-    id?: string;
+    priority?: number;
+    remainingCents?: number;
+    tags?: string;
     userId?: string;
-    enabled?: boolean;
-    commission?: number;
-    couponId?: string;
-    connectUrl?: string;
-};
-export type CreditGrant = {
+    voided?: boolean;
+}
+/** From the document. */
+export interface SubscriptionPlan {
+    currency?: string;
     id?: string;
-    userId?: string;
-    amount: number;
-    currency: string;
-    expiresAt?: string;
-    tags?: string[];
-};
+    interval?: string;
+    name?: string;
+    price?: number;
+}
 export declare class Commerce {
     private readonly baseUrl;
     private token;
     private readonly timeoutMs;
     constructor(config?: CommerceClientConfig);
-    /** 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: string): void;
-    private request;
-    getBalance(user: string, currency?: string, token?: string, headers?: Record<string, string>): Promise<Balance>;
-    getAllBalances(user: string, token?: string): Promise<Record<string, Balance>>;
-    /**
-     * 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.
-     */
-    getTier(user: string, opts?: {
-        token?: string;
-        headers?: Record<string, string>;
-    }): Promise<TierResponse>;
-    addUsageRecord(record: UsageRecord, token?: string, headers?: Record<string, string>): Promise<Transaction>;
-    getUsageRecords(user: string, currency?: string, token?: string): Promise<Transaction[]>;
-    addDeposit(params: {
-        user: string;
-        currency?: string;
-        amount: number;
-        notes?: string;
-        tags?: string[];
-        expiresIn?: string;
-    }, token?: string): Promise<Transaction>;
-    grantStarterCredit(user: string, token?: string): Promise<Transaction>;
-    getPlans(token?: string): Promise<Plan[]>;
-    getPlan(planId: string, token?: string): Promise<Plan | null>;
-    subscribe(params: {
-        planId: string;
-        userId?: string;
-        customerId?: string;
-        paymentMethodId?: string;
-        couponCode?: string;
-        trialDays?: number;
-    }, token?: string): Promise<Subscription>;
-    getSubscription(subscriptionId: string, token?: string): Promise<Subscription | null>;
-    listSubscriptions(params?: {
-        customerId?: string;
-    }, token?: string): Promise<Subscription[]>;
-    updateSubscription(subscriptionId: string, update: Partial<Subscription>, token?: string): Promise<Subscription>;
-    cancelSubscription(subscriptionId: string, immediately?: boolean, token?: string): Promise<Subscription>;
-    reactivateSubscription(subscriptionId: string, token?: string): Promise<Subscription>;
-    /**
-     * Create a hosted checkout session.
-     * Returns a URL to redirect the customer to for payment.
-     * Supports coupons, referral tracking, and multiple currencies.
-     */
-    createCheckoutSession(params: CheckoutSessionRequest, token?: string): Promise<CheckoutSessionResponse>;
-    addPaymentMethod(params: {
-        customerId: string;
-        type: PaymentMethodType;
-        token?: string;
-        providerRef?: string;
-        providerType?: string;
-    }, token?: string): Promise<PaymentMethod>;
-    listPaymentMethods(customerId: string, token?: string): Promise<PaymentMethod[]>;
-    removePaymentMethod(paymentMethodId: string, token?: string): Promise<void>;
-    setDefaultPaymentMethod(customerId: string, paymentMethodId: string, token?: string): Promise<PaymentMethod>;
-    /**
-     * Validate a coupon code.
-     * Optionally pass a subtotalCents to get the calculated discount amount.
-     */
-    validateCoupon(code: string, subtotalCents?: number, token?: string): Promise<CouponValidateResult>;
-    /**
-     * Redeem a coupon for a user. Creates credit grant records.
-     */
-    redeemCoupon(code: string, userId: string, token?: string): Promise<CreditGrant[]>;
-    /**
-     * Get or create a referrer record for a user.
-     * Returns the referral code/link the user can share.
-     */
-    getOrCreateReferrer(userId: string, token?: string): Promise<Referrer>;
-    getReferrals(userId: string, token?: string): Promise<Referral[]>;
-    getReferrers(userId: string, token?: string): Promise<Referrer[]>;
-    /**
-     * Get affiliate details for a user.
-     */
-    getAffiliate(userId: string, token?: string): Promise<Affiliate | null>;
-    /**
-     * Create an affiliate account for a user.
-     * After creation, user can connect their bank via the returnedconnectUrl.
-     */
-    createAffiliate(userId: string, token?: string): Promise<Affiliate>;
-    getAffiliateReferrals(affiliateId: string, token?: string): Promise<Referral[]>;
-    getAffiliateOrders(affiliateId: string, token?: string): Promise<unknown[]>;
-    getAffiliateTransactions(affiliateId: string, token?: string): Promise<Transaction[]>;
-    authorize(orderId: string, token?: string): Promise<Payment>;
-    capture(orderId: string, token?: string): Promise<Payment>;
-    charge(orderId: string, token?: string): Promise<Payment>;
-    refund(paymentId: string, token?: string): Promise<Payment>;
-    billingRefund(params: {
-        user: string;
-        amount: number;
-        originalTransactionId: string;
-        currency?: string;
-        notes?: string;
-    }, token?: string): Promise<Transaction>;
-    /**
-     * Get or create a deposit address for a given chain.
-     * Used for crypto top-up — user sends funds to this address.
-     */
-    getWalletAddress(params: {
-        chain: string;
-        userId: string;
-    }, token?: string): Promise<{
-        address: string;
-        chain: string;
-        qrCode?: string;
-    }>;
-    /**
-     * Add a bank account payment method (ACH).
-     * plaidToken from Plaid Link or Square bank OAuth.
-     */
-    addBankAccount(params: {
-        customerId: string;
-        plaidToken?: string;
-        bankName?: string;
-        accountType?: 'checking' | 'savings';
-    }, token?: string): Promise<PaymentMethod>;
-    addCryptoWallet(params: {
-        customerId: string;
-        chain: string;
-        address: string;
-        label?: string;
-    }, token?: string): Promise<PaymentMethod>;
     /**
-     * Convenience: charge a saved payment method and deposit credits.
-     * amount is in cents.
+     * 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.
      */
-    topup(params: {
-        userId: string;
-        paymentMethodId: string;
-        amountCents: number;
-        currency?: string;
-    }, token?: string): Promise<Transaction>;
-}
-/**
- * Create a commerce client pre-configured for api.hanzo.ai.
- * Pass your IAM access token (read from localStorage or cookie).
- *
- * @example
- * ```ts
- * import { hanzoCommerce } from '@hanzo/commerce/client'
- * const commerce = hanzoCommerce(localStorage.getItem('hanzo-auth-token') ?? undefined)
- * const plans = await commerce.getPlans()
- * ```
- */
-export declare function hanzoCommerce(token?: string): Commerce;
-export declare class CommerceApiError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}
+    request<T>(method: string, path: string, opts?: {
+        query?: Record<string, string | number | boolean | undefined>;
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers the caller's billing accounts: the org itself, its currency, when it was opened, and the caller's own standing in it. */
+    getBillingAccounts<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers one billing account's roster. */
+    getBillingAccountsByIdMembers<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Lists this org's spend caps: the ceiling, its scope, whether it enforces, and how much of it has been spent this period. */
+    getBillingAlerts<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Opens a spend cap on the caller's own org. */
+    postBillingAlerts<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers whether one proposed spend fits inside this org's caps. */
+    getBillingAlertsAuthorize<T = unknown>(opts?: {
+        query?: Record<string, string | number | boolean | undefined>;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Removes one of the caller's spend caps and answers 204. */
+    deleteBillingAlertsById<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Changes one spend cap: raise or lower the ceiling, flip enforcement, retune the rate limit. */
+    patchBillingAlertsById<T = unknown>(id: string, opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Prepaid credit the caller's org can still spend */
+    getBillingBalance<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers what the caller can spend right now, one entry per currency. */
+    getBillingCreditBalance<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers that same spendable credit split by grant tag, with the earliest expiry under each and the total across all of them. */
+    getBillingCreditBalanceBreakdown<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Lists the caller's credit grants — every one of them, spent and lapsed and voided included. */
+    getBillingCredits<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Issues a deposit address the caller can send crypto to, on the asset they ask for. */
+    postBillingCryptoDeposit<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Reads one of the caller's own deposit intents back — pending, confirming, or succeeded. */
+    getBillingCryptoDepositById<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers which chains and tokens the crypto rail accepts — what an asset picker renders. */
+    getBillingCryptoOptions<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Lists the caller's invoices, newest first, with the count beside them. */
+    getBillingInvoices<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Raise a draft invoice against a customer */
+    raiseInvoice<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Read one invoice */
+    getInvoice<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Collect an issued invoice from credits, balance, then card */
+    collectInvoice<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Issue a draft invoice, making it collectible */
+    issueInvoice<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Download one invoice as a PDF */
+    getBillingInvoicesByIdPdf<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Void a draft or issued invoice */
+    voidInvoice<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** 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<T = unknown>(opts?: {
+        query?: Record<string, string | number | boolean | undefined>;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Cards and accounts on file for the caller */
+    getBillingMethods<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Save a card or account for the caller */
+    postBillingMethods<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Removes one card or account the caller has saved. */
+    deleteBillingMethodsById<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Moves this org between sandbox money and real money. */
+    postBillingMode<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers the org's outbound payouts, newest first — amount, destination, status, and the failure reason where one applies. */
+    getBillingPayouts<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The plan catalog, priced with whatever offer is in force */
+    getBillingPlans<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Cards and accounts on file for the caller */
+    getBillingPortalMethods<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Save a card or account for the caller */
+    postBillingPortalMethods<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** DetachPortalMethod is DetachMethod at the address a hosted checkout addresses it by. */
+    deleteBillingPortalMethodsById<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** 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<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Sets the caller's auto-reload rule, and answers with the rule as stored. */
+    putBillingRecharge<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Sweeps every org's auto-recharge and answers what it did. */
+    postBillingRechargeRunAll<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** 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<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Buy a plan with a card */
+    postBillingSubscribeCard<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Lists the plans the caller holds, with the count beside them. */
+    getBillingSubscriptions<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** End a subscription */
+    cancelSubscription<T = unknown>(id: string, opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Put a canceled subscription back on its plan */
+    reactivateSubscription<T = unknown>(id: string, opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers which tier the caller is on, what it allows, and what is left to spend. */
+    getBillingTier<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Charges a card the caller already saved and credits the balance. */
+    postBillingTopup<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Charges a single-use card token and credits the caller's balance. */
+    postBillingTopupToken<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers one page of the caller's own ledger, newest first: what moved, how much, when, and what it was tagged with. */
+    getBillingTransactions<T = unknown>(opts?: {
+        query?: Record<string, string | number | boolean | undefined>;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Reads one ledger entry by its id. */
+    getBillingTransactionsById<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Every billed call the caller's org made, attributed to a product */
+    getBillingUsage<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** 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<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers the caller's month: what their plan includes, what has been consumed against it, and the wallet beside it. */
+    getBillingUsageRollup<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers where to send a wire top-up: the receiving bank details, with the caller's own payment reference. */
+    getBillingWire<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The catalog projection with cost and margin included */
+    getCommerceAdminCatalog<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Open a cart for a shopper to fill */
+    openCart<T = unknown>(opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Read one cart with its lines and totals */
+    getCart<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Discard a cart the shopper abandoned */
+    discardCart<T = unknown>(id: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Set one item's quantity in a cart; zero removes it */
+    setCartItem<T = unknown>(id: string, opts?: {
+        body?: unknown;
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The public product catalog projection for a brand */
+    getCommerceCatalog<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The raw catalog entries, including the unpublished ones */
+    getCommerceCatalogEntries<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Add a catalog entry */
+    postCommerceCatalogEntries<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Land a syncer's view of the model catalog: upstream costs and machine facts */
+    postCommerceCatalogModels<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Refresh the model catalog by reading the upstream provider */
+    postCommerceCatalogModelsRefresh<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Seed the embedded catalog, without disturbing edits already made */
+    postCommerceCatalogSeed<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's collections, as a page */
+    getCommerceCollection<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a collection */
+    postCommerceCollection<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a collection, keeping a recoverable copy */
+    deleteCommerceCollectionByCollectionid<T = unknown>(collectionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one collection */
+    getCommerceCollectionByCollectionid<T = unknown>(collectionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a collection */
+    patchCommerceCollectionByCollectionid<T = unknown>(collectionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a collection — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceCollectionByCollectionid<T = unknown>(collectionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a collection outright */
+    putCommerceCollectionByCollectionid<T = unknown>(collectionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The reference currency list the price and settings pickers render */
+    getCommerceCurrencies<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Read the crypto deposit watcher's runtime state, asset by asset */
+    getCommerceDeposits<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's disclosures, as a page */
+    getCommerceDisclosure<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a disclosure */
+    postCommerceDisclosure<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a disclosure, keeping a recoverable copy */
+    deleteCommerceDisclosureByDisclosureid<T = unknown>(disclosureid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one disclosure */
+    getCommerceDisclosureByDisclosureid<T = unknown>(disclosureid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a disclosure */
+    patchCommerceDisclosureByDisclosureid<T = unknown>(disclosureid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a disclosure — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceDisclosureByDisclosureid<T = unknown>(disclosureid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a disclosure outright */
+    putCommerceDisclosureByDisclosureid<T = unknown>(disclosureid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's discounts, as a page */
+    getCommerceDiscount<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a discount */
+    postCommerceDiscount<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a discount, keeping a recoverable copy */
+    deleteCommerceDiscountByDiscountid<T = unknown>(discountid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one discount */
+    getCommerceDiscountByDiscountid<T = unknown>(discountid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a discount */
+    patchCommerceDiscountByDiscountid<T = unknown>(discountid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a discount — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceDiscountByDiscountid<T = unknown>(discountid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a discount outright */
+    putCommerceDiscountByDiscountid<T = unknown>(discountid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Answers ok whenever the commerce subsystem is mounted. */
+    getCommerceHealth<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's movies, as a page */
+    getCommerceMovie<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a movie */
+    postCommerceMovie<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a movie, keeping a recoverable copy */
+    deleteCommerceMovieByMovieid<T = unknown>(movieid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one movie */
+    getCommerceMovieByMovieid<T = unknown>(movieid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a movie */
+    patchCommerceMovieByMovieid<T = unknown>(movieid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a movie — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceMovieByMovieid<T = unknown>(movieid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a movie outright */
+    putCommerceMovieByMovieid<T = unknown>(movieid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's notes, as a page */
+    getCommerceNote<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a note */
+    postCommerceNote<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a note, keeping a recoverable copy */
+    deleteCommerceNoteByNoteid<T = unknown>(noteid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one note */
+    getCommerceNoteByNoteid<T = unknown>(noteid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a note */
+    patchCommerceNoteByNoteid<T = unknown>(noteid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a note — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceNoteByNoteid<T = unknown>(noteid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a note outright */
+    putCommerceNoteByNoteid<T = unknown>(noteid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The public org configuration a checkout page boots from */
+    getCommerceOrg<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The raw plan authority rows */
+    getCommercePlansEntries<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Add a subscription plan */
+    postCommercePlansEntries<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Remove a plan from the authority */
+    deleteCommercePlansEntriesBySlug<T = unknown>(slug: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Edit a plan, leaving the fields you omit alone */
+    putCommercePlansEntriesBySlug<T = unknown>(slug: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Seed the embedded plan catalog, without overwriting administrative edits */
+    postCommercePlansSeed<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's products, as a page */
+    getCommerceProduct<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a product */
+    postCommerceProduct<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a product, keeping a recoverable copy */
+    deleteCommerceProductByProductid<T = unknown>(productid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one product */
+    getCommerceProductByProductid<T = unknown>(productid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a product */
+    patchCommerceProductByProductid<T = unknown>(productid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a product — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceProductByProductid<T = unknown>(productid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a product outright */
+    putCommerceProductByProductid<T = unknown>(productid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List what one unit of each metered thing costs */
+    getCommerceRatesEntries<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Add a rate */
+    postCommerceRatesEntries<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Remove a rate outright */
+    deleteCommerceRatesEntriesByProductByMeter<T = unknown>(product: string, meter: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Edit a rate, and mark it as operator-set */
+    putCommerceRatesEntriesByProductByMeter<T = unknown>(product: string, meter: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Load the published price document, reconciling rather than replacing */
+    postCommerceRatesImport<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's returns, as a page */
+    getCommerceReturn<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a return */
+    postCommerceReturn<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a return, keeping a recoverable copy */
+    deleteCommerceReturnByReturnid<T = unknown>(returnid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one return */
+    getCommerceReturnByReturnid<T = unknown>(returnid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a return */
+    patchCommerceReturnByReturnid<T = unknown>(returnid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a return — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceReturnByReturnid<T = unknown>(returnid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a return outright */
+    putCommerceReturnByReturnid<T = unknown>(returnid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's sales channels, as a page */
+    getCommerceSaleschannel<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a sales channel */
+    postCommerceSaleschannel<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a sales channel, keeping a recoverable copy */
+    deleteCommerceSaleschannelBySaleschannelid<T = unknown>(saleschannelid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one sales channel */
+    getCommerceSaleschannelBySaleschannelid<T = unknown>(saleschannelid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a sales channel */
+    patchCommerceSaleschannelBySaleschannelid<T = unknown>(saleschannelid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a sales channel — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceSaleschannelBySaleschannelid<T = unknown>(saleschannelid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a sales channel outright */
+    putCommerceSaleschannelBySaleschannelid<T = unknown>(saleschannelid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's stock locations, as a page */
+    getCommerceStocklocation<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a stock location */
+    postCommerceStocklocation<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a stock location, keeping a recoverable copy */
+    deleteCommerceStocklocationByStocklocationid<T = unknown>(stocklocationid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one stock location */
+    getCommerceStocklocationByStocklocationid<T = unknown>(stocklocationid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a stock location */
+    patchCommerceStocklocationByStocklocationid<T = unknown>(stocklocationid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a stock location — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceStocklocationByStocklocationid<T = unknown>(stocklocationid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a stock location outright */
+    putCommerceStocklocationByStocklocationid<T = unknown>(stocklocationid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's storefronts as a page */
+    getCommerceStore<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a storefront */
+    postCommerceStore<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Whether a store is entitled to trade, and why */
+    getCommerceStoreAccess<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Resolve your org's active storefront without naming an id */
+    getCommerceStoreCurrent<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Mint your org's least-privilege storefront read key */
+    postCommerceStoreToken<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a storefront, keeping a recoverable copy */
+    deleteCommerceStoreByStoreid<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one storefront */
+    getCommerceStoreByStoreid<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a storefront */
+    patchCommerceStoreByStoreid<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceStoreByStoreid<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a storefront outright */
+    putCommerceStoreByStoreid<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Authorize a new order against a storefront, holding the funds without settling them */
+    postCommerceStoreByStoreidAuthorize<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Authorize an order that already exists, holding the funds without settling them */
+    postCommerceStoreByStoreidAuthorizeByOrderid<T = unknown>(storeid: string, orderid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch a bundle as this storefront sells it */
+    getCommerceStoreByStoreidBundleByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Capture a previously authorized order and settle the payment */
+    postCommerceStoreByStoreidCaptureByOrderid<T = unknown>(storeid: string, orderid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Authorize and capture a new order in one call */
+    postCommerceStoreByStoreidCharge<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Authorize a new order against a storefront, holding the funds — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutAuthorize<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Authorize an existing order, holding the funds — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutAuthorizeByOrderid<T = unknown>(storeid: string, orderid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Capture a previously authorized order and settle it — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutCaptureByOrderid<T = unknown>(storeid: string, orderid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Authorize and capture a new order in one call — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutCharge<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** PayPal cancel by pay key — refuses, exactly as the unprefixed address does */
+    postCommerceStoreByStoreidCheckoutPaypalCancelByPaykey<T = unknown>(storeid: string, payKey: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** PayPal confirm by pay key — refuses, exactly as the unprefixed address does */
+    postCommerceStoreByStoreidCheckoutPaypalConfirmByPaykey<T = unknown>(storeid: string, payKey: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Start a PayPal authorization for a new order — the checkout spelling */
+    postCommerceStoreByStoreidCheckoutPaypalPay<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** The storefront's whole listing override map */
+    getCommerceStoreByStoreidListing<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Remove a listing override */
+    deleteCommerceStoreByStoreidListingByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one listing override, by item id or by its slug or SKU */
+    getCommerceStoreByStoreidListingByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Confirm a listing override exists and re-save the store */
+    patchCommerceStoreByStoreidListingByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Add a listing override under a new key */
+    postCommerceStoreByStoreidListingByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Upsert a listing override */
+    putCommerceStoreByStoreidListingByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** PayPal cancel by pay key — refuses, because a pay key alone does not identify the order */
+    postCommerceStoreByStoreidPaypalCancelByPaykey<T = unknown>(storeid: string, payKey: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** PayPal confirm by pay key — refuses, because a pay key alone does not identify the order */
+    postCommerceStoreByStoreidPaypalConfirmByPaykey<T = unknown>(storeid: string, payKey: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Start a PayPal authorization for a new order */
+    postCommerceStoreByStoreidPaypalPay<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch a product as this storefront sells it */
+    getCommerceStoreByStoreidProductByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Start this store's no-card trial on the entry plan */
+    postCommerceStoreByStoreidTrial<T = unknown>(storeid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch a variant as this storefront sells it */
+    getCommerceStoreByStoreidVariantByKey<T = unknown>(storeid: string, key: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's submissions, as a page */
+    getCommerceSubmission<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a submission */
+    postCommerceSubmission<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a submission, keeping a recoverable copy */
+    deleteCommerceSubmissionBySubmissionid<T = unknown>(submissionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one submission */
+    getCommerceSubmissionBySubmissionid<T = unknown>(submissionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a submission */
+    patchCommerceSubmissionBySubmissionid<T = unknown>(submissionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a submission — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceSubmissionBySubmissionid<T = unknown>(submissionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a submission outright */
+    putCommerceSubmissionBySubmissionid<T = unknown>(submissionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's subscribers, as a page */
+    getCommerceSubscriber<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a subscriber */
+    postCommerceSubscriber<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a subscriber, keeping a recoverable copy */
+    deleteCommerceSubscriberBySubscriberid<T = unknown>(subscriberid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one subscriber */
+    getCommerceSubscriberBySubscriberid<T = unknown>(subscriberid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a subscriber */
+    patchCommerceSubscriberBySubscriberid<T = unknown>(subscriberid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a subscriber — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceSubscriberBySubscriberid<T = unknown>(subscriberid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a subscriber outright */
+    putCommerceSubscriberBySubscriberid<T = unknown>(subscriberid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's token transactions, as a page */
+    getCommerceTokentransaction<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a token transaction */
+    postCommerceTokentransaction<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a token transaction, keeping a recoverable copy */
+    deleteCommerceTokentransactionByTokentransactionid<T = unknown>(tokentransactionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one token transaction */
+    getCommerceTokentransactionByTokentransactionid<T = unknown>(tokentransactionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a token transaction */
+    patchCommerceTokentransactionByTokentransactionid<T = unknown>(tokentransactionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a token transaction — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceTokentransactionByTokentransactionid<T = unknown>(tokentransactionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a token transaction outright */
+    putCommerceTokentransactionByTokentransactionid<T = unknown>(tokentransactionid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's transfers, as a page */
+    getCommerceTransfer<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a transfer */
+    postCommerceTransfer<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a transfer, keeping a recoverable copy */
+    deleteCommerceTransferByTransferid<T = unknown>(transferid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one transfer */
+    getCommerceTransferByTransferid<T = unknown>(transferid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a transfer */
+    patchCommerceTransferByTransferid<T = unknown>(transferid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a transfer — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceTransferByTransferid<T = unknown>(transferid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a transfer outright */
+    putCommerceTransferByTransferid<T = unknown>(transferid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's variants, as a page */
+    getCommerceVariant<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a variant */
+    postCommerceVariant<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a variant, keeping a recoverable copy */
+    deleteCommerceVariantByVariantid<T = unknown>(variantid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one variant */
+    getCommerceVariantByVariantid<T = unknown>(variantid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a variant */
+    patchCommerceVariantByVariantid<T = unknown>(variantid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a variant — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceVariantByVariantid<T = unknown>(variantid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a variant outright */
+    putCommerceVariantByVariantid<T = unknown>(variantid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's wallets, as a page */
+    getCommerceWallet<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a wallet */
+    postCommerceWallet<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a wallet, keeping a recoverable copy */
+    deleteCommerceWalletByWalletid<T = unknown>(walletid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one wallet */
+    getCommerceWalletByWalletid<T = unknown>(walletid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a wallet */
+    patchCommerceWalletByWalletid<T = unknown>(walletid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a wallet — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceWalletByWalletid<T = unknown>(walletid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a wallet outright */
+    putCommerceWalletByWalletid<T = unknown>(walletid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's watchlists, as a page */
+    getCommerceWatchlist<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a watchlist */
+    postCommerceWatchlist<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a watchlist, keeping a recoverable copy */
+    deleteCommerceWatchlistByWatchlistid<T = unknown>(watchlistid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one watchlist */
+    getCommerceWatchlistByWatchlistid<T = unknown>(watchlistid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a watchlist */
+    patchCommerceWatchlistByWatchlistid<T = unknown>(watchlistid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a watchlist — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceWatchlistByWatchlistid<T = unknown>(watchlistid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a watchlist outright */
+    putCommerceWatchlistByWatchlistid<T = unknown>(watchlistid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** List your org's webhooks, as a page */
+    getCommerceWebhook<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Create a webhook */
+    postCommerceWebhook<T = unknown>(opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Delete a webhook, keeping a recoverable copy */
+    deleteCommerceWebhookByWebhookid<T = unknown>(webhookid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Fetch one webhook */
+    getCommerceWebhookByWebhookid<T = unknown>(webhookid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Change part of a webhook */
+    patchCommerceWebhookByWebhookid<T = unknown>(webhookid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Method-override tunnel for a webhook — for clients that cannot send PUT, PATCH or DELETE */
+    postCommerceWebhookByWebhookid<T = unknown>(webhookid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Replace a webhook outright */
+    putCommerceWebhookByWebhookid<T = unknown>(webhookid: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /** Payment-provider webhook intake for settlement and subscription lifecycle events */
+    postCommerceWebhooksByProvider<T = unknown>(provider: string, opts?: {
+        token?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+}
+/**
+ * The process-wide client.
+ *
+ * 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 declare function hanzoCommerce(config?: CommerceClientConfig): Commerce;