@leaflow/sdk 0.45.0 → 0.47.0

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

@@ -32,6 +32,10 @@ export type SubmitIdentityVerificationBody = NonNullable<operations["submit-iden
 export type ListMyInvitationsResult = operations["list-my-invitations"]["responses"][200]["content"]["application/json"];
 /** `GET /account/v1/me/invitations` 的查询参数。 */
 export type ListMyInvitationsQuery = operations["list-my-invitations"]["parameters"]["query"];
+/** `GET /account/v1/invitations/by-token` 成功时的响应体。 */
+export type PreviewInvitationByTokenResult = operations["preview-invitation-by-token"]["responses"][200]["content"]["application/json"];
+/** `GET /account/v1/invitations/by-token` 的查询参数。 */
+export type PreviewInvitationByTokenQuery = operations["preview-invitation-by-token"]["parameters"]["query"];
 /** `POST /account/v1/me/invitations/accept` 成功时的响应体。 */
 export type AcceptInvitationByTokenResult = operations["accept-invitation-by-token"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/me/invitations/accept` 的请求体。 */

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

@@ -187,6 +187,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/invitations/by-token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * 看一眼这封邀请是谁发的、加入哪儿、什么角色
+         * @description 免认证，而且是有意的：点邮件里那条链接的人多半还没登录，甚至还没有账号。要他先注册再 告诉他这是谁发来的、加入哪个项目，等于让他在不知道要加入什么的情况下决定要不要注册。
+         *     它不多泄露任何东西。 这三样——项目名、邀请人、角色——邮件正文里已经写着了，而读得到 这个令牌的人就是收得到那封邮件的人。同一个令牌本来就能把持有者加进项目（见 `accept-invitation-by-token`），读一个项目名比那件事轻得多。
+         *     收件地址打了码（`t***@example.com`）。 不打码的话，这个接口就成了「拿一个令牌反查它 当初寄给了哪个地址」——而那是邮件正文里没有、持有者也未必知道的一件事。
+         *     令牌不存在、已经用过、被撤回、过期，四种情况同一个 404 和同一句话。分开报会把它变成 一个可以拿来试令牌的探针，而这个接口免认证，任何人都试得起。
+         *     它不在 `/me` 下面，隔壁那两条接受要约的在。 `/me` 的意思是「按这次请求的身份认出来 的、属于我的那些」，而这条路上没有身份——持有令牌的人未必是收件人本人。挂在 `/me` 下面会让读的人以为它认过身份，而那正是这条路唯一不做的事。
+         */
+        get: operations["preview-invitation-by-token"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/account/v1/me/invitations/accept": {
         parameters: {
             query?: never;
@@ -424,6 +448,21 @@ export interface components {
             /** @description 真实姓名。敏感个人信息，加密入库，任何接口都不会再把它读出来 */
             real_name: string;
         };
+        /**
+         * @description 一封邀请在被接受之前能给出的全部信息。
+         *     它比 InvitationResource 少两样：要约 id 和完整的收件地址。id 不给是因为持有令牌不等于 这封要约列在你名下——真正列在你名下的那些走 list-my-invitations，那条是认过身份的。
+         */
+        InvitationPreviewResource: {
+            /** @description 打过码的收件地址，只够收件人认出「这是发给我的」 */
+            email_masked: string;
+            /** Format: date-time */
+            expires_at: string;
+            /** @description 邀请人的显示名，姓名都空时是他的邮箱 */
+            invited_by_name: string;
+            project_name: string;
+            /** @description 接受之后会拿到的角色，显示名 */
+            role_names: string[] | null;
+        };
         InvitationResource: {
             /** Format: date-time */
             created_at: string;
@@ -432,11 +471,21 @@ export interface components {
             expires_at: string;
             /** Format: uuid */
             id: string;
+            /** @description 发出这份要约的账号 id */
             invited_by: string;
+            /** @description 发出这份要约的人的显示名，姓名都空时是他的邮箱。它是读取那一刻的事实，不是发信时的快照 */
+            invited_by_name: string;
             /** Format: uuid */
             project_id: string;
+            /**
+             * @description 目标项目的名字。
+             *     它在这里，而这一度是刻意不给的——理由是「没接受就不是成员，而名字只有成员能读」。 那条克制在这个场景下站不住：邀请邮件正文里就写着项目名，收件人早就知道了，而一个 只显示 uuid 的邀请列表让人没法判断该不该接受。
+             */
+            project_name: string;
             /** @description 兑现时会授予的角色编码 */
             roles: string[] | null;
+            /** @description 上面那些编码的显示名，按同样的顺序。读者看的是「管理员」，不是 ADMIN */
+            role_names: string[] | null;
         };
         LengthAwarePageInvitationResource: {
             /** @description 这一页的内容 */
@@ -907,6 +956,38 @@ export interface operations {
             };
         };
     };
+    "preview-invitation-by-token": {
+        parameters: {
+            query: {
+                /** @description 邀请链接里那串令牌 */
+                token: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InvitationPreviewResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "accept-invitation-by-token": {
         parameters: {
             query?: never;

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

@@ -34,6 +34,8 @@ export type ListChargesResult = operations["list-charges"]["responses"][200]["co
 export type ListInvoicesResult = operations["list-invoices"]["responses"][200]["content"]["application/json"];
 /** `GET /account/v1/billing-accounts/{accountKey}/invoices/{invoiceId}` 成功时的响应体。 */
 export type GetInvoiceResult = operations["get-invoice"]["responses"][200]["content"]["application/json"];
+/** `GET /account/v1/projects/{projectId}/billing-account` 成功时的响应体。 */
+export type ReadProjectBillingAccountResult = operations["read-project-billing-account"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/projects/{projectId}/quote` 成功时的响应体。 */
 export type QuoteProjectUsageResult = operations["quote-project-usage"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/projects/{projectId}/quote` 的请求体。 */
@@ -62,3 +64,13 @@ export type ListOffersResult = operations["list-offers"]["responses"][200]["cont
 export type PurchaseOfferResult = operations["purchase-offer"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts/{accountKey}/offers/{offerKey}/purchase` 的查询参数。 */
 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

@@ -326,6 +326,49 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/projects/{projectId}/billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Which account pays for this project
+         * @description The account a project's resources are charged to, resolved from the project rather than
+         *     guessed.
+         *
+         *     ## Why a console needs this
+         *
+         *     Everything in a console happens inside a project, while billing accounts belong to a person —
+         *     and a person can have many. Showing "the first one" next to a sentence like *you are
+         *     overdrawn, new resources will be refused* pairs one account's balance with another account's
+         *     rule. Both directions are wrong and one of them is silent: the figures look healthy while
+         *     creating anything is refused, and the refusal names a reason the page just contradicted.
+         *
+         *     ## Being a member is enough to ask, but not to see the money
+         *
+         *     The answer is the account's identity, not its balance. A project's members are not
+         *     necessarily the people paying for it — a company account can pay for a project someone else
+         *     works in — and their balance is not those members' business. Whoever owns the account reads
+         *     the figures from the balance route as before; `owned_by_me` says which case this is, so a
+         *     page can tell "you are overdrawn" apart from "ask whoever pays for this project".
+         *
+         *     ## A project with no account is a normal state, and it answers 404
+         *
+         *     A project nobody has bound yet cannot create resources at all — admission refuses it. That is
+         *     worth saying plainly ("this project has no billing account, bind one") rather than falling
+         *     back to some other account of theirs, which is how the wrong-account problem started.
+         */
+        get: operations["read-project-billing-account"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/account/v1/projects/{projectId}/quote": {
         parameters: {
             query?: never;
@@ -675,6 +718,126 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What I bought outright, and when it runs out
+         * @description Everything this account paid a term for, across every product, soonest to expire first.
+         *
+         *     ## Why this is one list rather than a page inside each product
+         *
+         *     Renewal is the one thing a customer forgets, and forgetting it stops the machine. Splitting
+         *     the list per product means the instance about to lapse tomorrow is only visible to someone
+         *     who thought to go and look at instances. Sorting by expiry rather than by purchase date is
+         *     the same reason: the row that matters is the one at the top.
+         *
+         *     ## Metered resources are not here
+         *
+         *     There is no term to run out. Listing them with an empty expiry would invite renewing
+         *     something that is already billed by the hour until it is deleted.
+         *
+         *     ## `state` and `desired_state` are both reported
+         *
+         *     A machine stopped because its term lapsed reads `suspended` for both. One that has just been
+         *     renewed reads `suspended` and `active` — it is on its way back. Without the second field
+         *     those look identical, and a customer who just paid concludes it did not work and pays again.
+         */
+        get: operations["list-prepaid-assets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal-quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What renewing this would cost
+         * @description Priced the same way the charge is, from the same table, so the number shown is the number
+         *     taken. Quoting separately from charging is what lets a customer see the price before
+         *     committing; computing it twice in two places is what makes the two disagree, and a bill that
+         *     disagrees with the page that sold it is a complaint rather than a bug report.
+         *
+         *     ## Both the current and the resulting expiry are returned
+         *
+         *     Renewing early adds the term to what is left, not to today — otherwise renewing a month
+         *     ahead throws that month away, and everyone learns to wait until the last moment. Something
+         *     that lapsed long ago is counted from now instead, because adding to a date in the past
+         *     produces an expiry that is still in the past.
+         *
+         *     Reporting only the new date leaves the customer unable to tell which of those happened.
+         *
+         *     ## A withdrawn price still quotes
+         *
+         *     Taking a product off sale means stop selling new ones. Refusing renewals as well would stop
+         *     a batch of existing machines on their expiry date, which is not what the operator pressed
+         *     that button for.
+         */
+        get: operations["quote-renewal"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renew": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Renew it
+         * @description Takes the money from the balance and pushes the expiry out. The resource itself is not
+         *     touched — nothing is rebuilt, nothing restarts, the id stays the same.
+         *
+         *     ## An idempotency key is required, not optional
+         *
+         *     Renewal is a pure charge. Unlike creating something, there is no resource whose uniqueness
+         *     catches a repeat, so a double click is two charges and twice the term — and both calls
+         *     return success. Letting the field be omitted would mean losing that protection silently, in
+         *     the one case that looks completely normal until the books are reconciled.
+         *
+         *     Sending the same key again returns the order that was already placed. It does not charge
+         *     again, and it is not an error: reporting a repeat as a failure makes the caller retry
+         *     forever, and makes the customer press the button a second time with a fresh key.
+         *
+         *     ## What happens if the balance is short
+         *
+         *     The order is recorded as failed and nothing else changes: no money moves, the expiry stays
+         *     where it was, and the resource keeps running until its existing term ends. Retrying with the
+         *     same key after topping up goes through.
+         *
+         *     ## Renewing something that already lapsed brings it back
+         *
+         *     Its term is counted from now, and it is asked to start again. Coming back is the
+         *     reconciliation loop's job, so it is not instant — which is what `desired_state` on the asset
+         *     list is for.
+         */
+        post: operations["renew-prepaid-asset"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -873,6 +1036,19 @@ export interface components {
              */
             state: "pending" | "fulfilled" | "failed";
             failure_reason?: string;
+            /**
+             * @description What was taken, as a decimal string. Absent on a metered order, where the amount is not
+             *     known when the order is placed: it comes from usage afterwards. Absent must be read as
+             *     "billed by usage" — writing zero would make a metered order and a genuinely free one
+             *     look the same.
+             */
+            amount?: string;
+            currency?: string;
+            /**
+             * @description Always `none` on a metered order.
+             * @enum {string}
+             */
+            payment_state?: "none" | "paid" | "refunded";
             /** Format: date-time */
             created_at: string;
             /** @description Only present on the single-order route. */
@@ -889,6 +1065,74 @@ export interface components {
             /** Format: int64 */
             quantity: number;
         };
+        PrepaidAsset: {
+            /** @description Use this to quote and to renew. */
+            id: string;
+            project_id: string;
+            /** @description Which service holds it. Also which console it is managed from. */
+            service: string;
+            /**
+             * @description That service's own catalogue id, not a billing sku. The price of a machine is made of
+             *     finer parts than the machine type — the type does not appear in the rate card at all.
+             */
+            product_id: string;
+            /** @description The id that service knows it by, so the two consoles can be lined up. */
+            resource_id?: string;
+            /**
+             * Format: int64
+             * @description GiB for a disk, 1 for a machine or an address.
+             */
+            quantity: number;
+            /**
+             * Format: date-time
+             * @description Paid up to this instant. It stops being served after it, not before.
+             */
+            term_end: string;
+            /** @enum {string} */
+            state: "pending" | "active" | "suspended" | "terminated";
+            /**
+             * @description What it is being moved to. Differs from `state` while a change is still being applied —
+             *     in particular right after a renewal, which is the moment a customer is most likely to
+             *     conclude that nothing happened.
+             * @enum {string}
+             */
+            desired_state: "active" | "suspended" | "terminated";
+        };
+        PrepaidAssetList: {
+            assets: components["schemas"]["PrepaidAsset"][];
+        };
+        RenewalQuote: {
+            provision_id: string;
+            term: string;
+            /**
+             * @description A decimal string, not a float. Money that survives a round trip through binary floating
+             *     point is money that stops adding up.
+             */
+            amount: string;
+            currency: string;
+            /**
+             * Format: date-time
+             * @description What it is paid up to now.
+             */
+            current_term_end: string;
+            /**
+             * Format: date-time
+             * @description What it would be paid up to after renewing.
+             */
+            term_end: string;
+        };
+        RenewRequestBody: {
+            /**
+             * @description How long to renew for, as an ISO 8601 duration (P1M, P1Y). It does not have to match the
+             *     term originally bought.
+             */
+            term: string;
+            /**
+             * @description Generate one per renewal the customer starts — when the dialog opens, not when it is
+             *     submitted — and send the same one on every retry of that renewal.
+             */
+            idempotency_key: string;
+        };
         OrderList: {
             orders: components["schemas"]["Order"][];
         };
@@ -1030,6 +1274,19 @@ export interface components {
              */
             available: string;
         };
+        /** @description The account a project's resources are charged to */
+        ProjectBillingAccount: {
+            account_key: string;
+            project_id: string;
+            display_name: string;
+            currency: components["schemas"]["Currency"];
+            /**
+             * @description Whether the caller owns this account, and therefore whether the balance routes will
+             *     answer for it. False means someone else pays for this project: the figures are theirs,
+             *     not the caller's, and a page should say so rather than showing nothing.
+             */
+            owned_by_me: boolean;
+        };
         /** @description Which account pays for which project, as it stands once the request has been applied */
         ProjectBinding: {
             account_key: string;
@@ -1114,6 +1371,48 @@ export interface components {
              *     just started as zero
              */
             total: string;
+            /**
+             * @description Which meter it is for, when the charge came from usage. A hash, not something to show —
+             *     it is here so two rows can be told apart programmatically and so support can line a row
+             *     up with the catalogue.
+             */
+            feature_key?: string;
+            /**
+             * @description Whether this figure moves. A usage charge climbs through the period; a flat fee does not.
+             *     Without it, the same number on two refreshes could mean "nobody used it" or "it never
+             *     moves", and those need different next steps.
+             * @enum {string}
+             */
+            type: "usage_based" | "flat_fee";
+            /**
+             * Format: date-time
+             * @description Start of the service period this charge covers.
+             *
+             *     This is what tells two same-named rows apart. Something billed by the hour produces
+             *     hundreds of identically named charges in a month, and a list carrying only a name and an
+             *     amount shows them as a wall of duplicates — which is what it looks like today.
+             */
+            period_from: string;
+            /**
+             * Format: date-time
+             * @description End of the service period this charge covers.
+             */
+            period_to: string;
+            /**
+             * @description How much of this charge was covered by credit, as a decimal string.
+             *
+             *     It is the answer to "I have a balance, why am I still being charged". Without it the
+             *     customer sees a number that disagrees with what they expected and the only thing that
+             *     explains it is on our side.
+             */
+            credits?: string;
+            /**
+             * @description How much was taken off by a discount, as a decimal string. A usage allowance (the first N
+             *     units free) lands here too.
+             */
+            discounts?: string;
+            /** @description Free text from the charge, usually empty. Set on charges raised by hand. */
+            description?: string;
         };
         ChargeList: {
             currency: components["schemas"]["Currency"];
@@ -1215,6 +1514,8 @@ export interface components {
     };
     responses: never;
     parameters: {
+        /** @description Which asset, from the prepaid list */
+        ProvisionId: string;
         /**
          * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
          *     which is why the key is what addresses the account.
@@ -1756,6 +2057,38 @@ export interface operations {
             };
         };
     };
+    "read-project-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The project being worked in */
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ProjectBillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "quote-project-usage": {
         parameters: {
             query?: never;
@@ -2120,4 +2453,123 @@ export interface operations {
             };
         };
     };
+    "list-prepaid-assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PrepaidAssetList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "quote-renewal": {
+        parameters: {
+            query: {
+                /**
+                 * @description How long to renew for, as an ISO 8601 duration (P1M, P1Y). A duration rather than a
+                 *     number of months: months are not the same length.
+                 */
+                term: string;
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description Which asset, from the prepaid list */
+                provisionId: components["parameters"]["ProvisionId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RenewalQuote"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "renew-prepaid-asset": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description Which asset, from the prepaid list */
+                provisionId: components["parameters"]["ProvisionId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RenewRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Order"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
 }

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

@@ -1381,6 +1381,19 @@ export interface components {
         ImageListResponseBody: {
             items: components["schemas"]["ImageResource"][] | null;
         };
+        PrepaidPrice: {
+            /**
+             * @description An ISO 8601 duration (P1M, P1Y). A duration rather than a number of months: months are not
+             *     the same length, and storing a number leaves whoever reads it to decide what it means.
+             */
+            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;
+        };
         InstanceTypeResource: {
             /** @description Availability zone of this instance type. A disk must be in the same zone to be attached */
             availability_zone_code: string;
@@ -1398,6 +1411,39 @@ export interface components {
             region_code: string;
             /** Format: int64 */
             vcpus: number;
+            /**
+             * @description Whether this type can be ordered right now.
+             *
+             *     It reflects a limit set by operations, not what the cloud can physically schedule — raising
+             *     the limit does not create capacity that is not there, and a type that is not sold out can
+             *     still fail to start if the zone is full.
+             *
+             *     It is advisory: it is read when the list is built, and the last one can be taken between
+             *     that read and the order. The order is what actually refuses.
+             */
+            sold_out: boolean;
+            /**
+             * Format: int64
+             * @description How many more may be created. Absent when this type is not limited at all.
+             *
+             *     Absent is not zero and not "unknown": a type with no limit simply has no number to show.
+             *     Reporting it as a number would need a sentinel, and any sentinel eventually gets compared
+             *     against a real count.
+             */
+            remaining?: number;
+            /**
+             * @description What buying this type outright costs, per term. Empty means this type is only sold by the
+             *     hour.
+             *
+             *     The hourly price is not here and is not missing: it is made of finer parts than the type
+             *     (cores and memory are priced separately, and the type itself does not appear in the rate
+             *     card at all), so there is no single number to show. A term price is one number because a
+             *     term is one purchase.
+             *
+             *     Advisory, like `sold_out`: it is read when the list is built. The order is what fixes the
+             *     price, and it refuses rather than falling back to hourly if the term is not sold.
+             */
+            prepaid_prices?: components["schemas"]["PrepaidPrice"][];
         };
         InstanceTypeListResponseBody: {
             items: components["schemas"]["InstanceTypeResource"][] | null;
@@ -1596,6 +1642,24 @@ export interface components {
              * @description A private image. Exactly one of this, `image_id` and `boot_disk_id`
              */
             private_image_id?: string;
+            /**
+             * @description Buy the instance outright for this long, as an ISO 8601 duration (P1M, P1Y). Billed by the
+             *     hour when omitted.
+             *
+             *     The money is taken from the balance when the order is placed, at the price the catalogue
+             *     reported for this type and term. If that term is not on sale for this type the request is
+             *     refused — it is never quietly sold by the hour instead, because the customer who asked for
+             *     a year would find out only from the bill.
+             *
+             *     The system disk is bought for the same term: it is the same purchase, and one order cannot
+             *     be half outright and half hourly. A term is therefore refused together with `boot_disk_id`,
+             *     where the disk already exists and is already billed its own way.
+             *
+             *     When the term runs out the instance is stopped, not deleted, and starts again once it is
+             *     renewed. Renewal lives in the billing console, across every product, because what a
+             *     customer needs to see is everything expiring this month rather than one product at a time.
+             */
+            term?: string;
             /**
              * Format: int64
              * @description System disk capacity in GB. Chosen automatically from the requirement of the image and the platform minimum when omitted. Ignored with `boot_disk_id`, since that disk already has its capacity

package/package.json

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