@leaflow/sdk 0.0.0-dev.113.g5d6fb99 → 0.0.0-dev.113.gecc0f27

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

@@ -0,0 +1,2657 @@
+/**
+ * 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}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read one of my billing accounts
+         * @description One account, with the projects it currently pays for.
+         *
+         *     The list returns the same objects, so this exists for the case the list cannot serve: a link
+         *     straight to one account. Making the caller fetch every account and filter turns a bookmarked
+         *     page into a request whose cost grows with how many accounts they hold.
+         */
+        get: operations["get-billing-account"];
+        /**
+         * Rename a billing account
+         * @description Changes the display name. Nothing else about the account can be changed here.
+         *
+         *     The key is not among the fields and never will be: ownership is stated by the key, and
+         *     invoices already issued refer to it. The name is what tells two accounts apart in a list, so
+         *     a mistake made while creating one is otherwise permanent.
+         */
+        put: operations["update-billing-account"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/credit-transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * How the balance got to where it is
+         * @description Every movement of credit on this account: what was added, what was spent, what expired, what
+         *     was voided. Newest first.
+         *
+         *     The balance on its own is a number with no account of itself. Asked why it is lower than
+         *     expected, it cannot answer, and the holder is left to guess between "I was charged" and
+         *     "something expired" — which lead to different next steps.
+         */
+        get: operations["list-credit-transactions"];
+        put?: never;
+        post?: never;
+        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;
+        /**
+         * Stop paying for a project
+         * @description Unbinds the project from this account. Nothing pays for it afterwards, and **everything in it
+         *     is refused admission** until some account takes it on — no new machines, no forwarded
+         *     requests.
+         *
+         *     That consequence is the reason this exists rather than an argument against it: a project
+         *     bound to the wrong account has no other way out, and moving it to another of the caller's
+         *     accounts is not a correction when the answer is that this account should not be paying for
+         *     it at all.
+         *
+         *     Charges already accrued stay where they are. They were incurred while this account held the
+         *     project, and an invoice has to keep pointing at what it was based on.
+         */
+        delete: operations["unbind-project-from-billing-account"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/orders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * My orders
+         * @description Every provisioning request made against the projects this account pays for, newest first.
+         *
+         *     An order that never went through stays here on purpose. Removing it would leave nothing to
+         *     look at in exactly the case someone wants to look: a resource was asked for, was not
+         *     delivered, and the question is what happened.
+         *
+         *     The list carries no lines. An order has only a handful, but shipping them on every page
+         *     means carrying data no column shows.
+         */
+        get: operations["list-orders"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/orders/{orderId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * One order, with its lines
+         * @description Each line names what was asked for and how much of it. This is the only route that carries
+         *     them.
+         */
+        get: operations["get-order"];
+        put?: never;
+        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;
+        };
+        /**
+         * My top-ups
+         * @description Every top-up this account has made, newest first.
+         *
+         *     Reading one top-up requires already holding its identifier, and the only place that
+         *     identifier appears is the redirect that started it — so without this list a top-up becomes
+         *     unfindable the moment the browser tab is closed, which is exactly when somebody wants to
+         *     check whether their money arrived.
+         */
+        get: operations["list-top-ups"];
+        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}/charges/{chargeId}/usage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What produced this charge
+         * @description Splits one charge back into the projects that produced it, and lists the resources it could
+         *     have come from.
+         *
+         *     ## Why this is not a field on the charge
+         *
+         *     A charge has no project, and that is not an omission: the billing subject is the **account**,
+         *     and the project is a dimension on each usage event. When three of an account's projects use
+         *     the same product, their usage aggregates into one charge — that charge genuinely spans three
+         *     projects, and stamping any single project id on it would be wrong.
+         *
+         *     A split is also more useful than a label would be: it gives proportions, and proportions are
+         *     what decide which project's resources to switch off.
+         *
+         *     ## The quantity here is what was reported, not what was billed
+         *
+         *     Conversion (machine-seconds to machine-hours) happens on the pricing side, and the engine
+         *     does not echo `unit_config` back on a charge. So this figure times the unit price does not
+         *     equal the total — a step is missing in between, and that step only becomes visible on the
+         *     invoice, where the whole pricing configuration is frozen onto each line.
+         *
+         *     Reported quantity is still the right number for "which project is burning this", which is
+         *     what the split is for.
+         *
+         *     ## The resource list says which, not how much
+         *
+         *     Usage events carry no resource id — it is not a grouping dimension, and making it one would
+         *     mean one time series per machine per hour. So the engine cannot attribute a charge to a
+         *     machine. What it can be attributed to is a product, and which resources of that product
+         *     exist is something billing knows from its own records.
+         *
+         *     Destroyed resources are listed too: this period's charge includes the part they ran for.
+         *     Leaving them out is what makes the numbers fail to add up for someone who deleted a machine
+         *     mid-month — which is exactly the case they are trying to explain.
+         *
+         *     ## A flat fee answers with an empty split
+         *
+         *     There is no meter behind it, so there is nothing to attribute. That is an answer, not an
+         *     error.
+         */
+        get: operations["get-charge-usage"];
+        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/projects/{projectId}/billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Which account pays for this project
+         * @description The account a project's resources are charged to, resolved from the project rather than
+         *     guessed.
+         *
+         *     ## Why a console needs this
+         *
+         *     Everything in a console happens inside a project, while billing accounts belong to a person —
+         *     and a person can have many. Showing "the first one" next to a sentence like *you are
+         *     overdrawn, new resources will be refused* pairs one account's balance with another account's
+         *     rule. Both directions are wrong and one of them is silent: the figures look healthy while
+         *     creating anything is refused, and the refusal names a reason the page just contradicted.
+         *
+         *     ## Being a member is enough to ask, but not to see the money
+         *
+         *     The answer is the account's identity, not its balance. A project's members are not
+         *     necessarily the people paying for it — a company account can pay for a project someone else
+         *     works in — and their balance is not those members' business. Whoever owns the account reads
+         *     the figures from the balance route as before; `owned_by_me` says which case this is, so a
+         *     page can tell "you are overdrawn" apart from "ask whoever pays for this project".
+         *
+         *     ## A project with no account is a normal state, and it answers 404
+         *
+         *     A project nobody has bound yet cannot create resources at all — admission refuses it. That is
+         *     worth saying plainly ("this project has no billing account, bind one") rather than falling
+         *     back to some other account of theirs, which is how the wrong-account problem started.
+         */
+        get: operations["read-project-billing-account"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/projects/{projectId}/quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * What a usage would cost in this project
+         * @description Prices a set of usages against whatever plan pays for this project, and returns **every
+         *     intermediate step** rather than a single number.
+         *
+         *     # Why by project rather than by billing account
+         *
+         *     The page that needs this is the one where somebody is about to create a machine, and all it has
+         *     is a project. Which account pays for that project is billing's own bookkeeping — asking the
+         *     caller to resolve it first would put that mapping into a page that otherwise has no business
+         *     knowing accounts exist.
+         *
+         *     # Quantities are raw
+         *
+         *     Seconds, token counts, GiB-seconds: the amount a service reports. Conversion happens here, which
+         *     is why services keep no conversion tables of their own and why the caller must not do the
+         *     arithmetic itself.
+         *
+         *     Name each usage by `service` and `product_id` rather than by key: the key is a hash of a
+         *     convention that has exactly one implementation on purpose.
+         *
+         *     # It is an estimate
+         *
+         *     The engine computes the real amount; this reproduces the same rules. Every step comes back for
+         *     that reason — a single number that disagrees with the bill says nothing about which step was
+         *     wrong.
+         *
+         *     `404` means the project has no billing account, or its account is on no plan. Both are worth
+         *     showing: nothing can be created in either case, because admission refuses it.
+         */
+        post: operations["quote-project-usage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * What a usage would cost on this account's plan
+         * @description Prices a set of usages against whatever plan this account is currently on, and returns **every
+         *     intermediate step** rather than a single number.
+         *
+         *     # What it is for
+         *
+         *     Showing someone what a machine will cost before they create it. The console asks for the usage a
+         *     machine of that shape produces in an hour, and gets back what that hour costs them — on their
+         *     plan, with their discounts.
+         *
+         *     # Quantities are raw
+         *
+         *     Seconds, token counts, GiB-seconds: the amount a service reports. Conversion happens here, which
+         *     is why services keep no conversion tables of their own and why the console must not do the
+         *     arithmetic itself.
+         *
+         *     # It is an estimate
+         *
+         *     The engine computes the real amount; this reproduces the same rules. Every step comes back for
+         *     that reason — a single number that disagrees with the bill says nothing about which step was
+         *     wrong.
+         *
+         *     `404` means this account is not on any plan, and there is therefore nothing to price against.
+         */
+        post: operations["quote-usage"];
+        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}/payment-methods": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The payment methods on file
+         * @description Every method saved against this account, and which one an invoice will be charged to.
+         *
+         *     ## Why the brand, last four and expiry are here
+         *
+         *     They were deliberately absent while the billing engine held the card, because the answer
+         *     that mattered — can money be collected — came from the engine, and a page built on the
+         *     provider's answer could show a method the engine had not recorded. Collection now runs from
+         *     this service against the provider directly, so there is one answer, and it is the one shown.
+         *
+         *     Expiry is the reason this is worth showing at all: a card expires, the invoice then fails,
+         *     dunning runs out, and the project stops — with the account holder watching it happen and no
+         *     indication that a card was the cause.
+         *
+         *     No other card data exists here. The number, the expiry entered by the holder and the CVC go
+         *     from the browser to the provider and never reach this platform.
+         *
+         *     An account that has never added one returns an empty list. That is the normal state of a new
+         *     account, not an error.
+         */
+        get: operations["list-payment-methods"];
+        put?: never;
+        /**
+         * Begin adding a payment method
+         * @description Starts a session for adding a method, and returns the secret the browser needs to mount the
+         *     provider's own form.
+         *
+         *     ## The form is embedded, not a redirect
+         *
+         *     The returned `client_secret` initialises the provider's JavaScript, which renders its form
+         *     inside an iframe on this platform's own page. **No card data reaches this platform** — the
+         *     number goes from the browser straight to the provider, exactly as it would on a redirect —
+         *     but the account holder never leaves the console.
+         *
+         *     A redirect would take them to a page with someone else's branding in the middle of adding a
+         *     payment method, which is the moment they are most likely to abandon it.
+         *
+         *     ## This is a prerequisite for buying a plan, not a convenience
+         *
+         *     A plan is charged by invoice, and the invoice is collected from a method on file. Discovering
+         *     that none exists at purchase time turns a missing payment method into a rejection whose
+         *     wording is about something else entirely.
+         *
+         *     It is *not* a prerequisite for topping up: a top-up collects the money there and then.
+         */
+        post: operations["start-payment-method-setup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/payment-methods/{paymentMethodId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Remove a payment method
+         * @description Detaches it from this account. Removing the last one is allowed.
+         *
+         *     ## Why removing the last one is not blocked
+         *
+         *     Blocking it leaves an account holder who wants to stop paying with no way out. The cost of
+         *     allowing it is that later invoices cannot be collected — and that path has notice, a grace
+         *     period and a way back. A card that cannot be removed is a dead end.
+         */
+        delete: operations["remove-payment-method"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/payment-methods/{paymentMethodId}/default": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Charge invoices to this one
+         * @description Makes this the method an invoice is collected from.
+         *
+         *     ## It is stored at the provider, not here
+         *
+         *     The charge itself reads that setting from the provider, so keeping a second copy here would
+         *     create two answers to the same question. When they disagree the visible symptom is that the
+         *     account holder changed the default and the charge still went to the old one.
+         */
+        put: operations["set-default-payment-method"];
+        post?: never;
+        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;
+    };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What I bought outright
+         * @description Everything this account holds on a term, across every product.
+         *
+         *     ## Nothing here expires on its own
+         *
+         *     A term renews for as long as the seat is held: the engine charges the next period, prorates
+         *     any change to the second, and stops the moment the seat is given up. So there is no renewal
+         *     to remember and no expiry to warn about — giving it up means deleting the resource, in the
+         *     console that owns it.
+         *
+         *     What the next period costs and when it falls due is on the charges route. That is read
+         *     straight from the engine rather than copied here, because a copy is a second answer that
+         *     drifts without saying so.
+         *
+         *     ## Metered resources are not here
+         *
+         *     They have no term. Listing them would invite renewing something that is already billed by
+         *     the hour until it is deleted.
+         *
+         *     ## `state` and `desired_state` are both reported
+         *
+         *     A machine stopped for arrears reads `suspended` for both. One being brought back reads
+         *     `suspended` and `active` — it is on its way. Without the second field those look identical,
+         *     and a customer who just paid concludes it did not work and pays again.
+         */
+        get: operations["list-prepaid-assets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * @description The usages to price. Quantities are the **raw amounts a service reports** — seconds, token
+         *     counts, GiB-seconds. Conversion happens on the billing side, which is why services keep no
+         *     conversion tables of their own.
+         */
+        QuoteRequest: {
+            lines: components["schemas"]["QuoteUsage"][];
+        };
+        /**
+         * @description One usage to price. Name the thing **either** by its rate card key **or** by the service and
+         *     product it belongs to — exactly one of the two.
+         *
+         *     # Why the second form exists
+         *
+         *     A meter's key is a hash of `(service, product_id, variant)`, computed by a function that lives in
+         *     one place on purpose: get it wrong and usage lands in the wrong bucket, or in none, and nothing
+         *     reports it. A caller that derived the key itself would be a second copy of that convention.
+         *
+         *     So callers that know what they are buying — a machine of a given type, a model's input tokens —
+         *     give the service and product, and this side derives the key.
+         */
+        QuoteUsage: {
+            /**
+             * @description The rate card's key. For a card tied to a meter that is the meter's key, because the engine
+             *     requires the two to be identical.
+             *
+             *     Leave it out when giving `service` and `product_id` instead
+             */
+            key?: string;
+            /** @description The service that owns the product, as it appears in its usage events */
+            service?: string;
+            /** @description That service's own catalogue id for the thing being bought */
+            product_id?: string;
+            /**
+             * @description The fixed dimension values that split one product into several meters — canopy's token kind,
+             *     for instance. Part of the key, so leaving it out names a different meter
+             */
+            variant?: {
+                [key: string]: string;
+            };
+            /** @description The raw amount, before any conversion. A decimal string */
+            quantity: string;
+        };
+        /**
+         * @description One rate card priced, with every intermediate step.
+         *
+         *     Each step is here on purpose: a single total that disagrees with the bill says nothing about
+         *     which step went wrong, and this is a second implementation of the engine's rules
+         */
+        QuoteLine: {
+            key: string;
+            name: string;
+            /** @description False for a flat fee, which ignores usage entirely */
+            metered: boolean;
+            /** @description The quantity as given */
+            raw: string;
+            /** @description After unit conversion, before rounding */
+            converted: string;
+            /**
+             * @description After rounding. `unit_config.rounding` applies to this step only — entitlement uses the
+             *     exact converted value, which is the engine's documented behaviour
+             */
+            billable: string;
+            /** @description Units covered by the usage discount */
+            free_units: string;
+            charged: string;
+            unit_price: string;
+            /** @description Before the percentage discount */
+            gross: string;
+            discount: string;
+            /**
+             * @description Rounded to the currency's minor unit, **per line**. Not by rounding the sum: the engine
+             *     rounds each line, and the difference grows with the number of lines
+             */
+            total: string;
+        };
+        Quote: {
+            lines: components["schemas"]["QuoteLine"][];
+            /** @description The sum of the already-rounded lines */
+            total: string;
+            /**
+             * @description Keys that were given a usage but have no rate card on this plan.
+             *
+             *     **Reported rather than ignored**, because ignoring them yields a smaller but entirely
+             *     normal-looking number — and that is the most expensive misconfiguration there is: usage
+             *     lands, the usage chart shows it, and the bill has no line for it
+             */
+            unpriced?: string[];
+        };
+        /**
+         * @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;
+        };
+        UpdateBillingAccountRequestBody: {
+            display_name: string;
+        };
+        Order: {
+            id: string;
+            project_id: string;
+            placed_by: string;
+            /**
+             * @description Whether the request went through. It is not the state of what was provisioned: that
+             *     belongs to each resource and outlives the order.
+             * @enum {string}
+             */
+            state: "pending" | "fulfilled" | "failed";
+            failure_reason?: string;
+            /**
+             * @description What was taken, as a decimal string. Absent on a metered order, where the amount is not
+             *     known when the order is placed: it comes from usage afterwards. Absent must be read as
+             *     "billed by usage" — writing zero would make a metered order and a genuinely free one
+             *     look the same.
+             */
+            amount?: string;
+            currency?: string;
+            /**
+             * @description Always `none` on a metered order.
+             * @enum {string}
+             */
+            payment_state?: "none" | "paid" | "refunded";
+            /** Format: date-time */
+            created_at: string;
+            /** @description Only present on the single-order route. */
+            lines?: components["schemas"]["OrderLine"][];
+        };
+        OrderLine: {
+            id: string;
+            /** @enum {string} */
+            action: "add" | "renew" | "modify" | "remove";
+            /** @description Which service holds the thing, for example `compute`. */
+            service: string;
+            /** @description That service's own catalogue identifier for what was asked for. */
+            product_id: string;
+            /** Format: int64 */
+            quantity: number;
+        };
+        PrepaidAsset: {
+            id: string;
+            project_id: string;
+            /** @description Which service holds it. Also which console it is managed from. */
+            service: string;
+            /**
+             * @description That service's own catalogue id, not a billing sku. The price of a machine is made of
+             *     finer parts than the machine type — the type does not appear in the rate card at all.
+             */
+            product_id: string;
+            /** @description The id that service knows it by, so the two consoles can be lined up. */
+            resource_id?: string;
+            /**
+             * Format: int64
+             * @description GiB for a disk, 1 for a machine or an address.
+             */
+            quantity: number;
+            /**
+             * @description How long one period buys, as an ISO 8601 duration (P1M, P1Y).
+             *
+             *     There is no expiry to report. The engine keeps renewing this for as long as the seat is
+             *     held, so what runs out is not the term but the customer's decision to keep it. What the
+             *     next period costs, and when it is charged, is on the charges route — that is the engine's
+             *     own answer rather than a copy of it.
+             */
+            term: string;
+            /** @enum {string} */
+            state: "pending" | "active" | "suspended" | "terminated";
+            /**
+             * @description What it is being moved to. Differs from `state` while a change is still being applied,
+             *     which is the moment a customer is most likely to conclude that nothing happened.
+             * @enum {string}
+             */
+            desired_state: "active" | "suspended" | "terminated";
+        };
+        PrepaidAssetList: {
+            assets: components["schemas"]["PrepaidAsset"][];
+        };
+        RenewRequestBody: {
+            /**
+             * @description How long to renew for, as an ISO 8601 duration (P1M, P1Y). It does not have to match the
+             *     term originally bought.
+             */
+            term: string;
+            /**
+             * @description Generate one per renewal the customer starts — when the dialog opens, not when it is
+             *     submitted — and send the same one on every retry of that renewal.
+             */
+            idempotency_key: string;
+        };
+        OrderList: {
+            orders: components["schemas"]["Order"][];
+        };
+        TopUpList: {
+            top_ups: components["schemas"]["TopUpStatus"][];
+        };
+        CreditTransactionList: {
+            transactions: components["schemas"]["CreditTransaction"][];
+        };
+        /**
+         * @description One movement of credit. Immutable — a correction is another movement, never an edit of this
+         *     one, which is what lets the balance be recomputed from the list at any time
+         */
+        CreditTransaction: {
+            id: string;
+            type: components["schemas"]["CreditTransactionType"];
+            /** @description A decimal string. Never a float — a balance that rounds is a balance that drifts */
+            amount: string;
+            currency: string;
+            /**
+             * Format: date-time
+             * @description When it landed on the ledger, which is not always when it was requested
+             */
+            booked_at: string;
+            /**
+             * @description What the balance became. Recorded by the metering engine rather than recomputed here —
+             *     recomputing assumes our understanding of the burn-down order matches its own, and this
+             *     is its own account of it
+             */
+            balance_after: string;
+        };
+        /**
+         * @description `funded` is credit arriving, `consumed` is it being spent, `expired` is a grant reaching the
+         *     end of its life unspent, and `voided` is one cancelled — a refund, or a correction
+         * @enum {string}
+         */
+        CreditTransactionType: "funded" | "consumed" | "expired" | "voided";
+        /**
+         * @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 The account a project's resources are charged to */
+        ProjectBillingAccount: {
+            account_key: string;
+            project_id: string;
+            display_name: string;
+            currency: components["schemas"]["Currency"];
+            /**
+             * @description Whether the caller owns this account, and therefore whether the balance routes will
+             *     answer for it. False means someone else pays for this project: the figures are theirs,
+             *     not the caller's, and a page should say so rather than showing nothing.
+             */
+            owned_by_me: boolean;
+        };
+        /** @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;
+        };
+        PaymentMethodSetupSession: {
+            /**
+             * @description Initialises the provider's JavaScript, which mounts its form in an iframe on this page.
+             *
+             *     Not a URL: the form is embedded rather than redirected to, so the account holder stays
+             *     on the console. It expires, so fetch it when the form is about to be shown rather than
+             *     when the page loads.
+             */
+            client_secret: string;
+            /**
+             * @description Identifies this platform to the provider's JavaScript. Public by design.
+             *
+             *     It comes from here rather than from the browser bundle because it has to match the
+             *     account and the mode of the key the session was created with. Baking it into the build
+             *     makes one image unusable against the other mode, and the mismatch shows up as a form
+             *     that never loads.
+             */
+            publishable_key: string;
+            /**
+             * @description The provider's id for this attempt.
+             *
+             *     The browser does not need it — the callback carries the same id and is what actually
+             *     records the method. It is here so that a support conversation about one failed attempt
+             *     has something to look it up by.
+             */
+            session_id?: string;
+        };
+        /**
+         * @description One saved way of collecting money later, without the account holder present.
+         *
+         *     Deliberately not called a card: a card is one kind, and direct debit and the recurring
+         *     mandates offered by regional wallets occupy the same slot.
+         */
+        PaymentMethod: {
+            /** @description The provider's id for it. Used to remove it or make it the default */
+            id: string;
+            /** @description Visa, Mastercard, and so on. Empty for kinds that have no brand */
+            brand?: string;
+            /**
+             * @description The last four digits, for telling two saved methods apart.
+             *
+             *     This and the expiry are the only parts of the instrument that exist here. The number,
+             *     the expiry the holder typed and the CVC never reach this platform.
+             */
+            last4?: string;
+            /** Format: int32 */
+            exp_month?: number;
+            /**
+             * Format: int32
+             * @description Together with `exp_month`, when this stops working.
+             *
+             *     Worth showing because the failure is otherwise invisible: the card expires, the invoice
+             *     fails, dunning runs out, and the project stops — with nothing pointing at the card.
+             */
+            exp_year?: number;
+            /**
+             * @description True for the one an invoice is collected from.
+             *
+             *     Exactly one is the default while any exist. An account whose only method was removed
+             *     has none, and its next invoice cannot be collected.
+             */
+            default: boolean;
+        };
+        PaymentMethodList: {
+            payment_methods: components["schemas"]["PaymentMethod"][];
+        };
+        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;
+            /**
+             * @description Which meter it is for, when the charge came from usage. A hash, not something to show —
+             *     it is here so two rows can be told apart programmatically and so support can line a row
+             *     up with the catalogue.
+             */
+            feature_key?: string;
+            /**
+             * @description Whether this figure moves. A usage charge climbs through the period; a flat fee does not.
+             *     Without it, the same number on two refreshes could mean "nobody used it" or "it never
+             *     moves", and those need different next steps.
+             * @enum {string}
+             */
+            type: "usage_based" | "flat_fee";
+            /**
+             * Format: date-time
+             * @description Start of the service period this charge covers.
+             *
+             *     This is what tells two same-named rows apart. Something billed by the hour produces
+             *     hundreds of identically named charges in a month, and a list carrying only a name and an
+             *     amount shows them as a wall of duplicates — which is what it looks like today.
+             */
+            period_from: string;
+            /**
+             * Format: date-time
+             * @description End of the service period this charge covers.
+             */
+            period_to: string;
+            /**
+             * @description How much of this charge was covered by credit, as a decimal string.
+             *
+             *     It is the answer to "I have a balance, why am I still being charged". Without it the
+             *     customer sees a number that disagrees with what they expected and the only thing that
+             *     explains it is on our side.
+             */
+            credits?: string;
+            /**
+             * @description How much was taken off by a discount, as a decimal string. A usage allowance (the first N
+             *     units free) lands here too.
+             */
+            discounts?: string;
+            /** @description Free text from the charge, usually empty. Set on charges raised by hand. */
+            description?: string;
+            /**
+             * @description What one unit costs, as a decimal string. Absent when the line has no single unit price
+             *     — a flat fee, or a tiered price whose rate changes with volume.
+             *
+             *     The conversion between reported and billed quantity is deliberately not here: the engine
+             *     does not echo it back on a charge, only on an invoice line. So a charge answers "what
+             *     does a unit cost", and an invoice answers "how the total was reached".
+             */
+            unit_price?: string;
+        };
+        /** @description What produced one charge */
+        ChargeUsage: {
+            charge_id: string;
+            /**
+             * @description Total reported quantity for the period, as a decimal string. Empty on a charge with no
+             *     meter behind it.
+             *
+             *     Reported, not billed: see the route's description.
+             */
+            quantity: string;
+            /**
+             * @description The same quantity split by project. Empty when the charge has no meter behind it — a
+             *     flat fee has nothing to attribute.
+             */
+            by_project: components["schemas"]["ProjectUsage"][];
+            /**
+             * @description Resources of this product in the account's projects — candidates for what produced the
+             *     charge, not a per-resource breakdown. Absent when billing could not look them up; the
+             *     charge itself is still answered.
+             */
+            resources?: components["schemas"]["ChargeResource"][];
+        };
+        ProjectUsage: {
+            project_id: string;
+            /** @description Decimal string. */
+            quantity: string;
+        };
+        ChargeResource: {
+            project_id: string;
+            /** @description Which service holds it, and therefore which console manages it. */
+            service: string;
+            product_id: string;
+            resource_id: string;
+            /** @enum {string} */
+            state: "pending" | "active" | "suspended" | "terminated";
+        };
+        ChargeList: {
+            currency: components["schemas"]["Currency"];
+            charges: components["schemas"]["Charge"][];
+            /**
+             * Format: int64
+             * @description How many charges there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
+            /**
+             * @description The sum over the **whole period**, not this page — it is the same number as `unsettled`
+             *     on the balance, and paging must not change it. A page-scoped sum would disagree with the
+             *     balance card sitting next to it, and there would be no way to tell which one to believe.
+             */
+            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 The billed quantity for this line, as a decimal string — after conversion. A machine
+             *     billed by the hour reports machine-seconds; this is machine-hours.
+             *
+             *     It comes from the line's detailed segments summed together: the engine splits a line
+             *     into segments (different cost categories, different sub-periods) and the quantity lives
+             *     on those.
+             */
+            quantity?: string;
+            /**
+             * @description What one unit cost, as a decimal string, frozen at billing time. Absent on a flat fee,
+             *     whose amount is the amount, and on tiered prices, whose rate changes with volume.
+             */
+            unit_price?: string;
+            /**
+             * @description How reported quantity became billed quantity — 3600 for a machine billed by the hour
+             *     from machine-seconds, 1000000 for a price per million tokens.
+             *
+             *     Without it, `quantity` disagrees with what the customer remembers doing, by whole orders
+             *     of magnitude, and there is nothing on the page that explains the gap.
+             */
+            conversion_factor?: string;
+            /**
+             * @description What was done with the factor.
+             * @enum {string}
+             */
+            conversion_operation?: "divide" | "multiply";
+            /** @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 Which asset, from the prepaid list */
+        ProvisionId: string;
+        /**
+         * @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"];
+                };
+            };
+        };
+    };
+    "get-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"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        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"];
+                };
+            };
+        };
+    };
+    "update-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"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateBillingAccountRequestBody"];
+            };
+        };
+        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"];
+                };
+            };
+        };
+    };
+    "list-credit-transactions": {
+        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"]["CreditTransactionList"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    "unbind-project-from-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 to stop paying for */
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Unbound */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-orders": {
+        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"]["OrderList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-order": {
+        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"];
+                orderId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Order"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-top-ups": {
+        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"]["TopUpList"];
+                };
+            };
+            /** @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?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: number;
+                /**
+                 * @description How many charges per page. Defaults to a full page.
+                 *
+                 *     Charge count grows with resource count — an account running dozens of machines produces
+                 *     hundreds of lines in a period, and a screen shows a dozen. Fetching all of them on every
+                 *     visit carries data nothing displays.
+                 */
+                page_size?: number;
+            };
+            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"];
+                };
+            };
+        };
+    };
+    "get-charge-usage": {
+        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 Which charge, from the charges list */
+                chargeId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChargeUsage"];
+                };
+            };
+            /** @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-project-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The project being worked in */
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ProjectBillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "quote-project-usage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["QuoteRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Quote"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "quote-usage": {
+        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"]["QuoteRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Quote"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    "list-payment-methods": {
+        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"]["PaymentMethodList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "start-payment-method-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"]["PaymentMethodSetupSession"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "remove-payment-method": {
+        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"];
+                paymentMethodId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Removed */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "set-default-payment-method": {
+        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"];
+                paymentMethodId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Updated */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    "list-prepaid-assets": {
+        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"]["PrepaidAssetList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+}