@leaflow/sdk 0.48.0 → 0.50.0

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

@@ -30,6 +30,8 @@ export type StartTopUpResult = operations["start-top-up"]["responses"][200]["con
 export type StartTopUpBody = NonNullable<operations["start-top-up"]["requestBody"]>["content"]["application/json"];
 /** `GET /account/v1/billing-accounts/{accountKey}/charges` 成功时的响应体。 */
 export type ListChargesResult = operations["list-charges"]["responses"][200]["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}/charges` 的查询参数。 */
+export type ListChargesQuery = operations["list-charges"]["parameters"]["query"];
 /** `GET /account/v1/billing-accounts/{accountKey}/charges/{chargeId}/usage` 成功时的响应体。 */
 export type GetChargeUsageResult = operations["get-charge-usage"]["responses"][200]["content"]["application/json"];
 /** `GET /account/v1/billing-accounts/{accountKey}/invoices` 成功时的响应体。 */
@@ -68,6 +70,10 @@ 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"];
+/** `PUT /account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal` 成功时的响应体。 */
+export type SetRenewalStatusResult = operations["set-renewal-status"]["responses"][200]["content"]["application/json"];
+/** `PUT /account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal` 的请求体。 */
+export type SetRenewalStatusBody = NonNullable<operations["set-renewal-status"]["requestBody"]>["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` 的查询参数。 */

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

@@ -813,6 +813,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}/prepaid-assets/{provisionId}/renewal": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Choose what happens when it expires
+         * @description Three choices, not two.
+         *
+         *     ## Why automatic renewal has to be opted into
+         *
+         *     Charging someone automatically has to be something they chose. Defaulting to it means a
+         *     person who wanted to try one month is charged for a second they never agreed to — and that
+         *     is where chargebacks come from. So a resource bought outright starts on `manual`.
+         *
+         *     ## And why "let it expire" is its own choice, not just "not automatic"
+         *
+         *     `manual` keeps reminding: the notice before expiry is mandatory, because expiry stops the
+         *     resource. Someone who has decided to let it go does not want those, and the cost of sending
+         *     them anyway is not annoyance — it is that the reminders get filtered away, taking the ones
+         *     that mattered with them.
+         *
+         *     ## Turning it on needs a known cycle
+         *
+         *     Renewing automatically has to know for how long, which comes from the last purchase or
+         *     renewal. A resource adopted into billing, or bought before this was recorded, has no cycle
+         *     yet: renew it manually once and the cycle is written down.
+         */
+        put: operations["set-renewal-status"];
+        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;
@@ -1154,6 +1193,19 @@ export interface components {
              * @enum {string}
              */
             desired_state: "active" | "suspended" | "terminated";
+            /**
+             * @description How long one renewal buys, as an ISO 8601 duration (P1M, P1Y). Empty on something adopted
+             *     into billing rather than bought through it — automatic renewal cannot be turned on until
+             *     one manual renewal records it.
+             */
+            billing_cycle?: string;
+            /**
+             * @description What happens at expiry. `manual` is where everything starts: charging automatically has
+             *     to be chosen. `none` also stops the reminders, which is a different thing from `manual`
+             *     — see the route that sets it.
+             * @enum {string}
+             */
+            renewal_status: "manual" | "auto" | "none";
         };
         PrepaidAssetList: {
             assets: components["schemas"]["PrepaidAsset"][];
@@ -1178,6 +1230,10 @@ export interface components {
              */
             term_end: string;
         };
+        SetRenewalStatusRequestBody: {
+            /** @enum {string} */
+            status: "manual" | "auto" | "none";
+        };
         RenewRequestBody: {
             /**
              * @description How long to renew for, as an ISO 8601 duration (P1M, P1Y). It does not have to match the
@@ -1519,7 +1575,20 @@ export interface components {
         ChargeList: {
             currency: components["schemas"]["Currency"];
             charges: components["schemas"]["Charge"][];
-            /** @description The sum, which is the same number as `unsettled` on the balance */
+            /**
+             * Format: int64
+             * @description How many charges there are in total, across every page.
+             *
+             *     Without it, "is there another page" has to be guessed from whether this one came back
+             *     full — and that guess turns into one extra fetch of an empty page whenever the last page
+             *     happens to be exactly full.
+             */
+            total_count?: number;
+            /**
+             * @description The sum over the **whole period**, not this page — it is the same number as `unsettled`
+             *     on the balance, and paging must not change it. A page-scoped sum would disagree with the
+             *     balance card sitting next to it, and there would be no way to tell which one to believe.
+             */
             total: string;
         };
         /** @enum {string} */
@@ -2082,7 +2151,18 @@ export interface operations {
     };
     "list-charges": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description 1-based page number; the first page when omitted. */
+                page?: number;
+                /**
+                 * @description How many charges per page. Defaults to a full page.
+                 *
+                 *     Charge count grows with resource count — an account running dozens of machines produces
+                 *     hundreds of lines in a period, and a screen shows a dozen. Fetching all of them on every
+                 *     visit carries data nothing displays.
+                 */
+                page_size?: number;
+            };
             header?: never;
             path: {
                 /**
@@ -2654,6 +2734,47 @@ export interface operations {
             };
         };
     };
+    "set-renewal-status": {
+        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"]["SetRenewalStatusRequestBody"];
+            };
+        };
+        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"];
+                };
+            };
+        };
+    };
     "quote-renewal": {
         parameters: {
             query: {

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.48.0",
+  "version": "0.50.0",
   "description": "Leaflow 平台 API 的 TypeScript SDK",
   "license": "MIT",
   "repository": {