@leaflow/sdk 0.53.0 → 0.54.1

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

@@ -82,7 +82,10 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List disk types on sale */
+        /**
+         * List disk types on sale
+         * @description Only disk types currently on sale are listed. A withdrawn one disappears from here and can no longer be bought, while the disks already on it keep working and can still be resized.
+         */
         get: operations["list-disk-types"];
         put?: never;
         post?: never;
@@ -102,6 +105,8 @@ export interface paths {
         /**
          * List images on sale
          * @description An image whose `min_ram_mb` exceeds the memory of the selected instance type cannot boot. Filter the options accordingly.
+         *
+         *     Only images currently on sale are listed. An image the platform withdraws disappears from here and can no longer install new instances, while the instances already running it keep running and can still be rebuilt onto it.
          */
         get: operations["list-images"];
         put?: never;
@@ -119,7 +124,10 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List instance types on sale */
+        /**
+         * List instance types on sale
+         * @description Only instance types currently on sale are listed. A withdrawn one disappears from here and can no longer be ordered, while the instances already running it keep running.
+         */
         get: operations["list-instance-types"];
         put?: never;
         post?: never;
@@ -182,6 +190,8 @@ export interface paths {
         /**
          * Create a disk
          * @description The disk is created in the availability zone of the selected disk type, and an instance must reside in the same zone to attach it. Choosing the disk type therefore determines the zone.
+         *
+         *     A disk type that has been withdrawn is rejected with `DISK_TYPE_RETIRED`, even though its identifier still resolves. Withdrawn types stop appearing in the disk type listing; disks already bought on one keep working and can still be resized.
          */
         post: operations["create-disk"];
         delete?: never;
@@ -230,6 +240,12 @@ export interface paths {
         /**
          * Resize a disk
          * @description Capacity can only be increased; shrinking is not supported. Extend the file system inside the instance once the resize completes.
+         *
+         *     **A data disk whose performance grows with its size has to be detached first.** The storage backend decides a volume's limit when the volume is attached and never revisits it, so growing one that is attached would give you the capacity immediately and leave the speed at the old size's figure — indefinitely, and stopping the instance does not help. Rather than take the money for performance that does not arrive, this is refused with `DISK_RESIZE_NEEDS_DETACH`; detach the disk, resize it, and attach it again.
+         *
+         *     It is only refused when the two sizes really would differ in speed. A disk whose type has no QoS level, or whose performance has already reached the type's ceiling, grows online as before.
+         *
+         *     **A system disk is the exception and grows online**, because a root volume cannot be detached at all. Its performance does not change with size for exactly that reason — system disk types are required to carry a level that does not scale.
          */
         post: operations["resize-disk"];
         delete?: never;
@@ -317,6 +333,8 @@ export interface paths {
         /**
          * Set the bandwidth limit
          * @description Limits both directions at once. Limiting egress alone does not prevent ingress traffic from saturating the uplink.
+         *
+         *     While the address is bound to an instance, the ceiling has to fit that instance type's `max_bandwidth_mbps`; asking for more is refused with `INSTANCE_BANDWIDTH_CEILING`. An address bound to nothing is not checked against any type — there is none to check against — and is checked again when it is attached.
          */
         put: operations["set-floating-ip-bandwidth"];
         post?: never;
@@ -370,6 +388,8 @@ export interface paths {
          *
          *     Exactly one source must be given: `image_id` for a platform image, `private_image_id` for a private image, or `boot_disk_id` to boot a disk you already have. Supplying more than one, or none, is rejected.
          *
+         *     A platform image that has been withdrawn is rejected with `IMAGE_RETIRED`, and an instance type that has been withdrawn with `INSTANCE_TYPE_RETIRED` — in both cases the identifier still resolves. Withdrawn entries stop appearing in their listing, so an identifier held in a script, a template or an earlier order is the way this is usually hit: reread the listing and pick another. Instances already running either are unaffected, and one on a withdrawn image can still be rebuilt onto it.
+         *
          *     `boot_disk_id` recovers an instance that can no longer be repaired from the inside. Snapshot its disk, restore that snapshot into a new disk, attach the new disk to another instance and repair it there, then create an instance from it. That disk is not deleted when the instance is released; it is detached and returned to you.
          *
          *     Instances are created in the availability zone of the instance type. Disks to be attached later must reside in the same zone.
@@ -605,6 +625,8 @@ export interface paths {
         /**
          * Rebuild an instance
          * @description **All data on the system disk is erased and cannot be recovered.** Attached data disks are unaffected.
+         *
+         *     The image this instance already runs is accepted even after the platform has withdrawn it, since rebuilding is the only way back into an instance broken from the inside. Any *other* withdrawn image is rejected with `IMAGE_RETIRED`, which is a change of image and therefore a new order.
          */
         post: operations["rebuild-instance"];
         delete?: never;
@@ -1310,7 +1332,7 @@ export interface components {
         RestoreBackupRequestBody: {
             /**
              * Format: uuid
-             * @description May differ from the availability zone of the source disk, but must be in the same region
+             * @description May differ from the availability zone of the source disk, but must be in the same region. It has to be on sale — restoring creates a new disk, so a withdrawn type is rejected here as well
              */
             disk_type_id: string;
             name: string;
@@ -1338,14 +1360,52 @@ export interface components {
             region_code: string;
             /** Format: int64 */
             size_gb: number;
+            /**
+             * Format: int64
+             * @description IOPS this disk is allowed. Null when its type is not rate-limited.
+             *
+             *     Computed from the disk's own capacity, so it grows when the disk is grown — but see the
+             *     note on the resize endpoint: growing a disk that is attached is refused, precisely because
+             *     the new figure would not take effect until it was attached again.
+             */
+            iops: number | null;
+            /**
+             * Format: int64
+             * @description Throughput this disk is allowed, in bytes per second. Null when its type is not rate-limited
+             */
+            throughput_bytes_per_sec: number | null;
             /** @enum {string} */
             status: "provisioning" | "available" | "attaching" | "in_use" | "detaching" | "resizing" | "reverting" | "restoring" | "releasing" | "deleting" | "error";
+            /**
+             * @description How this disk is paid for. `postpaid` is billed by the hour for as long as it exists;
+             *     `prepaid` was bought outright for a term.
+             *
+             *     **Not the term.** How long it was bought for belongs to the order, not to the disk:
+             *     renewing can change it, and a machine bought for a year and then renewed for a month is
+             *     still a prepaid machine. Ask billing for the term and the expiry — they live there, and
+             *     they are the only two values a renewal moves.
+             * @enum {string}
+             */
+            charge_type: "postpaid" | "prepaid";
         };
         DiskTypeResource: {
             availability_zone_code: string;
             /** Format: uuid */
             id: string;
-            iops_display: string;
+            /**
+             * Format: int64
+             * @description IOPS a disk of `min_size_gb` gets. Null when this type is not rate-limited.
+             *
+             *     Performance grows with capacity, so this and `iops_at_max_size` are the two ends of the
+             *     range. The exact figure for the size actually bought appears on the disk itself once it
+             *     exists.
+             */
+            iops_at_min_size: number | null;
+            /**
+             * Format: int64
+             * @description IOPS a disk of `max_size_gb` gets. Null when this type is not rate-limited
+             */
+            iops_at_max_size: number | null;
             /** Format: int64 */
             max_size_gb: number;
             /** @enum {string} */
@@ -1356,7 +1416,62 @@ export interface components {
             region_code: string;
             /** Format: int64 */
             step_gb: number;
-            throughput_display: string;
+            /**
+             * Format: int64
+             * @description Throughput a disk of `min_size_gb` gets, in **bytes per second**. Null when this type is
+             *     not rate-limited.
+             *
+             *     Bytes rather than MiB so the number needs no rounding on the way out; divide by 1048576
+             *     for MiB/s at the point of display.
+             */
+            throughput_at_min_size: number | null;
+            /**
+             * Format: int64
+             * @description Throughput a disk of `max_size_gb` gets, in bytes per second. Null when this type is not rate-limited
+             */
+            throughput_at_max_size: number | null;
+            /**
+             * @description Whether any capacity is left in this type's pool.
+             *
+             *     The same shape as on an instance type, but it answers less here: a disk is sold by the
+             *     GiB, so "not sold out" does not mean the size being asked for fits. `remaining` is the
+             *     field that decides that, and this one only says whether the pool is empty outright.
+             *
+             *     It reflects a limit set by operations, not what the storage backend physically has —
+             *     raising the limit does not create capacity, and a type that is not sold out can still fail
+             *     to create if the backend is full.
+             *
+             *     Advisory: it is read when the list is built, and capacity can be taken between that read
+             *     and the order. The order is what actually refuses.
+             */
+            sold_out: boolean;
+            /**
+             * Format: int64
+             * @description How much capacity is left, **in GiB**. Absent when this type is not limited at all.
+             *
+             *     Unlike an instance type, where this is a count of machines, here it is an amount of
+             *     storage — and it is the number that bounds the size a customer may ask for. A picker that
+             *     offers sizes above it produces orders that are refused after the customer has chosen
+             *     everything else.
+             *
+             *     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 size.
+             */
+            remaining?: number;
+            /**
+             * @description What buying this type outright costs, per term. Empty means this type is only sold by the
+             *     hour.
+             *
+             *     **The amount is per GiB for the whole term**, not the price of one disk: a disk's size is
+             *     chosen by the customer, so the total is this figure times the size. That differs from an
+             *     instance type, where the same field is the price of one machine — the unit follows what
+             *     the product is sold by, and the order is priced the same way.
+             *
+             *     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"][];
         };
         DiskTypeListResponseBody: {
             items: components["schemas"]["DiskTypeResource"][] | null;
@@ -1399,8 +1514,29 @@ export interface components {
             availability_zone_code: string;
             /** Format: uuid */
             id: string;
-            /** Format: int64 */
+            /**
+             * Format: int64
+             * @description The most public bandwidth a machine of this type may be given, in Mbps. Asking for more
+             *     when creating a machine, or raising a bound address past it, is refused.
+             *
+             *     A ceiling on what can be bought, not a speed. How fast the machine's own interfaces run is
+             *     `network_egress_kbps` / `network_ingress_kbps`.
+             */
             max_bandwidth_mbps: number;
+            /**
+             * Format: int64
+             * @description Outbound ceiling of **each** network interface, in kbps. Null when this type is not
+             *     rate-limited.
+             *
+             *     Per interface rather than per machine: a machine with two interfaces has this ceiling on
+             *     each of them, not shared between them. `max_ports` says how many it may have.
+             */
+            network_egress_kbps: number | null;
+            /**
+             * Format: int64
+             * @description Inbound ceiling of each network interface, in kbps. Null when this type is not rate-limited
+             */
+            network_ingress_kbps: number | null;
             /** Format: int64 */
             max_floating_ips: number;
             /** Format: int64 */
@@ -1467,7 +1603,34 @@ export interface components {
             items: components["schemas"]["DiskResource"][] | null;
         };
         CreateDiskRequestBody: {
-            /** Format: uuid */
+            /**
+             * @description A promotion code to apply to this order. Case and surrounding whitespace do not matter.
+             *
+             *     An unusable code is rejected outright rather than quietly ignored: somebody who typed a
+             *     code is buying at the discounted price, and letting it through silently means they pay
+             *     full price expecting the discount, with nothing anywhere saying so.
+             *
+             *     The discount applies to the lines the campaign covers, not the whole order — typically
+             *     the instance type and memory, not the system disk, the address, or traffic. Preview it
+             *     first at `POST /account/v1/billing-accounts/{accountKey}/promotion-codes/preview` to
+             *     show the customer what will actually be charged.
+             *
+             *     Metered orders reject any code: there is no amount to discount at this point.
+             */
+            promotion_code?: string;
+            /**
+             * @description "This is the same click". Generate one when the dialog opens — not when it is submitted —
+             *     and send the same one on every retry of that action.
+             *
+             *     Optional, and what happens without it is worth knowing: two identical requests inside the
+             *     same minute are treated as one, because there is nothing else to tell a double-click apart
+             *     from a deliberate second order. Sending your own key removes that guess entirely.
+             */
+            idempotency_key?: string;
+            /**
+             * Format: uuid
+             * @description A disk type currently on sale. A withdrawn one is rejected even though its identifier still resolves
+             */
             disk_type_id: string;
             name: string;
             /** Format: int64 */
@@ -1545,6 +1708,18 @@ export interface components {
         AllocateFloatingIPRequestBody: {
             /** @description The address to allocate. Allocated by the platform when omitted */
             address?: string;
+            /**
+             * Format: int64
+             * @description The bandwidth ceiling of this address, in Mbit/s, applied to both directions.
+             *
+             *     Required, and there is no "unlimited": an address with no ceiling runs at line rate and is
+             *     charged nothing for the traffic, while the address itself bills normally — so the invoice
+             *     looks correct and nothing anywhere reports it.
+             *
+             *     It is billed separately from the address, per Mbit/s-hour, and appears as its own line on
+             *     the order. Changing it later goes through the bandwidth endpoint.
+             */
+            bandwidth_mbps: number;
             /** Format: uuid */
             private_network_id: string;
         };
@@ -1628,11 +1803,100 @@ export interface components {
             suspended_at: string | null;
             /** Format: date-time */
             updated_at: string;
+            /**
+             * @description How this instance is paid for. `postpaid` is billed by the hour for as long as it exists;
+             *     `prepaid` was bought outright for a term.
+             *
+             *     **Not the term.** How long it was bought for belongs to the order, not to the instance:
+             *     renewing can change it, and a machine bought for a year and then renewed for a month is
+             *     still a prepaid machine. Ask billing for the term and the expiry — they live there, and
+             *     they are the only two values a renewal moves.
+             * @enum {string}
+             */
+            charge_type: "postpaid" | "prepaid";
+            /**
+             * @description The order this instance was bought under, in billing's own identifiers. Empty when the
+             *     deployment has no billing wired in.
+             *
+             *     Kept so the question can be answered later. "Why was I charged for this" is asked days
+             *     after the fact, and an order id handed back only in the launch response is one the
+             *     person who needs it never had.
+             */
+            billing_order_id: string;
         };
         InstanceListResponseBody: {
             items: components["schemas"]["InstanceResource"][] | null;
         };
         LaunchInstanceRequestBody: {
+            /**
+             * @description A promotion code to apply to this order. Case and surrounding whitespace do not matter.
+             *
+             *     An unusable code is rejected outright rather than quietly ignored: somebody who typed a
+             *     code is buying at the discounted price, and letting it through silently means they pay
+             *     full price expecting the discount, with nothing anywhere saying so.
+             *
+             *     The discount applies to the lines the campaign covers, not the whole order — typically
+             *     the instance type and memory, not the system disk, the address, or traffic. Preview it
+             *     first at `POST /account/v1/billing-accounts/{accountKey}/promotion-codes/preview` to
+             *     show the customer what will actually be charged.
+             *
+             *     Metered orders reject any code: there is no amount to discount at this point.
+             */
+            promotion_code?: string;
+            /**
+             * @description "This is the same click". Generate one when the dialog opens — not when it is submitted —
+             *     and send the same one on every retry of that action.
+             *
+             *     Optional, and what happens without it is worth knowing: two identical requests inside the
+             *     same minute are treated as one, because there is nothing else to tell a double-click apart
+             *     from a deliberate second order. Sending your own key removes that guess entirely.
+             */
+            idempotency_key?: string;
+            /**
+             * Format: uuid
+             * @description Bind a floating IP you already hold, instead of allocating a new one. It must be idle and in
+             *     the same region.
+             *
+             *     Mutually exclusive with `bandwidth_mbps`: an address you already hold has its own bandwidth
+             *     ceiling, set when it was allocated, and changing it is a separate operation.
+             *
+             *     Like `bandwidth_mbps`, this happens **inside the creation**: if binding fails, no instance is
+             *     created. Binding afterwards is still possible from the instance page, but then it is two
+             *     operations and a failure in between leaves an instance you cannot reach.
+             *
+             *     Only one instance can be created when it is used — one address binds to one interface.
+             */
+            floating_ip_id?: string;
+            /**
+             * Format: int64
+             * @description Give this instance a public address with this much bandwidth, in Mbit/s. Omitted or 0 means
+             *     no public address.
+             *
+             *     Mutually exclusive with `floating_ip_id`, which binds one you already hold.
+             *
+             *     The bandwidth is what says whether an address is wanted, rather than a separate flag,
+             *     because an address with no ceiling would run at line rate and be charged nothing for the
+             *     traffic — while the address itself bills normally and the invoice looks correct.
+             *
+             *     The address and its bandwidth are two lines on the same order as the instance and its
+             *     system disk — one purchase with one total — and everything is created together or not at
+             *     all: if any step fails, the address goes back to the pool and no instance is created.
+             *     Asking for an address separately afterwards is still possible, but then they are separate
+             *     purchases, and a failure in between leaves an instance you cannot reach.
+             *
+             *     Both lines are always billed by the hour, even when the instance is bought outright for a
+             *     term: a public IPv4 is a scarce resource the platform keeps holding for as long as you have
+             *     it, so it is not something that can be paid for once.
+             *
+             *     Which address you get is not a choice here. Use the floating IP endpoints to claim a
+             *     particular address and bind it, which is what getting a known address back after a
+             *     migration needs.
+             *
+             *     Rejected together with `port_id` when that interface already has a floating IP: an
+             *     interface carries one IPv4, and one IPv4 takes one floating IP. Attach another interface to
+             *     hold a second address.
+             */
+            bandwidth_mbps?: number;
             /**
              * Format: int64
              * @description Number of instances to create; 1 when omitted. Names are numbered automatically for several
@@ -1647,10 +1911,13 @@ export interface components {
             boot_disk_id?: string;
             /**
              * Format: uuid
-             * @description A platform image. Exactly one of this, `private_image_id` and `boot_disk_id`
+             * @description A platform image, and it must be one currently on sale. Exactly one of this, `private_image_id` and `boot_disk_id`
              */
             image_id?: string;
-            /** Format: uuid */
+            /**
+             * Format: uuid
+             * @description An instance type currently on sale. A withdrawn one is rejected even though its identifier still resolves
+             */
             instance_type_id: string;
             /** @description The account the disk lets you log in as. Required with `boot_disk_id`, and rejected without it since an image states its own */
             login_username?: string;
@@ -1692,9 +1959,13 @@ export interface components {
              *     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.
+             *     The system disk is bought for the same term, because it is the same purchase: an instance
+             *     bought for a year whose disk is billed hourly is a bill nobody would predict from what they
+             *     clicked. A term is therefore refused together with `boot_disk_id`, where the disk already
+             *     exists and is already billed its own way.
+             *
+             *     A public address asked for with `assign_public_ip` stays hourly regardless — it cannot be
+             *     bought outright — so one order can carry both.
              *
              *     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
@@ -1715,6 +1986,23 @@ export interface components {
             subnet_id?: string;
         };
         LaunchInstanceResponseBody: {
+            /**
+             * @description The orders these instances were bought under, in the same order as `instances`.
+             *
+             *     **One per instance, not one per request.** A batch of three places three orders, because
+             *     each machine is ordered as it is created — stopping halfway leaves the machines already
+             *     made, and they each have to be paid for. A caller showing "your order" for a batch has to
+             *     show all of them.
+             *
+             *     Empty when the deployment has no billing wired in, and on the `checkout_url` branch where
+             *     nothing was created yet.
+             *
+             *     Given so the caller can point at the transaction. Creating a resource takes money — by
+             *     the hour from that moment for a metered one, in full from the balance for a prepaid one —
+             *     and until now the only thing handed back was the resource itself. Somebody asking "why
+             *     was I charged" had nothing to open.
+             */
+            order_ids?: string[] | null;
             /** @description Non-empty when only some of the instances were created, stating why the sequence stopped */
             failure: string | null;
             /** @description Returned in request order; an array even for a single instance */
@@ -1792,7 +2080,7 @@ export interface components {
             generate_password?: boolean;
             /**
              * Format: uuid
-             * @description A platform image. Exactly one of this and `private_image_id`
+             * @description A platform image, which must be on sale unless it is the one this instance already runs. Exactly one of this and `private_image_id`
              */
             image_id?: string;
             password?: string;

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

@@ -444,11 +444,6 @@ export interface components {
             /** Format: uuid */
             id: string;
             name: string;
-            /**
-             * Format: date-time
-             * @description 欠费的起始时间
-             */
-            overdue_at: string | null;
             /** @enum {string} */
             status: "ACTIVE" | "SUSPENDED" | "BANNED" | "DELETING" | "DELETED";
             /** @description 给人看的，不参与任何查询 */

package/package.json

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