@leaflow/sdk 0.49.0 → 0.51.0

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

@@ -56,12 +56,10 @@ export type CancelSubscriptionResult = operations["cancel-subscription"]["respon
 export type CancelSubscriptionQuery = operations["cancel-subscription"]["parameters"]["query"];
 /** `GET /account/v1/billing-accounts/{accountKey}/top-ups/{paymentId}` 成功时的响应体。 */
 export type ReadTopUpResult = operations["read-top-up"]["responses"][200]["content"]["application/json"];
-/** `GET /account/v1/billing-accounts/{accountKey}/payment-method` 成功时的响应体。 */
-export type ReadPaymentMethodResult = operations["read-payment-method"]["responses"][200]["content"]["application/json"];
-/** `POST /account/v1/billing-accounts/{accountKey}/payment-method` 成功时的响应体。 */
+/** `GET /account/v1/billing-accounts/{accountKey}/payment-methods` 成功时的响应体。 */
+export type ListPaymentMethodsResult = operations["list-payment-methods"]["responses"][200]["content"]["application/json"];
+/** `POST /account/v1/billing-accounts/{accountKey}/payment-methods` 成功时的响应体。 */
 export type StartPaymentMethodSetupResult = operations["start-payment-method-setup"]["responses"][200]["content"]["application/json"];
-/** `POST /account/v1/billing-accounts/{accountKey}/billing-portal` 成功时的响应体。 */
-export type StartBillingPortalResult = operations["start-billing-portal"]["responses"][200]["content"]["application/json"];
 /** `GET /account/v1/billing-accounts/{accountKey}/offers` 成功时的响应体。 */
 export type ListOffersResult = operations["list-offers"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts/{accountKey}/offers/{offerKey}/purchase` 成功时的响应体。 */
@@ -70,11 +68,3 @@ export type PurchaseOfferResult = operations["purchase-offer"]["responses"][200]
 export type PurchaseOfferQuery = operations["purchase-offer"]["parameters"]["query"];
 /** `GET /account/v1/billing-accounts/{accountKey}/prepaid-assets` 成功时的响应体。 */
 export type ListPrepaidAssetsResult = operations["list-prepaid-assets"]["responses"][200]["content"]["application/json"];
-/** `GET /account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal-quote` 成功时的响应体。 */
-export type QuoteRenewalResult = operations["quote-renewal"]["responses"][200]["content"]["application/json"];
-/** `GET /account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal-quote` 的查询参数。 */
-export type QuoteRenewalQuery = operations["quote-renewal"]["parameters"]["query"];
-/** `POST /account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renew` 成功时的响应体。 */
-export type RenewPrepaidAssetResult = operations["renew-prepaid-asset"]["responses"][200]["content"]["application/json"];
-/** `POST /account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renew` 的请求体。 */
-export type RenewPrepaidAssetBody = NonNullable<operations["renew-prepaid-asset"]["requestBody"]>["content"]["application/json"];

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

@@ -598,7 +598,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/account/v1/billing-accounts/{accountKey}/payment-method": {
+    "/account/v1/billing-accounts/{accountKey}/payment-methods": {
         parameters: {
             query?: never;
             header?: never;
@@ -606,57 +606,50 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Whether this account can be charged
-         * @description Answers whether a payment method is on file, and nothing else.
+         * The payment methods on file
+         * @description Every method saved against this account, and which one an invoice will be charged to.
          *
-         *     ## It is a payment method, not a card
+         *     ## Why the brand, last four and expiry are here
          *
-         *     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.
+         *     They were deliberately absent while the billing engine held the card, because the answer
+         *     that mattered — can money be collected — came from the engine, and a page built on the
+         *     provider's answer could show a method the engine had not recorded. Collection now runs from
+         *     this service against the provider directly, so there is one answer, and it is the one shown.
          *
-         *     ## Why there is no brand, no last four digits, no expiry
+         *     Expiry is the reason this is worth showing at all: a card expires, the invoice then fails,
+         *     dunning runs out, and the project stops — with the account holder watching it happen and no
+         *     indication that a card was the cause.
          *
-         *     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.
+         *     No other card data exists here. The number, the expiry entered by the holder and the CVC go
+         *     from the browser to the provider and never reach this platform.
          *
-         *     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.
+         *     An account that has never added one returns an empty list. That is the normal state of a new
+         *     account, not an error.
          */
-        get: operations["read-payment-method"];
+        get: operations["list-payment-methods"];
         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**.
+         * Begin adding a payment method
+         * @description Starts a session for adding a method, and returns the secret the browser needs to mount the
+         *     provider's own form.
          *
-         *     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.
+         *     ## The form is embedded, not a redirect
+         *
+         *     The returned `client_secret` initialises the provider's JavaScript, which renders its form
+         *     inside an iframe on this platform's own page. **No card data reaches this platform** — the
+         *     number goes from the browser straight to the provider, exactly as it would on a redirect —
+         *     but the account holder never leaves the console.
+         *
+         *     A redirect would take them to a page with someone else's branding in the middle of adding a
+         *     payment method, which is the moment they are most likely to abandon it.
          *
          *     ## This is a prerequisite for buying a plan, not a convenience
          *
-         *     A plan is charged by invoice, and the invoice is collected from 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.
+         *     A plan is charged by invoice, and the invoice is collected from a method on file. Discovering
+         *     that none exists at purchase time turns a missing payment method into a rejection whose
+         *     wording is about something else entirely.
          *
          *     It is *not* a prerequisite for topping up: a top-up collects the money there and then.
-         *
-         *     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;
@@ -665,7 +658,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/account/v1/billing-accounts/{accountKey}/billing-portal": {
+    "/account/v1/billing-accounts/{accountKey}/payment-methods/{paymentMethodId}": {
         parameters: {
             query?: never;
             header?: never;
@@ -674,26 +667,43 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        post?: 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
+         * Remove a payment method
+         * @description Detaches it from this account. Removing the last one is allowed.
          *
-         *     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.
+         *     ## Why removing the last one is not blocked
          *
-         *     ## Something has to be able to replace an expiring card
+         *     Blocking it leaves an account holder who wants to stop paying with no way out. The cost of
+         *     allowing it is that later invoices cannot be collected — and that path has notice, a grace
+         *     period and a way back. A card that cannot be removed is a dead end.
+         */
+        delete: operations["remove-payment-method"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/payment-methods/{paymentMethodId}/default": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Charge invoices to this one
+         * @description Makes this the method an invoice is collected from.
          *
-         *     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.
+         *     ## It is stored at the provider, not here
          *
-         *     The URL is single-use and expires. Do not store it.
+         *     The charge itself reads that setting from the provider, so keeping a second copy here would
+         *     create two answers to the same question. When they disagree the visible symptom is that the
+         *     account holder changed the default and the charge still went to the old one.
          */
-        post: operations["start-billing-portal"];
+        put: operations["set-default-payment-method"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
@@ -783,26 +793,30 @@ export interface paths {
             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.
+         * What I bought outright
+         * @description Everything this account holds on a term, across every product.
+         *
+         *     ## Nothing here expires on its own
          *
-         *     ## Why this is one list rather than a page inside each product
+         *     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.
          *
-         *     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.
+         *     What the next period costs and when it falls due is on the charges route. That is read
+         *     straight from the engine rather than copied here, because a copy is a second answer that
+         *     drifts without saying so.
          *
          *     ## Metered resources are not here
          *
-         *     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.
+         *     They have no term. Listing them would invite renewing something that is already billed by
+         *     the hour until it is deleted.
          *
          *     ## `state` and `desired_state` are both reported
          *
-         *     A machine stopped 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.
+         *     A machine stopped for arrears reads `suspended` for both. One being brought back reads
+         *     `suspended` and `active` — it is on its way. Without the second field those look identical,
+         *     and a customer who just paid concludes it did not work and pays again.
          */
         get: operations["list-prepaid-assets"];
         put?: never;
@@ -813,88 +827,6 @@ export interface paths {
         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 {
@@ -1123,7 +1055,6 @@ export interface components {
             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. */
@@ -1141,16 +1072,19 @@ export interface components {
              */
             quantity: number;
             /**
-             * Format: date-time
-             * @description Paid up to this instant. It stops being served after it, not before.
+             * @description How long one period buys, as an ISO 8601 duration (P1M, P1Y).
+             *
+             *     There is no expiry to report. The engine keeps renewing this for as long as the seat is
+             *     held, so what runs out is not the term but the customer's decision to keep it. What the
+             *     next period costs, and when it is charged, is on the charges route — that is the engine's
+             *     own answer rather than a copy of it.
              */
-            term_end: string;
+            term: string;
             /** @enum {string} */
             state: "pending" | "active" | "suspended" | "terminated";
             /**
-             * @description What it is being moved to. Differs from `state` while a change is still being applied —
-             *     in particular right after a renewal, which is the moment a customer is most likely to
-             *     conclude that nothing happened.
+             * @description What it is being moved to. Differs from `state` while a change is still being applied,
+             *     which is the moment a customer is most likely to conclude that nothing happened.
              * @enum {string}
              */
             desired_state: "active" | "suspended" | "terminated";
@@ -1158,26 +1092,6 @@ export interface components {
         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
@@ -1372,40 +1286,60 @@ export interface components {
         };
         PaymentMethodSetupSession: {
             /**
-             * Format: uri
-             * @description Send the browser here. It expires, so do not store it
+             * @description Initialises the provider's JavaScript, which mounts its form in an iframe on this page.
+             *
+             *     Not a URL: the form is embedded rather than redirected to, so the account holder stays
+             *     on the console. It expires, so fetch it when the form is about to be shown rather than
+             *     when the page loads.
              */
-            url: string;
-        };
-        BillingPortalSession: {
+            client_secret: string;
             /**
-             * Format: uri
-             * @description Send the browser here. It expires, so do not store it
+             * @description The provider's id for this attempt.
+             *
+             *     The browser does not need it — the callback carries the same id and is what actually
+             *     records the method. It is here so that a support conversation about one failed attempt
+             *     has something to look it up by.
              */
-            url: string;
+            session_id?: string;
         };
         /**
-         * @description Whether money can be collected from this account later, without the account holder present.
+         * @description One saved way of collecting money 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.
+         *     Deliberately not called a card: a card is one kind, and direct debit and the recurring
+         *     mandates offered by regional wallets occupy the same slot.
          */
         PaymentMethod: {
+            /** @description The provider's id for it. Used to remove it or make it the default */
+            id: string;
+            /** @description Visa, Mastercard, and so on. Empty for kinds that have no brand */
+            brand?: string;
             /**
-             * @description True when the billing engine holds a default payment method for this account and can
-             *     therefore collect an invoice.
+             * @description The last four digits, for telling two saved methods apart.
              *
-             *     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.
+             *     This and the expiry are the only parts of the instrument that exist here. The number,
+             *     the expiry the holder typed and the CVC never reach this platform.
+             */
+            last4?: string;
+            /** Format: int32 */
+            exp_month?: number;
+            /**
+             * Format: int32
+             * @description Together with `exp_month`, when this stops working.
              *
-             *     It says nothing about which kind is on file. To show or change that, send the account
-             *     holder to the billing portal.
+             *     Worth showing because the failure is otherwise invisible: the card expires, the invoice
+             *     fails, dunning runs out, and the project stops — with nothing pointing at the card.
+             */
+            exp_year?: number;
+            /**
+             * @description True for the one an invoice is collected from.
              *
-             *     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.
+             *     Exactly one is the default while any exist. An account whose only method was removed
+             *     has none, and its next invoice cannot be collected.
              */
-            ready: boolean;
+            default: boolean;
+        };
+        PaymentMethodList: {
+            payment_methods: components["schemas"]["PaymentMethod"][];
         };
         TopUpSession: {
             /**
@@ -2463,7 +2397,7 @@ export interface operations {
             };
         };
     };
-    "read-payment-method": {
+    "list-payment-methods": {
         parameters: {
             query?: never;
             header?: never;
@@ -2484,7 +2418,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PaymentMethod"];
+                    "application/json": components["schemas"]["PaymentMethodList"];
                 };
             };
             /** @description Error */
@@ -2533,7 +2467,7 @@ export interface operations {
             };
         };
     };
-    "start-billing-portal": {
+    "remove-payment-method": {
         parameters: {
             query?: never;
             header?: never;
@@ -2543,19 +2477,18 @@ export interface operations {
                  *     which is why the key is what addresses the account.
                  */
                 accountKey: components["parameters"]["AccountKey"];
+                paymentMethodId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Removed */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["BillingPortalSession"];
-                };
+                content?: never;
             };
             /** @description Error */
             default: {
@@ -2568,7 +2501,7 @@ export interface operations {
             };
         };
     };
-    "list-offers": {
+    "set-default-payment-method": {
         parameters: {
             query?: never;
             header?: never;
@@ -2578,59 +2511,18 @@ export interface operations {
                  *     which is why the key is what addresses the account.
                  */
                 accountKey: components["parameters"]["AccountKey"];
+                paymentMethodId: string;
             };
             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: {
+            /** @description Updated */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["Purchase"];
-                };
+                content?: never;
             };
             /** @description Error */
             default: {
@@ -2643,7 +2535,7 @@ export interface operations {
             };
         };
     };
-    "list-prepaid-assets": {
+    "list-offers": {
         parameters: {
             query?: never;
             header?: never;
@@ -2664,7 +2556,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PrepaidAssetList"];
+                    "application/json": components["schemas"]["OfferList"];
                 };
             };
             /** @description Error */
@@ -2678,14 +2570,11 @@ export interface operations {
             };
         };
     };
-    "quote-renewal": {
+    "purchase-offer": {
         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;
+            query?: {
+                /** @description When the switch takes effect. Required if the account already has a plan, ignored otherwise */
+                timing?: components["schemas"]["PlanChangeTiming"];
             };
             header?: never;
             path: {
@@ -2694,8 +2583,8 @@ export interface operations {
                  *     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"];
+                /** @description Which offer */
+                offerKey: string;
             };
             cookie?: never;
         };
@@ -2707,7 +2596,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["RenewalQuote"];
+                    "application/json": components["schemas"]["Purchase"];
                 };
             };
             /** @description Error */
@@ -2721,7 +2610,7 @@ export interface operations {
             };
         };
     };
-    "renew-prepaid-asset": {
+    "list-prepaid-assets": {
         parameters: {
             query?: never;
             header?: never;
@@ -2731,16 +2620,10 @@ export interface operations {
                  *     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"];
-            };
-        };
+        requestBody?: never;
         responses: {
             /** @description OK */
             200: {
@@ -2748,7 +2631,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["Order"];
+                    "application/json": components["schemas"]["PrepaidAssetList"];
                 };
             };
             /** @description Error */

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

@@ -1477,6 +1477,31 @@ export interface components {
              * @description Restore from this snapshot. When given, the capacity need only be no smaller than the snapshot
              */
             snapshot_id?: string;
+            /**
+             * @description Buy the disk outright for this long, as an ISO 8601 duration (P1M, P1Y). Billed by the
+             *     hour when omitted.
+             *
+             *     A disk bought outright can still be expanded: the difference is prorated over the days
+             *     left in the term, and the expiry date does not move. It is stopped, not deleted, when the
+             *     term runs out — the data stays and comes back once renewed.
+             */
+            term?: string;
+            /**
+             * @description How to pay for a term bought outright. Only meaningful together with `term`.
+             *
+             *     `balance` takes it from the account balance and either succeeds or refuses on the spot.
+             *     `online` returns a `checkout_url` instead and **creates nothing** — the resource is only
+             *     created once the money arrives and the customer comes back to place it again. That last
+             *     part is deliberate: a successful payment should not silently turn into a machine, because
+             *     between paying and returning they may have changed their mind.
+             *
+             *     Online payment is not a second wallet. What arrives lands in the balance first and the
+             *     order is settled from there, so money topped up and money paid at checkout are the same
+             *     pool.
+             * @default balance
+             * @enum {string}
+             */
+            payment_method?: "balance" | "online";
         };
         RenameDiskRequestBody: {
             name: string;
@@ -1642,6 +1667,22 @@ export interface components {
              * @description A private image. Exactly one of this, `image_id` and `boot_disk_id`
              */
             private_image_id?: string;
+            /**
+             * @description How to pay for a term bought outright. Only meaningful together with `term`.
+             *
+             *     `balance` takes it from the account balance and either succeeds or refuses on the spot.
+             *     `online` returns a `checkout_url` instead and **creates nothing** — the resource is only
+             *     created once the money arrives and the customer comes back to place it again. That last
+             *     part is deliberate: a successful payment should not silently turn into a machine, because
+             *     between paying and returning they may have changed their mind.
+             *
+             *     Online payment is not a second wallet. What arrives lands in the balance first and the
+             *     order is settled from there, so money topped up and money paid at checkout are the same
+             *     pool.
+             * @default balance
+             * @enum {string}
+             */
+            payment_method?: "balance" | "online";
             /**
              * @description Buy the instance outright for this long, as an ISO 8601 duration (P1M, P1Y). Billed by the
              *     hour when omitted.
@@ -1680,6 +1721,15 @@ export interface components {
             instances: components["schemas"]["InstanceResource"][] | null;
             /** @description Returned only in this response; store it immediately. All instances of a batch share it */
             password: string;
+            /**
+             * @description Present only when `payment_method` was `online`: **nothing was created**. Send the
+             *     customer here to pay.
+             *
+             *     What comes back is not a resource but a bill to settle. Treating this response as a
+             *     success and moving on is how something gets handed over without the money arriving —
+             *     and it looks exactly like a normal creation from the outside.
+             */
+            checkout_url?: string;
         };
         SetInstanceLabelsRequestBody: {
             /** @description The complete set of labels. Whatever is absent here is removed; send an empty object to clear them all. A key may not contain a colon, whitespace or control characters */
@@ -2487,6 +2537,33 @@ export interface operations {
                     "application/json": components["schemas"]["DiskResource"];
                 };
             };
+            /**
+             * @description Payment required: **nothing was created.**
+             *
+             *     Returned when `payment_method` is `online`. `meta.checkout_url` is where to send the
+             *     customer; `meta.order_id` is the order waiting on it.
+             *
+             *     ## Why this is a status and not a field on a 200
+             *
+             *     A field on a success response is something a client can forget to read, and forgetting it
+             *     means treating "we created nothing and are waiting for money" as "created" — which looks
+             *     identical from the outside until the bill does not add up. A 402 fails loudly in any
+             *     client that handles errors at all.
+             *
+             *     ## What happens after they pay
+             *
+             *     The money lands in the balance and the order is settled from it. The resource is **not**
+             *     created automatically: placing it again is the customer's move, because between paying
+             *     and coming back they may have changed their mind. The balance is theirs either way.
+             */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description Error */
             default: {
                 headers: {
@@ -2940,6 +3017,33 @@ export interface operations {
                     "application/json": components["schemas"]["LaunchInstanceResponseBody"];
                 };
             };
+            /**
+             * @description Payment required: **nothing was created.**
+             *
+             *     Returned when `payment_method` is `online`. `meta.checkout_url` is where to send the
+             *     customer; `meta.order_id` is the order waiting on it.
+             *
+             *     ## Why this is a status and not a field on a 200
+             *
+             *     A field on a success response is something a client can forget to read, and forgetting it
+             *     means treating "we created nothing and are waiting for money" as "created" — which looks
+             *     identical from the outside until the bill does not add up. A 402 fails loudly in any
+             *     client that handles errors at all.
+             *
+             *     ## What happens after they pay
+             *
+             *     The money lands in the balance and the order is settled from it. The resource is **not**
+             *     created automatically: placing it again is the customer's move, because between paying
+             *     and coming back they may have changed their mind. The balance is theirs either way.
+             */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description Error */
             default: {
                 headers: {

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

@@ -815,6 +815,12 @@ export interface components {
             /** @description The service that reports this type */
             service: string;
             severity: components["schemas"]["NotificationSeverity"];
+            /**
+             * @description A short name for this type, in the reader's language — what a settings screen puts on
+             *     the row. It is not the subject line of the notification itself: a subject says what
+             *     happened this time and carries the ticket number, while this names the kind of thing.
+             */
+            title: string;
             type: string;
         };
         NotificationTypeListResponseBody: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leaflow/sdk",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "description": "Leaflow 平台 API 的 TypeScript SDK",
   "license": "MIT",
   "repository": {