@leaflow/sdk 0.26.0 → 0.28.0

package/dist/billing/v1/schema.d.ts

@@ -0,0 +1,1258 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/account/v1/billing-accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List my billing accounts
+         * @description Every billing account belonging to the caller, with the projects each one currently pays for.
+         *
+         *     Not paginated: how many accounts one person holds is bounded by how many they bothered to
+         *     create, and that is a small number.
+         */
+        get: operations["list-billing-accounts"];
+        put?: never;
+        /**
+         * Create a billing account
+         * @description Creates a billing account for the caller.
+         *
+         *     **`seq` is supplied by the client, not assigned here.** Assigning it would mean reading the
+         *     existing accounts and adding one, which is a read-modify-write race: two concurrent "create"
+         *     clicks compute the same `seq`. Having the client name it turns that race into a plain
+         *     idempotent repeat — the second request returns the first account instead of failing.
+         *
+         *     The new account pays for nothing. Binding a project is a separate, deliberate act; doing it
+         *     here would quietly turn "I want to add a card" into "I have changed who pays".
+         */
+        post: operations["create-billing-account"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/balance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read an account's balance
+         * @description What is left on the account.
+         *
+         *     The figure is the **live** balance: usage that has been reported but not yet settled is
+         *     already subtracted. The settled figure is larger, and the difference is precisely what the
+         *     holder has just spent — showing that instead would tell them they can afford something they
+         *     cannot.
+         *
+         *     An account that has never been topped up reports `"0"` — not an absent field, and not an
+         *     empty string.
+         */
+        get: operations["read-billing-account-balance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/projects/{projectId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Make this account pay for a project
+         * @description Binds a project to this account. A project bound to another account is moved.
+         *
+         *     **Both the account and the project must belong to the caller.** Either one failing refuses the
+         *     request. Requiring the project as well as the account is what stops somebody attaching a
+         *     project that is not theirs — which sounds generous, since they would be paying for it, but it
+         *     would also expose that project's usage to them, and let them detach it again at any moment,
+         *     leaving the project with no account and therefore unable to allocate anything.
+         *
+         *     Idempotent: binding a project already bound to this account changes nothing.
+         *
+         *     Only subsequent usage is affected; see the hard constraint on rebinding.
+         */
+        put: operations["bind-project-to-billing-account"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/top-ups": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a top-up
+         * @description Begins adding money to this account. Returns a URL to send the browser to; the card is
+         *     entered there, on the payment provider's own page.
+         *
+         *     **No card data ever reaches this platform**, in any field, in any log. That is the entire
+         *     reason this returns a redirect instead of accepting card details.
+         *
+         *     **Credit is not added here.** It is added once the payment provider confirms the money
+         *     arrived, which happens out of band and usually within seconds. The balance is unchanged when
+         *     this call returns, and polling it immediately will show the old figure.
+         *
+         *     That ordering is deliberate. Credit is spendable as soon as it exists, so anything added
+         *     before the charge succeeds is money the holder can spend against a payment that then fails.
+         *
+         *     Abandoning the page costs nothing; nothing is created on the account until the money arrives.
+         */
+        post: operations["start-top-up"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/charges": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What this period has run up so far
+         * @description The itemised version of `unsettled`: what has been used this period and not yet billed.
+         *
+         *     It has to come from charges rather than from invoices. An invoice only exists once a period has
+         *     been billed, and the one for the period in progress is in a state that does not appear in the
+         *     invoice list at all — reading invoices would show nothing and suggest the account has used
+         *     nothing, while the spend keeps climbing.
+         */
+        get: operations["list-charges"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/invoices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List this account's invoices
+         * @description Past periods, most recent first. The period in progress is not here — see the charges
+         *     endpoint for that.
+         */
+        get: operations["list-invoices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/invoices/{invoiceId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read one invoice with its lines
+         * @description A total does not answer "why is it this much", and that is the question a bill provokes. Each
+         *     line carries its service period, without which lines of the same name — hundreds of them on an
+         *     hourly bill — cannot be told apart, and how much of it credit covered, which is the answer to
+         *     "I have a balance, why am I being charged".
+         */
+        get: operations["get-invoice"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/subscription": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Which plan this account is on
+         * @description `404` means no plan, which is worth showing rather than hiding: an account without one is
+         *     refused admission, so nothing can be allocated in it.
+         *
+         *     A subscription that has been cancelled but has not reached the end of its period still counts
+         *     as being on a plan — it is still serving, still billing, and the period has already been paid
+         *     for.
+         */
+        get: operations["read-subscription"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/subscription/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Come off the paid plan
+         * @description Moves the account off whatever plan it is on.
+         *
+         *     Where a default plan is configured this is a switch to it rather than a cancellation — an
+         *     account with no plan is refused admission, so cancelling outright would cut off someone who
+         *     only meant to drop back to the free tier. Without a default plan it is a real cancellation and
+         *     the account is left with no plan on purpose.
+         *
+         *     `timing` has to be stated. Ending immediately on an account that has already paid for the
+         *     current period takes back what they paid for; ending at the end of the period does not. There
+         *     is no default because the two are materially different and picking one silently would make the
+         *     wrong one happen whenever the field is forgotten.
+         *
+         *     Without this, someone who bought a paid plan can only stop paying by contacting support —
+         *     which is how a cancellation becomes a chargeback.
+         */
+        post: operations["cancel-subscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/top-ups/{paymentId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * How far along a top-up is
+         * @description Credit arrives asynchronously, shortly after the payment provider confirms the money. Coming
+         *     back from the payment page the balance has usually not moved yet, and without this there is no
+         *     way to tell "it is on its way" from "it failed" — the only recourse is refreshing the balance
+         *     and guessing.
+         *
+         *     `settled` means the credit has landed. `pending` means the money arrived and the credit has
+         *     not been issued yet, or the payment method is an asynchronous one and the money itself is
+         *     still in transit.
+         */
+        get: operations["read-top-up"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/card": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Add or replace the card on file
+         * @description Begins adding a card. Returns a URL to send the browser to; the card is entered there, on the
+         *     payment provider's own page, and **no card data ever reaches this platform**.
+         *
+         *     ## This is a prerequisite for buying a plan, not a convenience
+         *
+         *     A plan is charged by invoice, and the invoice is collected from the card on file. The billing
+         *     a subscription cannot start for an account that has none — so "add a card, then
+         *     buy" is the order the system requires, not a flow that was chosen.
+         *
+         *     It is *not* a prerequisite for topping up: a top-up collects the money there and then.
+         *
+         *     Replacing the card uses the same operation. The new card becomes the default and the old one
+         *     stops being used; nothing else about the account changes.
+         */
+        post: operations["start-card-setup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/offers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the offers this account can buy
+         * @description Lists what is actually purchasable by this account, right now.
+         *
+         *     ## Every offer here has passed the full eligibility check
+         *
+         *     The list is not "everything on sale" filtered by status. A promotion whose places are gone, a
+         *     first-month discount this person already used, a beta price they are not on the list for —
+         *     none of them appear. Returning them and rejecting the purchase afterwards reads as a broken
+         *     system rather than as a rule.
+         *
+         *     The price is not here, and not because it was left out: an offer states **who may buy, and
+         *     when**. What it costs comes from the plan it points at, and is reported by the offers list.
+         */
+        get: operations["list-offers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/offers/{offerKey}/purchase": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Buy an offer
+         * @description Puts the account on the plan this offer points at, taking one of its places if it has a limit.
+         *
+         *     ## A card has to be on file first
+         *
+         *     Unless the offer points at a free plan. A paid plan is collected from the card on file
+         *     and refuses to start the subscription without one; that refusal arrives here as a
+         *     precondition error rather than as a conflict.
+         *
+         *     ## `timing` is required only when the account already has a plan
+         *
+         *     Moving between plans immediately is what an upgrade wants — the customer paid more and wants
+         *     it now. Waiting for the end of the period is what a downgrade wants — they already paid for
+         *     this one. Neither is a safe default, and picking one silently gets the money wrong whenever
+         *     the field is forgotten.
+         *
+         *     ## Being refused says which rule refused
+         *
+         *     Places gone, window closed, already used, not on the list — each needs the customer to do
+         *     something different, and several of them need them to do nothing at all. A single "not
+         *     eligible" sends everyone to support.
+         *
+         *     ## Retrying is safe
+         *
+         *     A place is taken before the subscription is created, so a failure in between leaves the place
+         *     held rather than the discount given away. Retrying the same purchase finishes it instead of
+         *     taking a second place.
+         */
+        post: operations["purchase-offer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * @description When a plan change takes effect. There is no default: an upgrade and a downgrade want opposite
+         *     answers, and the difference is money
+         * @enum {string}
+         */
+        PlanChangeTiming: "immediate" | "next_billing_cycle";
+        OfferList: {
+            offers: components["schemas"]["Offer"][];
+        };
+        /**
+         * @description One thing this account can buy. It carries no price — the price is on the plan it points at,
+         *     recorded in exactly one place
+         */
+        Offer: {
+            /** @description The stable identifier operations and support use for this offer */
+            offer_key: string;
+            name: string;
+            description?: string;
+            /** @description A short label for the pricing page, e.g. the one marking the recommended tier */
+            badge?: string;
+            /**
+             * Format: date-time
+             * @description When this offer stops being purchasable. Absent means it does not expire
+             */
+            valid_until?: string;
+            /** @description Present on offers that sell a plan */
+            pricing?: components["schemas"]["Pricing"];
+            /** @description Present on offers that sell credit */
+            top_up?: components["schemas"]["TopUpPricing"];
+        };
+        /**
+         * @description What this offer costs, as a structure rather than a number.
+         *
+         *     A plan is rarely one number: an introductory period at one price followed by another, a monthly
+         *     fee alongside metered usage, an allowance of free units before metering starts. Flattening that
+         *     into a single figure means deciding which part to show, and every such decision is wrong for
+         *     some plan.
+         *
+         *     This is read on each request rather than stored alongside the offer. The plan owns
+         *     prices; a second copy would be a second answer, and the two would drift without anything saying
+         *     so — the visible symptom being a pricing page that disagrees with the invoice.
+         */
+        Pricing: {
+            currency: components["schemas"]["Currency"];
+            /** @description How often this recurs, as an ISO 8601 duration. `P1M` is monthly */
+            billing_period?: string;
+            /**
+             * @description In order. A phase with no `duration` runs until the subscription ends, and there is at most
+             *     one of those, last
+             */
+            phases: components["schemas"]["PricingPhase"][];
+        };
+        PricingPhase: {
+            name: string;
+            /** @description How long this phase lasts, as an ISO 8601 duration. Absent means "until the end" */
+            duration?: string;
+            lines: components["schemas"]["PricingLine"][];
+        };
+        /** @description One charge within a phase — a fee, or a rate for something metered */
+        PricingLine: {
+            name: string;
+            /**
+             * @description `free` costs nothing. `flat` is charged once per period regardless of use. `unit` is charged
+             *     per unit consumed
+             * @enum {string}
+             */
+            type: "free" | "flat" | "unit";
+            /** @description A decimal string. Money is never a float */
+            amount?: string;
+            /**
+             * @description For `unit` lines whose meter counts something finer than what is charged for: how many
+             *     metered units one charge covers. A price of `10` with `units_per_charge` of `1000000` is
+             *     ten currency units per million.
+             *
+             *     Absent means one for one. **Showing the amount without this is wrong by whatever this
+             *     factor is**, which for token pricing is six orders of magnitude
+             */
+            units_per_charge?: string;
+            /** @description How many units are not charged for before charging starts */
+            free_units?: string;
+            /**
+             * Format: float
+             * @description A reduction applied to this line, 0 to 100
+             */
+            percent_off?: number;
+            /**
+             * @description True when this is charged once at the start rather than every period. Absent or false means
+             *     it recurs
+             */
+            one_time?: boolean;
+        };
+        /**
+         * @description What a top-up bundle costs and what it grants. Present only on offers that sell credit.
+         *
+         *     Unlike a plan price, this is stated on the bundle itself: credit is granted per
+         *     transaction and has no catalog of bundles to read from. There is no second copy to drift
+         *     against, because there is no first one anywhere else
+         */
+        TopUpPricing: {
+            /** @description What is charged, as a decimal string */
+            pay: string;
+            /** @description How much credit is granted. Equal to `pay` when there is no bonus */
+            credit: string;
+        };
+        Purchase: {
+            offer_key: string;
+            /**
+             * @description The subscription now serving this account. When the change was set to take effect at the
+             *     end of the period, this is the one that takes over then, and its status says `scheduled`
+             */
+            subscription_id: string;
+        };
+        Error: {
+            code?: string;
+            message: string;
+            meta?: {
+                [key: string]: unknown;
+            };
+            /** Format: int64 */
+            status: number;
+        };
+        /**
+         * @description A billing account.
+         *
+         *     Any internal identifier is deliberately absent: the key addresses everything on
+         *     this API, and a second identifier is one more thing a client can pass in the wrong place, for
+         *     no benefit to anyone reading the page.
+         */
+        BillingAccount: {
+            /** @description Addresses the account and states who owns it. Of the form `u_<user_id>_<seq>` */
+            key: string;
+            /** @description What the holder called it. Not unique, and it addresses nothing */
+            display_name: string;
+            currency: components["schemas"]["Currency"];
+            /** @description The projects this account pays for. Empty when it pays for none, never `null` */
+            project_ids: string[];
+        };
+        BillingAccountList: {
+            /** @description Every account belonging to the caller. Empty when they hold none */
+            accounts: components["schemas"]["BillingAccount"][];
+        };
+        CreateBillingAccountRequestBody: {
+            /**
+             * Format: int32
+             * @description Which of the caller's accounts this is. Two requests carrying the same `seq` describe the
+             *     same account, so a retry is safe; a different `seq` creates a different account.
+             *
+             *     It is not optional. Defaulting it would mean that a client which forgot the field
+             *     silently receives the account it already had, and reads that as a successful creation.
+             */
+            seq: number;
+            /** @description A name for the holder's own benefit */
+            display_name: string;
+            currency?: components["schemas"]["Currency"];
+            /**
+             * @description Buy one of the top-up bundles from `/offers` instead of an arbitrary amount. When given,
+             *     `amount` is ignored: the bundle says what is charged and how much credit it grants.
+             *
+             *     How much credit arrives is decided when the money does, not now — and only if the amount
+             *     collected matches what the bundle costs. A bundle whose places ran out, or whose window
+             *     closed, in between still grants what was paid for; it just does not grant the bonus.
+             */
+            offer_key?: string;
+        };
+        /**
+         * @description The three numbers a billing page needs, which are not the same number.
+         *
+         *     `balance` answers "can I start another one" and is floored at zero, so it cannot express
+         *     being past zero. `unsettled` is what the current period has run up. `available` is the
+         *     difference between the two and **may be negative**.
+         *
+         *     Reporting only the first would make an account that has overspent indistinguishable from one
+         *     that spent exactly what it had, and those two call for different actions.
+         */
+        Balance: {
+            currency: components["schemas"]["Currency"];
+            /**
+             * @description What is spendable right now, with usage reported but not yet settled already subtracted.
+             *     Never negative — it is floored at zero, so it answers "can I start another machine" but
+             *     not "how much do I owe". A decimal string; `"0"` when the account has never been topped up
+             */
+            balance: string;
+            /** @description The amount booked to the ledger, before this period's usage is taken off */
+            cash: string;
+            /**
+             * @description What this period has run up and not yet been billed for. It keeps growing past the cash
+             *     balance, which is precisely the case the live figure cannot show
+             */
+            unsettled: string;
+            /**
+             * @description `cash` minus `unsettled`. **Negative means already in arrears**, and being able to say that
+             *     is the whole reason this field exists — the positive range is already covered by `balance`
+             */
+            available: string;
+        };
+        /** @description Which account pays for which project, as it stands once the request has been applied */
+        ProjectBinding: {
+            account_key: string;
+            /** Format: uuid */
+            project_id: string;
+        };
+        StartTopUpRequestBody: {
+            /**
+             * @description How much to add, as a decimal string — `"20"`, `"19.99"`.
+             *
+             *     **Anything below one cent is rejected rather than rounded.** Rounding up overcharges and
+             *     rounding down undercharges; both alter the amount somewhere the payer cannot see it, and
+             *     this is the one number on this API where being wrong means money is wrong.
+             */
+            amount: string;
+            currency?: components["schemas"]["Currency"];
+            /**
+             * @description Buy one of the top-up bundles from `/offers` instead of an arbitrary amount. When given,
+             *     `amount` is ignored: the bundle says what is charged and how much credit it grants.
+             *
+             *     How much credit arrives is decided when the money does, not now — and only if the amount
+             *     collected matches what the bundle costs. A bundle whose places ran out, or whose window
+             *     closed, in between still grants what was paid for; it just does not grant the bonus.
+             */
+            offer_key?: string;
+        };
+        CardSetupSession: {
+            /**
+             * Format: uri
+             * @description Send the browser here. It expires, so do not store it
+             */
+            url: string;
+        };
+        TopUpSession: {
+            /**
+             * @description Identifies this attempt. Quote it in a support conversation — it is what ties the payment
+             *     provider's record to the credit that was granted
+             */
+            payment_id: string;
+            /**
+             * Format: uri
+             * @description Send the browser here. It expires, so do not store it
+             */
+            url: string;
+        };
+        /** @description One thing this period has been charged for */
+        Charge: {
+            id: string;
+            name: string;
+            /**
+             * @description Decimal string, the real-time figure. The booked figure would show a machine that only
+             *     just started as zero
+             */
+            total: string;
+        };
+        ChargeList: {
+            currency: components["schemas"]["Currency"];
+            charges: components["schemas"]["Charge"][];
+            /** @description The sum, which is the same number as `unsettled` on the balance */
+            total: string;
+        };
+        /** @enum {string} */
+        InvoiceStatus: "draft" | "issuing" | "issued" | "payment_processing" | "overdue" | "paid" | "uncollectible" | "voided";
+        Invoice: {
+            id: string;
+            number?: string;
+            status: components["schemas"]["InvoiceStatus"];
+            currency: components["schemas"]["Currency"];
+            total: string;
+            /** Format: date-time */
+            due_at?: string;
+            /** Format: date-time */
+            issued_at?: string;
+            /** Format: date-time */
+            created_at: string;
+        };
+        InvoiceList: {
+            invoices: components["schemas"]["Invoice"][];
+        };
+        InvoiceLine: {
+            name: string;
+            description?: string;
+            /**
+             * Format: date-time
+             * @description Required. Lines of the same name repeat many times on one invoice — hundreds on an hourly
+             *     bill — and without the period they cannot be told apart
+             */
+            period_from: string;
+            /** Format: date-time */
+            period_to: string;
+            /** @description Before discounts and credit */
+            amount: string;
+            discounts_total?: string;
+            /** @description How much of this line credit covered */
+            credits_total?: string;
+            total: string;
+        };
+        InvoiceDetail: {
+            id: string;
+            number?: string;
+            status: components["schemas"]["InvoiceStatus"];
+            currency: components["schemas"]["Currency"];
+            total: string;
+            charges_total?: string;
+            discounts_total?: string;
+            credits_total?: string;
+            taxes_total?: string;
+            /** Format: date-time */
+            period_from?: string;
+            /** Format: date-time */
+            period_to?: string;
+            /** Format: date-time */
+            due_at?: string;
+            /** Format: date-time */
+            issued_at?: string;
+            /** Format: date-time */
+            created_at: string;
+            lines: components["schemas"]["InvoiceLine"][];
+        };
+        Subscription: {
+            id: string;
+            plan_key: string;
+            plan_version?: number;
+            /**
+             * @description `canceled` still counts as being on a plan — it is serving until the end of the period,
+             *     which has already been paid for
+             */
+            status: string;
+        };
+        TopUpStatus: {
+            payment_id: string;
+            /**
+             * @description `settled` means the credit has landed. `pending` means it has not yet — the payment is
+             *     still being confirmed, or the money itself is still in transit
+             * @enum {string}
+             */
+            state: "settled" | "pending";
+            /** @description The credit that was issued, present once settled */
+            amount?: string;
+            currency?: components["schemas"]["Currency"];
+        };
+        /**
+         * @description ISO 4217, uppercase. `USD` is the only value the platform issues today, and a request
+         *     naming any other is refused with `BILLING_CURRENCY_UNSUPPORTED`.
+         *
+         *     Deliberately not an enumeration. The set of currency codes is governed outside this API, so
+         *     a client generated today must still be able to read a response naming a code added later —
+         *     an enumeration turns that response into a decode failure in a client nobody can redeploy.
+         *     Restricting what may be *sent* is a rule about what the platform supports, and it lives
+         *     where that rule can change without regenerating anything.
+         */
+        Currency: string;
+    };
+    responses: never;
+    parameters: {
+        /**
+         * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+         *     which is why the key is what addresses the account.
+         */
+        AccountKey: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    "list-billing-accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingAccountList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "create-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateBillingAccountRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "read-billing-account-balance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Balance"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "bind-project-to-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description The project this account should pay for */
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ProjectBinding"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "start-top-up": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["StartTopUpRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopUpSession"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-charges": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChargeList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-invoices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InvoiceList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-invoice": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                invoiceId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InvoiceDetail"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "read-subscription": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Subscription"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "cancel-subscription": {
+        parameters: {
+            query: {
+                /** @description When it takes effect */
+                timing: "immediate" | "next_billing_cycle";
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Subscription"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "read-top-up": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description The payment id returned when the top-up was started */
+                paymentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopUpStatus"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "start-card-setup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CardSetupSession"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-offers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OfferList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "purchase-offer": {
+        parameters: {
+            query?: {
+                /** @description When the switch takes effect. Required if the account already has a plan, ignored otherwise */
+                timing?: components["schemas"]["PlanChangeTiming"];
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description Which offer */
+                offerKey: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Purchase"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+}