@leaflow/sdk 0.52.0 → 0.54.0

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

@@ -123,6 +123,44 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}/balance/movement": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * How the balance moved this month
+         * @description Opening balance, money in, money out, closing balance — for the current calendar month.
+         *
+         *     **The four add up**: `closing = opening + income - spending`. That is the point of the
+         *     endpoint. The balance alone answers "how much is left" and cannot answer "how did it get
+         *     there", which is what somebody watching their balance shrink is actually asking. Four
+         *     figures that add up can be checked by the holder; a single figure can only be taken on
+         *     faith or queried with support.
+         *
+         *     `closing` is computed from the other three rather than read separately. Reading the current
+         *     balance for it would leave the equation off by whatever was booked between the two reads —
+         *     and an equation that is off by a few cents is worse than no equation, because it puts the
+         *     ledger itself in doubt.
+         *
+         *     The window is the **calendar** month, not the engine's billing period. This is the month a
+         *     person means when they say "this month"; the billing anchor is an internal recurrence that
+         *     happens to line up.
+         *
+         *     A month with no movement reports opening equal to closing and zero on both sides — not all
+         *     zeroes, which would read as "your money is gone".
+         */
+        get: operations["read-billing-account-balance-movement"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/account/v1/billing-accounts/{accountKey}/projects/{projectId}": {
         parameters: {
             query?: never;
@@ -182,8 +220,8 @@ export interface paths {
          *     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.
+         *     Lines come with each order. A list showing only identifiers and amounts is a page nobody can
+         *     read — recognising one ("which of these was last week's machine") is why it gets opened.
          */
         get: operations["list-orders"];
         put?: never;
@@ -203,8 +241,8 @@ export interface paths {
         };
         /**
          * 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.
+         * @description Each line names what was asked for, how much of it, and what it produced. The list route
+         *     carries lines too; this one exists for a permanent link to a single transaction.
          */
         get: operations["get-order"];
         put?: never;
@@ -538,6 +576,36 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}/subscription/keep": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Undo an end-of-period cancellation
+         * @description Takes back a cancellation that was set for the end of the period, so the plan carries on.
+         *
+         *     **It only works on a cancellation, not on a scheduled downgrade.** Scheduling a change to
+         *     another plan leaves a second, scheduled subscription holding the customer's one slot, and the
+         *     engine offers no way to remove it: unscheduling is refused with a conflict and the scheduled
+         *     subscription cannot be deleted over HTTP. So a downgrade becomes final the moment it is
+         *     scheduled, and saying so up front is the only honest thing to do — this endpoint answers
+         *     `BILLING_NO_SCHEDULED_CHANGE` rather than pretending to undo it.
+         *
+         *     Without this, someone who cancels by accident has to wait out the period and buy the tier
+         *     again, losing whatever the tier had accumulated.
+         */
+        post: operations["keep-subscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/account/v1/billing-accounts/{accountKey}/subscription/cancel": {
         parameters: {
             query?: never;
@@ -549,12 +617,13 @@ export interface paths {
         put?: never;
         /**
          * Come off the paid plan
-         * @description Moves the account off whatever plan it is on.
+         * @description Takes the account off its paid plan and back to the free tier.
          *
-         *     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.
+         *     Ending immediately lands on the free tier straight away. Ending at the end of the period is a
+         *     plain cancellation that can still be undone (`subscription/keep`) — it deliberately does not
+         *     schedule a switch, because a scheduled switch holds the customer's one subscription slot and
+         *     the engine gives no way to cancel it afterwards. The free tier is applied once the period
+         *     actually ends, by the sweep that keeps every account on some plan.
          *
          *     `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
@@ -796,16 +865,19 @@ export interface paths {
          * What I bought outright
          * @description Everything this account holds on a term, across every product.
          *
-         *     ## Nothing here expires on its own
+         *     ## Every one of these expires
          *
-         *     A term renews for as long as the seat is held: the engine charges the next period, prorates
-         *     any change to the second, and stops the moment the seat is given up. So there is no renewal
-         *     to remember and no expiry to warn about — giving it up means deleting the resource, in the
-         *     console that owns it.
+         *     A term is paid for once, up front, and buys exactly the period named by `term`. Nothing
+         *     renews it on its own: `expires_at` is when it runs out, and after that the machine is
+         *     stopped and — once the retention window is over — released.
          *
-         *     What the next period costs and when it falls due is on the charges route. That is read
-         *     straight from the engine rather than copied here, because a copy is a second answer that
-         *     drifts without saying so.
+         *     This route used to say the opposite. It described an engine that charged the next period by
+         *     itself for as long as the seat was held, which is how this worked before the money became a
+         *     single up-front charge. Reading the old text, a customer would have had no reason to renew
+         *     anything, and the first sign of trouble would have been a stopped machine.
+         *
+         *     Turn on `auto_renew` to have billing place the renewal order itself while there is balance
+         *     to pay for it. That is the only thing that makes a term continue.
          *
          *     ## Metered resources are not here
          *
@@ -827,6 +899,137 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{assetId}/renew": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Buy another period
+         * @description Extends a term by one more period, paid for out of the account's balance right now.
+         *
+         *     **The new expiry is the old one plus the term, not now plus the term.** Renewing three days
+         *     early would otherwise throw those three days away, and renewing after the expiry would
+         *     quietly reward the delay. Neither shows up as an error — the date on the account looks
+         *     self-consistent either way, and only the customer notices.
+         *
+         *     `term` does not have to match what was bought originally: a monthly machine can be renewed
+         *     for a year.
+         *
+         *     Refused when the balance does not cover it. The alternative — placing the order and letting
+         *     the account go negative — turns a renewal the customer chose into a debt they did not.
+         */
+        post: operations["renew-prepaid-asset"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{assetId}/auto-renew": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Turn automatic renewal on or off
+         * @description With it on, billing places the renewal order itself a few days before the period runs out,
+         *     paying from the account's balance.
+         *
+         *     **Not enough balance is not an error here.** The switch only says what to attempt; whether
+         *     the money is there is settled at renewal time, and the customer is told either way — told it
+         *     renewed, or told it could not and by when it will expire.
+         */
+        put: operations["set-prepaid-auto-renew"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/promotion-codes/preview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * See what a code takes off before committing
+         * @description Runs the same checks and the same arithmetic that placing the order will run, so the price
+         *     shown here and the price charged agree. Writing the calculation twice — once for the page and
+         *     once for the order — means they drift, and the visible form of that drift is a page saying
+         *     "20 off" while the full amount is taken.
+         *
+         *     Nothing is redeemed. The allowance is only consumed when the order is actually placed.
+         *
+         *     A code that cannot be used is rejected here with the reason, so the user learns it before
+         *     filling in the rest of the form rather than at the moment they press buy.
+         *
+         *     **Metered orders are rejected.** They have no amount at this point — the money is worked out
+         *     later from usage. Applying a discount to a nil amount leaves the user believing they saved
+         *     something while the bill is unchanged.
+         */
+        post: operations["preview-promotion-code"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/vouchers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List this account's vouchers
+         * @description Credit received from campaigns, most recent first. Not the credit ledger — this says which
+         *     campaign each amount came from, which is the question "where did this 50 come from" that the
+         *     ledger cannot answer.
+         */
+        get: operations["list-account-vouchers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/refunds": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List this account's refunds
+         * @description Each refund carries how it was split. A customer asking "I was refunded 100, why is only 60
+         *     back on my card" is answered here and nowhere else.
+         */
+        get: operations["list-account-refunds"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -912,13 +1115,35 @@ export interface components {
             /** @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.
+             * @description The usages that 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
+             *     lands, the usage chart shows it, and the bill has no line for it.
+             *
+             *     ## Each entry carries the caller's own naming, not only the key
+             *
+             *     A meter key is a hash, and callers are told not to compute it (see `QuoteUsage`). An answer
+             *     that named the unpriced usages by key alone was therefore unusable whenever more than one
+             *     usage was priced at a time: the caller could see that something was unsold but not which of
+             *     the things it asked about. That is the case a catalogue page needs — pricing thirty machine
+             *     types in one call and marking the ones this plan does not sell — so the answer echoes the
+             *     `service` and `product_id` that were given
              */
-            unpriced?: string[];
+            unpriced?: components["schemas"]["UnpricedUsage"][];
+        };
+        /** @description One usage that has no rate card on the plan it was priced against. */
+        UnpricedUsage: {
+            /** @description The meter key this usage resolved to */
+            key: string;
+            /** @description Echoed from the request when the usage was named by service and product */
+            service?: string;
+            /** @description Echoed from the request when the usage was named by service and product */
+            product_id?: string;
+            /** @description Echoed from the request */
+            variant?: {
+                [key: string]: string;
+            };
         };
         /**
          * @description When a plan change takes effect. There is no default: an upgrade and a downgrade want opposite
@@ -927,6 +1152,15 @@ export interface components {
          */
         PlanChangeTiming: "immediate" | "next_billing_cycle";
         OfferList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             offers: components["schemas"]["Offer"][];
         };
         /**
@@ -945,6 +1179,15 @@ export interface components {
              * @description When this offer stops being purchasable. Absent means it does not expire
              */
             valid_until?: string;
+            /**
+             * @description The plan this offer sells, matching `plan_key` on the subscription. Present on offers
+             *     that sell a plan.
+             *
+             *     It is here so the pricing page can mark the tier the account is already on. Without it
+             *     the current tier looks like every other one, and the obvious thing to do — buy it — is
+             *     refused as a switch to the same plan
+             */
+            plan_key?: string;
             /** @description Present on offers that sell a plan */
             pricing?: components["schemas"]["Pricing"];
             /** @description Present on offers that sell credit */
@@ -971,6 +1214,21 @@ export interface components {
              *     one of those, last
              */
             phases: components["schemas"]["PricingPhase"][];
+            /**
+             * @description Credit handed out at the start of every period, as a decimal string in `currency`. Absent
+             *     when the tier comes with none.
+             *
+             *     It is what makes a paid tier worth buying — "$200 a month, and $200 of credit to spend" —
+             *     so leaving it off the pricing page turns that tier into a fee with nothing visibly
+             *     attached to it
+             */
+            included_credit?: string;
+            /**
+             * @description Whether unused credit is voided at the end of the period. Only meaningful alongside
+             *     `included_credit`, and worth showing either way: carried over, it accumulates, which is a
+             *     materially different offer at the same price
+             */
+            included_credit_expires?: boolean;
         };
         PricingPhase: {
             name: string;
@@ -1033,16 +1291,70 @@ export interface components {
              */
             amount?: string;
             currency?: string;
+            /**
+             * Format: date-time
+             * @description When the money for this order arrived. Absent on an order nothing was charged for, and on
+             *     one still waiting to be paid.
+             *
+             *     Separate from `created_at` because the two can be far apart: an order paid online is
+             *     created first and paid whenever the customer gets round to it. Merged into one field,
+             *     "how long did this sit unpaid" has no answer anywhere — and that is the number chasing
+             *     payment looks at.
+             */
+            paid_at?: string;
             /**
              * @description Always `none` on a metered order.
+             *
+             *     `pending` is an order paid for online whose money has not arrived yet: the checkout
+             *     session is open and nothing has been created. It was missing from this enum while the
+             *     column had it and the handler passed it through unchanged, so such an order read back
+             *     a value outside the enum — the one state where the caller most needs to know not to
+             *     expect the resource yet.
              * @enum {string}
              */
-            payment_state?: "none" | "paid" | "refunded";
+            payment_state?: "none" | "pending" | "paid" | "refunded";
             /** Format: date-time */
             created_at: string;
-            /** @description Only present on the single-order route. */
+            /**
+             * @description What this order was for. Present on the list route too — an order list that shows only
+             *     numbers and amounts is a page of identifiers with no content, and recognising one
+             *     ("which of these was last week's machine") is the reason anyone opens it.
+             */
             lines?: components["schemas"]["OrderLine"][];
         };
+        BalanceMovement: {
+            currency: components["schemas"]["Currency"];
+            /**
+             * Format: date-time
+             * @description Start of the window — the first instant of the current calendar month, UTC.
+             */
+            from: string;
+            /**
+             * Format: date-time
+             * @description End of the window, which is **now** rather than the month's end. The month is not over.
+             */
+            to: string;
+            /**
+             * @description The balance when the window opened, as a decimal string.
+             *
+             *     Taken from the earliest transaction in the window rather than read separately: every
+             *     transaction carries the balance before and after it, so this figure and the totals below
+             *     come from one read of one ledger and therefore agree.
+             */
+            opening: string;
+            /** @description What came in — top-ups and credit issued by operations. Never negative. */
+            income: string;
+            /**
+             * @description What went out — consumption and expiry. **Never negative**: the direction is in the
+             *     name, not in the sign. Signed, a client would have to handle both `-20` and `20` meaning
+             *     the same thing.
+             */
+            spending: string;
+            /** @description `opening + income - spending`. Computed, not read separately — see the endpoint. */
+            closing: string;
+            /** @description False when this account has no balance record in this currency at all, which is not the same as a zero balance. */
+            present: boolean;
+        };
         OrderLine: {
             id: string;
             /** @enum {string} */
@@ -1051,8 +1363,62 @@ export interface components {
             service: string;
             /** @description That service's own catalogue identifier for what was asked for. */
             product_id: string;
+            /**
+             * @description What this was called when it was ordered.
+             *
+             *     A snapshot, not a lookup. `product_id` is usually a uuid, and an order page that shows it
+             *     shows a string of hex. Asking the owning service for the name later is worse: it is a
+             *     cross-service call per row, and by then the product may have been renamed or withdrawn —
+             *     a bill has to answer "what did I buy", and that answer has to be in the words used at the
+             *     time.
+             *
+             *     Empty on orders placed before this was recorded, and on the rare call that omits it.
+             *     Fall back to `product_id`.
+             */
+            product_name: string;
+            /**
+             * @description What was configured on this line at the moment of sale, as key–value pairs meant for a
+             *     person to read.
+             *
+             *     **Free-form, not fixed fields.** Every service's products have their own dimensions — a
+             *     machine has cores and memory, a disk has capacity and medium, an address has bandwidth.
+             *     Fixed fields would mean adding more of them for every service that comes along, or
+             *     squeezing one service's answers into another's boxes.
+             *
+             *     Do not parse it. The keys are written for the reader, in the reader's language, and they
+             *     change when the wording changes. Anything a program needs to decide on is in
+             *     `product_id` and `quantity`.
+             */
+            configuration?: {
+                [key: string]: string;
+            };
             /** Format: int64 */
             quantity: number;
+            /**
+             * @description How this line is paid for: empty is by the hour, an ISO 8601 duration (`P1M`, `P1Y`) is
+             *     bought outright for that long.
+             *
+             *     Fixed at the moment of sale. The asset's own term can move afterwards (renewing can
+             *     change the period); this one cannot, because an order is a transaction that already
+             *     happened.
+             */
+            term: string;
+            /**
+             * Format: date-time
+             * @description Start of the period this line bought. **Absent when billed by the hour** — that has no
+             *     service period, and filling in "today to today" would state a term that does not exist.
+             */
+            service_period_from?: string;
+            /**
+             * Format: date-time
+             * @description End of the period this line bought. Absent when billed by the hour.
+             */
+            service_period_to?: string;
+            /**
+             * @description The resource this line produced, in the owning service's own identifiers. Absent until
+             *     that service reports it back, which is also the moment the line starts being billed.
+             */
+            resource_id?: string;
         };
         PrepaidAsset: {
             id: string;
@@ -1074,12 +1440,31 @@ export interface components {
             /**
              * @description How long one period buys, as an ISO 8601 duration (P1M, P1Y).
              *
-             *     There is no expiry to report. The engine keeps renewing this for as long as the seat is
-             *     held, so what runs out is not the term but the customer's decision to keep it. What the
-             *     next period costs, and when it is charged, is on the charges route — that is the engine's
-             *     own answer rather than a copy of it.
+             *     It is paid for once at purchase. Read it next to `expires_at`, which is when the period
+             *     actually runs out — the two are settled when the order is placed and neither moves on
+             *     its own.
              */
             term: string;
+            /**
+             * Format: date-time
+             * @description When the paid-for period runs out.
+             *
+             *     Settled when the order is placed, not when the resource lands, so a purchase paid for
+             *     online does not get a longer period by being paid later.
+             *
+             *     Absent means it was never settled — a row that has not finished being created. It is not
+             *     "does not expire": everything on this route does.
+             */
+            expires_at?: string;
+            /**
+             * @description Whether billing places the renewal order itself as the period runs out.
+             *
+             *     Off by default, and deliberately so: renewing charges the account, and a charge nobody
+             *     asked for is worse than an expiry that was warned about. With it on, the renewal is
+             *     placed only while there is balance to pay for it — when there is not, the customer is
+             *     told rather than put into debt.
+             */
+            auto_renew: boolean;
             /** @enum {string} */
             state: "pending" | "active" | "suspended" | "terminated";
             /**
@@ -1090,6 +1475,15 @@ export interface components {
             desired_state: "active" | "suspended" | "terminated";
         };
         PrepaidAssetList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             assets: components["schemas"]["PrepaidAsset"][];
         };
         RenewRequestBody: {
@@ -1104,13 +1498,43 @@ export interface components {
              */
             idempotency_key: string;
         };
+        AutoRenewRequestBody: {
+            auto_renew: boolean;
+        };
         OrderList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             orders: components["schemas"]["Order"][];
         };
         TopUpList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             top_ups: components["schemas"]["TopUpStatus"][];
         };
         CreditTransactionList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             transactions: components["schemas"]["CreditTransaction"][];
         };
         /**
@@ -1154,13 +1578,46 @@ export interface components {
             /** @description How much credit is granted. Equal to `pay` when there is no bonus */
             credit: string;
         };
+        /**
+         * @description The result of buying an offer — either it is done, or the money has to arrive first.
+         *
+         *     ## A paid tier is never granted before the money lands
+         *
+         *     A tier that charges a fee is paid for by card, not from the credit balance. Two reasons, and
+         *     the second is the one that decides it:
+         *
+         *     1. The engine bills a plan's fee **in arrears** — subscribing only records an unsettled
+         *        charge, while the tier's credit is handed over at once. Without payment first, an account
+         *        can subscribe, spend the credit, and walk away from an invoice nobody will pay.
+         *     2. Paying for the membership out of credit is a loop: the tier hands back credit of the same
+         *        value, so nothing the platform can bank ever enters. The membership fee is where real
+         *        money is supposed to arrive.
+         *
+         *     So `checkout_url` comes back instead of `subscription_id`, and the switch happens when the
+         *     payment does. The place on the offer is already held, so returning to it later finishes the
+         *     same purchase rather than starting a second one.
+         */
         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`
+             *     end of the period, this is the one that takes over then, and its status says `scheduled`.
+             *
+             *     Absent when payment is still needed — see `checkout_url`
              */
-            subscription_id: string;
+            subscription_id?: string;
+            /**
+             * @description Where to send the buyer to pay. Present exactly when the tier charges a fee and the
+             *     payment has not been made yet.
+             *
+             *     The switch is performed by the payment callback, so a client that ignores this and reads
+             *     `subscription_id` gets nothing — which is the intended failure: pretending the tier is
+             *     active before the money arrives is the thing this whole route exists to prevent
+             */
+            checkout_url?: string;
+            /** @description What the buyer is being sent to pay, in `currency`. Present with `checkout_url` */
+            amount_due?: string;
+            currency?: components["schemas"]["Currency"];
         };
         Error: {
             code?: string;
@@ -1188,6 +1645,15 @@ export interface components {
             project_ids: string[];
         };
         BillingAccountList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             /** @description Every account belonging to the caller. Empty when they hold none */
             accounts: components["schemas"]["BillingAccount"][];
         };
@@ -1286,11 +1752,11 @@ export interface components {
         };
         PaymentMethodSetupSession: {
             /**
-             * @description Initialises the provider's JavaScript, which mounts its form in an iframe on this page.
+             * @description Confirms this attempt from the browser, against the provider's own inputs.
              *
-             *     Not a URL: the form is embedded rather than redirected to, so the account holder stays
-             *     on the console. It expires, so fetch it when the form is about to be shown rather than
-             *     when the page loads.
+             *     Not a URL and not a hosted page: only the inputs come from the provider, so the
+             *     heading, the button and the styling around them are this platform's. It expires, so
+             *     fetch it when the form is about to be shown rather than when the page loads.
              */
             client_secret: string;
             /**
@@ -1309,7 +1775,7 @@ export interface components {
              *     records the method. It is here so that a support conversation about one failed attempt
              *     has something to look it up by.
              */
-            session_id?: string;
+            setup_id?: string;
         };
         /**
          * @description One saved way of collecting money later, without the account holder present.
@@ -1348,6 +1814,15 @@ export interface components {
             default: boolean;
         };
         PaymentMethodList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             payment_methods: components["schemas"]["PaymentMethod"][];
         };
         TopUpSession: {
@@ -1494,6 +1969,15 @@ export interface components {
             created_at: string;
         };
         InvoiceList: {
+            /**
+             * Format: int64
+             * @description How many entries there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
             invoices: components["schemas"]["Invoice"][];
         };
         InvoiceLine: {
@@ -1566,12 +2050,60 @@ export interface components {
         Subscription: {
             id: string;
             plan_key: string;
+            /** @description What this tier is called on the pricing page */
+            plan_name?: 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;
+            /**
+             * Format: date-time
+             * @description Start of the period being served. Absent for the moment right after subscribing, while
+             *     the engine is still writing the charge this is read from — absent means "not known yet"
+             *     rather than "no period"
+             */
+            current_period_start?: string;
+            /**
+             * Format: date-time
+             * @description End of the period being served, which is also when the next charge falls and when
+             *     anything scheduled takes effect
+             */
+            current_period_end?: string;
+            /**
+             * @description What takes over at the end of the period, when a downgrade has been scheduled.
+             *
+             *     Absent when nothing is pending. Leaving it out entirely would show someone who has
+             *     already scheduled a downgrade the tier they are on today, so they would schedule it
+             *     again.
+             */
+            scheduled?: components["schemas"]["ScheduledPlan"];
+            /**
+             * @description True once the account has been taken off its paid plan at the end of the period. It is
+             *     still being served until then, and this can still be undone — unlike a scheduled
+             *     downgrade
+             */
+            cancels_at_period_end?: boolean;
+            /**
+             * @description True when this is the free tier every account starts on.
+             *
+             *     Coming off it is not a thing that can happen: cancelling puts the account back on it, so
+             *     offering that as an action is at best a no-op and at worst a gap — between the period
+             *     ending and the sweep putting the tier back, the account has no plan at all and admission
+             *     refuses it. A console reads this to leave the action out.
+             */
+            is_default_plan?: boolean;
+        };
+        ScheduledPlan: {
+            plan_key: string;
+            plan_name?: string;
+            plan_version?: number;
+            /**
+             * Format: date-time
+             * @description When it takes over, which is the end of the current period
+             */
+            starts_at?: string;
         };
         TopUpStatus: {
             payment_id: string;
@@ -1596,9 +2128,113 @@ export interface components {
          *     where that rule can change without regenerating anything.
          */
         Currency: string;
+        PreviewPromotionCodeRequestBody: {
+            /** @description Case and surrounding whitespace do not matter. */
+            code: string;
+            /**
+             * Format: uuid
+             * @description Which project the order will be placed against — the price depends on its plan.
+             */
+            project_id: string;
+            /**
+             * @description The same lines the order will carry. The discount is computed over the ones in scope,
+             *     not the whole order, so leaving lines out changes the answer.
+             */
+            lines: components["schemas"]["PromotionPreviewLine"][];
+        };
+        /**
+         * @description One line of the order being previewed. Only what pricing and scope need — this is not the
+         *     order itself, and carrying the whole order here would mean two places that have to agree on
+         *     what an order looks like.
+         */
+        PromotionPreviewLine: {
+            service: string;
+            product_id: string;
+            /**
+             * @description ISO 8601 duration for a prepaid line. Empty means metered, and a metered line
+             *     contributes nothing to the discount — it has no amount at this point.
+             */
+            term?: string;
+            /** @default 1 */
+            quantity?: number;
+        };
+        PromotionPreview: {
+            /** @description The code as stored, upper-cased. */
+            code: string;
+            /** @description The campaign's name, to show next to the price. */
+            name?: string;
+            /** @enum {string} */
+            kind: "voucher" | "discount";
+            /** @description How much comes off this order, or how much credit is granted. */
+            benefit_amount: string;
+            /**
+             * @description The part of the order the discount applies to. Shown so "why did only 12 come off a 200
+             *     order" has an answer on the page rather than in a support ticket.
+             */
+            discount_base?: string;
+            original_amount: string;
+            /** @description What will actually be charged. This is the number to show as the price. */
+            payable_amount: string;
+            currency: string;
+        };
+        Voucher: {
+            /** Format: uuid */
+            redemption_id: string;
+            promotion_key: string;
+            name?: string;
+            amount: string;
+            currency: string;
+            /** Format: date-time */
+            granted_at: string;
+        };
+        VoucherList: {
+            items: components["schemas"]["Voucher"][];
+            total_count?: number;
+        };
+        AccountRefund: {
+            /** Format: uuid */
+            refund_id: string;
+            /** Format: uuid */
+            order_id?: string | null;
+            total_amount: string;
+            currency: string;
+            /**
+             * @description `partial` means some of it is back and some is not. Showing it as "refunded" would have
+             *     the customer looking for money that has not moved.
+             * @enum {string}
+             */
+            state: "pending" | "settled" | "partial";
+            legs: components["schemas"]["AccountRefundLeg"][];
+            /** Format: date-time */
+            created_at: string;
+        };
+        AccountRefundLeg: {
+            /** @enum {string} */
+            kind: "cash" | "voucher" | "balance";
+            amount: string;
+            currency: string;
+            /** @enum {string} */
+            state: "pending" | "done" | "failed";
+            /** Format: date-time */
+            settled_at?: string | null;
+        };
+        AccountRefundList: {
+            items: components["schemas"]["AccountRefund"][];
+            total_count?: number;
+        };
     };
     responses: never;
     parameters: {
+        /** @description 1-based page number; the first page when omitted. */
+        Page: number;
+        /**
+         * @description How many entries per page, at most 100.
+         *
+         *     Every list here grows without bound — charges with resources, transactions with time. A list
+         *     that returns everything works on the account it was written against and quietly turns into a
+         *     multi-megabyte response on the one that has been running for a year.
+         */
+        PageSize: number;
         /** @description Which asset, from the prepaid list */
         ProvisionId: string;
         /**
@@ -1615,7 +2251,18 @@ export type $defs = Record<string, never>;
 export interface operations {
     "list-billing-accounts": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -1751,7 +2398,18 @@ export interface operations {
     };
     "list-credit-transactions": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -1819,6 +2477,41 @@ export interface operations {
             };
         };
     };
+    "read-billing-account-balance-movement": {
+        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"]["BalanceMovement"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "bind-project-to-billing-account": {
         parameters: {
             query?: never;
@@ -1893,7 +2586,18 @@ export interface operations {
     };
     "list-orders": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -1964,7 +2668,18 @@ export interface operations {
     };
     "list-top-ups": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -2040,15 +2755,15 @@ export interface operations {
         parameters: {
             query?: {
                 /** @description 1-based page number; the first page when omitted. */
-                page?: number;
+                page?: components["parameters"]["Page"];
                 /**
-                 * @description How many charges per page. Defaults to a full page.
+                 * @description How many entries per page, at most 100.
                  *
-                 *     Charge count grows with resource count — an account running dozens of machines produces
-                 *     hundreds of lines in a period, and a screen shows a dozen. Fetching all of them on every
-                 *     visit carries data nothing displays.
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
                  */
-                page_size?: number;
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path: {
@@ -2121,7 +2836,18 @@ export interface operations {
     };
     "list-invoices": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -2331,6 +3057,41 @@ export interface operations {
             };
         };
     };
+    "keep-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: {
@@ -2408,7 +3169,18 @@ export interface operations {
     };
     "list-payment-methods": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -2546,7 +3318,18 @@ export interface operations {
     };
     "list-offers": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -2621,7 +3404,18 @@ export interface operations {
     };
     "list-prepaid-assets": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 /**
@@ -2654,4 +3448,217 @@ export interface operations {
             };
         };
     };
+    "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 */
+                assetId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RenewRequestBody"];
+            };
+        };
+        responses: {
+            /** @description Renewed */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PrepaidAsset"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "set-prepaid-auto-renew": {
+        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 */
+                assetId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AutoRenewRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PrepaidAsset"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "preview-promotion-code": {
+        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"]["PreviewPromotionCodeRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PromotionPreview"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-account-vouchers": {
+        parameters: {
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
+            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"]["VoucherList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-account-refunds": {
+        parameters: {
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: components["parameters"]["Page"];
+                /**
+                 * @description How many entries per page, at most 100.
+                 *
+                 *     Every list here grows without bound — charges with resources, transactions with time. A list
+                 *     that returns everything works on the account it was written against and quietly turns into a
+                 *     multi-megabyte response on the one that has been running for a year.
+                 */
+                page_size?: components["parameters"]["PageSize"];
+            };
+            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"]["AccountRefundList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
 }