@leaflow/sdk 0.0.0-dev.101.g01ce843

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

@@ -0,0 +1,2445 @@
+/**
+ * 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}/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}/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-method": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Whether this account can be charged
+         * @description Answers whether a payment method is on file, and nothing else.
+         *
+         *     ## It is a payment method, not a card
+         *
+         *     A card is one kind. Direct debit and the recurring-payment mandates offered by regional
+         *     wallets are others, and they occupy the same slot: something the provider can charge later
+         *     without the account holder present. Naming the slot after cards would put an assumption
+         *     into the contract that stops being true the day a second kind is accepted.
+         *
+         *     ## Why there is no brand, no last four digits, no expiry
+         *
+         *     Those would have to be read from the payment provider, and the two answers can disagree: a
+         *     method present at the provider that the billing engine has not recorded as the default is
+         *     exactly the state in which money cannot be collected — while a page built on the provider's
+         *     answer would be showing one. What matters here is whether the party that will run the
+         *     charge believes it can, so the answer comes from that party alone.
+         *
+         *     To see it, replace it, or remove it, open the billing portal.
+         *
+         *     ## Read this before offering a paid plan, not after
+         *
+         *     `ready` being false is why the engine refuses to start a paid subscription. Discovering it
+         *     at purchase time turns a missing payment method into a rejection whose wording is about
+         *     something else entirely.
+         *
+         *     An account that has never had one returns `ready: false`. That is the normal state of a
+         *     new account, not an error.
+         */
+        get: operations["read-payment-method"];
+        put?: never;
+        /**
+         * Add or replace the payment method on file
+         * @description Begins adding a payment method. Returns a URL to send the browser to; the details are
+         *     entered there, on the payment provider's own page, and **no card data ever reaches this
+         *     platform**.
+         *
+         *     Which kinds are offered is the provider's decision, not this API's — a card today, a
+         *     wallet mandate or a direct debit wherever the provider supports charging one later without
+         *     the account holder present.
+         *
+         *     ## This is a prerequisite for buying a plan, not a convenience
+         *
+         *     A plan is charged by invoice, and the invoice is collected from the method on file. A
+         *     subscription cannot start for an account that has none — so "add a payment method, then
+         *     buy" is the order the system requires, not a flow that was chosen.
+         *
+         *     It is *not* a prerequisite for topping up: a top-up collects the money there and then.
+         *
+         *     Replacing uses the same operation. The new method becomes the default and the old one stops
+         *     being used; nothing else about the account changes.
+         */
+        post: operations["start-payment-method-setup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/billing-portal": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Open the hosted billing portal
+         * @description Returns a URL to the payment provider's own portal, where the card can be replaced or
+         *     removed, the billing address changed, and past invoices downloaded.
+         *
+         *     ## Why replacing a card is not a form on this platform
+         *
+         *     A form would mean a card number field, and no card data ever reaches this platform. The
+         *     portal moves the whole interaction to the provider; only a session URL comes back.
+         *
+         *     ## Something has to be able to replace an expiring card
+         *
+         *     Cards expire. Once one does, the invoices for a plan stop being collectable, dunning runs
+         *     out, and the projects paid for by this account are suspended for non-payment. Without this
+         *     operation the account holder watches that happen with nowhere to fix it — adding a card
+         *     does not help, since that operation only makes sense when there is none.
+         *
+         *     The URL is single-use and expires. Do not store it.
+         */
+        post: operations["start-billing-portal"];
+        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, and when it runs out
+         * @description Everything this account paid a term for, across every product, soonest to expire first.
+         *
+         *     ## Why this is one list rather than a page inside each product
+         *
+         *     Renewal is the one thing a customer forgets, and forgetting it stops the machine. Splitting
+         *     the list per product means the instance about to lapse tomorrow is only visible to someone
+         *     who thought to go and look at instances. Sorting by expiry rather than by purchase date is
+         *     the same reason: the row that matters is the one at the top.
+         *
+         *     ## Metered resources are not here
+         *
+         *     There is no term to run out. Listing them with an empty expiry 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 because its term lapsed reads `suspended` for both. One that has just been
+         *     renewed reads `suspended` and `active` — it is on its way back. 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;
+    };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal-quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What renewing this would cost
+         * @description Priced the same way the charge is, from the same table, so the number shown is the number
+         *     taken. Quoting separately from charging is what lets a customer see the price before
+         *     committing; computing it twice in two places is what makes the two disagree, and a bill that
+         *     disagrees with the page that sold it is a complaint rather than a bug report.
+         *
+         *     ## Both the current and the resulting expiry are returned
+         *
+         *     Renewing early adds the term to what is left, not to today — otherwise renewing a month
+         *     ahead throws that month away, and everyone learns to wait until the last moment. Something
+         *     that lapsed long ago is counted from now instead, because adding to a date in the past
+         *     produces an expiry that is still in the past.
+         *
+         *     Reporting only the new date leaves the customer unable to tell which of those happened.
+         *
+         *     ## A withdrawn price still quotes
+         *
+         *     Taking a product off sale means stop selling new ones. Refusing renewals as well would stop
+         *     a batch of existing machines on their expiry date, which is not what the operator pressed
+         *     that button for.
+         */
+        get: operations["quote-renewal"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renew": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Renew it
+         * @description Takes the money from the balance and pushes the expiry out. The resource itself is not
+         *     touched — nothing is rebuilt, nothing restarts, the id stays the same.
+         *
+         *     ## An idempotency key is required, not optional
+         *
+         *     Renewal is a pure charge. Unlike creating something, there is no resource whose uniqueness
+         *     catches a repeat, so a double click is two charges and twice the term — and both calls
+         *     return success. Letting the field be omitted would mean losing that protection silently, in
+         *     the one case that looks completely normal until the books are reconciled.
+         *
+         *     Sending the same key again returns the order that was already placed. It does not charge
+         *     again, and it is not an error: reporting a repeat as a failure makes the caller retry
+         *     forever, and makes the customer press the button a second time with a fresh key.
+         *
+         *     ## What happens if the balance is short
+         *
+         *     The order is recorded as failed and nothing else changes: no money moves, the expiry stays
+         *     where it was, and the resource keeps running until its existing term ends. Retrying with the
+         *     same key after topping up goes through.
+         *
+         *     ## Renewing something that already lapsed brings it back
+         *
+         *     Its term is counted from now, and it is asked to start again. Coming back is the
+         *     reconciliation loop's job, so it is not instant — which is what `desired_state` on the asset
+         *     list is for.
+         */
+        post: operations["renew-prepaid-asset"];
+        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: {
+            /** @description Use this to quote and to renew. */
+            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;
+            /**
+             * Format: date-time
+             * @description Paid up to this instant. It stops being served after it, not before.
+             */
+            term_end: 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 —
+             *     in particular right after a renewal, 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"][];
+        };
+        RenewalQuote: {
+            provision_id: string;
+            term: string;
+            /**
+             * @description A decimal string, not a float. Money that survives a round trip through binary floating
+             *     point is money that stops adding up.
+             */
+            amount: string;
+            currency: string;
+            /**
+             * Format: date-time
+             * @description What it is paid up to now.
+             */
+            current_term_end: string;
+            /**
+             * Format: date-time
+             * @description What it would be paid up to after renewing.
+             */
+            term_end: string;
+        };
+        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 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: {
+            /**
+             * Format: uri
+             * @description Send the browser here. It expires, so do not store it
+             */
+            url: string;
+        };
+        BillingPortalSession: {
+            /**
+             * Format: uri
+             * @description Send the browser here. It expires, so do not store it
+             */
+            url: string;
+        };
+        /**
+         * @description Whether money can be collected from this account later, without the account holder present.
+         *
+         *     Deliberately not called a card: a card is one kind of payment method, and direct debit and
+         *     the recurring mandates offered by regional wallets occupy the same slot.
+         */
+        PaymentMethod: {
+            /**
+             * @description True when the billing engine holds a default payment method for this account and can
+             *     therefore collect an invoice.
+             *
+             *     This is the precondition for a paid plan. While it is false, starting a paid
+             *     subscription is refused, and the refusal is about billing setup rather than about the
+             *     plan — so check this first and say what is actually missing.
+             *
+             *     It says nothing about which kind is on file. To show or change that, send the account
+             *     holder to the billing portal.
+             *
+             *     A free plan does not require it, which is what allows a new account to be placed on the
+             *     default tier before anyone has entered a card.
+             */
+            ready: boolean;
+        };
+        TopUpSession: {
+            /**
+             * @description Identifies this attempt. Quote it in a support conversation — it is what ties the payment
+             *     provider's record to the credit that was granted
+             */
+            payment_id: string;
+            /**
+             * Format: uri
+             * @description Send the browser here. It expires, so do not store it
+             */
+            url: string;
+        };
+        /** @description One thing this period has been charged for */
+        Charge: {
+            id: string;
+            name: string;
+            /**
+             * @description Decimal string, the real-time figure. The booked figure would show a machine that only
+             *     just started as zero
+             */
+            total: string;
+        };
+        ChargeList: {
+            currency: components["schemas"]["Currency"];
+            charges: components["schemas"]["Charge"][];
+            /** @description The sum, which is the same number as `unsettled` on the balance */
+            total: string;
+        };
+        /** @enum {string} */
+        InvoiceStatus: "draft" | "issuing" | "issued" | "payment_processing" | "overdue" | "paid" | "uncollectible" | "voided";
+        Invoice: {
+            id: string;
+            number?: string;
+            status: components["schemas"]["InvoiceStatus"];
+            currency: components["schemas"]["Currency"];
+            total: string;
+            /** Format: date-time */
+            due_at?: string;
+            /** Format: date-time */
+            issued_at?: string;
+            /** Format: date-time */
+            created_at: string;
+        };
+        InvoiceList: {
+            invoices: components["schemas"]["Invoice"][];
+        };
+        InvoiceLine: {
+            name: string;
+            description?: string;
+            /**
+             * Format: date-time
+             * @description Required. Lines of the same name repeat many times on one invoice — hundreds on an hourly
+             *     bill — and without the period they cannot be told apart
+             */
+            period_from: string;
+            /** Format: date-time */
+            period_to: string;
+            /** @description Before discounts and credit */
+            amount: string;
+            discounts_total?: string;
+            /** @description How much of this line credit covered */
+            credits_total?: string;
+            total: string;
+        };
+        InvoiceDetail: {
+            id: string;
+            number?: string;
+            status: components["schemas"]["InvoiceStatus"];
+            currency: components["schemas"]["Currency"];
+            total: string;
+            charges_total?: string;
+            discounts_total?: string;
+            credits_total?: string;
+            taxes_total?: string;
+            /** Format: date-time */
+            period_from?: string;
+            /** Format: date-time */
+            period_to?: string;
+            /** Format: date-time */
+            due_at?: string;
+            /** Format: date-time */
+            issued_at?: string;
+            /** Format: date-time */
+            created_at: string;
+            lines: components["schemas"]["InvoiceLine"][];
+        };
+        Subscription: {
+            id: string;
+            plan_key: string;
+            plan_version?: number;
+            /**
+             * @description `canceled` still counts as being on a plan — it is serving until the end of the period,
+             *     which has already been paid for
+             */
+            status: string;
+        };
+        TopUpStatus: {
+            payment_id: string;
+            /**
+             * @description `settled` means the credit has landed. `pending` means it has not yet — the payment is
+             *     still being confirmed, or the money itself is still in transit
+             * @enum {string}
+             */
+            state: "settled" | "pending";
+            /** @description The credit that was issued, present once settled */
+            amount?: string;
+            currency?: components["schemas"]["Currency"];
+        };
+        /**
+         * @description ISO 4217, uppercase. `USD` is the only value the platform issues today, and a request
+         *     naming any other is refused with `BILLING_CURRENCY_UNSUPPORTED`.
+         *
+         *     Deliberately not an enumeration. The set of currency codes is governed outside this API, so
+         *     a client generated today must still be able to read a response naming a code added later —
+         *     an enumeration turns that response into a decode failure in a client nobody can redeploy.
+         *     Restricting what may be *sent* is a rule about what the platform supports, and it lives
+         *     where that rule can change without regenerating anything.
+         */
+        Currency: string;
+    };
+    responses: never;
+    parameters: {
+        /** @description 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?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChargeList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-invoices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InvoiceList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-invoice": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                invoiceId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InvoiceDetail"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "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"];
+                };
+            };
+        };
+    };
+    "read-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"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PaymentMethod"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    "start-billing-portal": {
+        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"]["BillingPortalSession"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    "quote-renewal": {
+        parameters: {
+            query: {
+                /**
+                 * @description How long to renew for, as an ISO 8601 duration (P1M, P1Y). A duration rather than a
+                 *     number of months: months are not the same length.
+                 */
+                term: string;
+            };
+            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 asset, from the prepaid list */
+                provisionId: components["parameters"]["ProvisionId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RenewalQuote"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "renew-prepaid-asset": {
+        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 asset, from the prepaid list */
+                provisionId: components["parameters"]["ProvisionId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RenewRequestBody"];
+            };
+        };
+        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"];
+                };
+            };
+        };
+    };
+}