@leaflow/sdk 0.0.0-dev.25.g6c5751f → 0.0.0-dev.252.gbe25f3b

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

@@ -19,7 +19,9 @@ export interface paths {
          *
          *     Disks attached to a running instance, including system disks, can be backed up.
          *
-         *     The duration depends on the amount of data. The backup is not complete when this endpoint returns; poll the retrieve endpoint.
+         *     The duration depends on the amount of data. The backup is not complete when this endpoint returns; track the returned task.
+         *
+         *     The backup is billed for its size, at the backup price of its region. Obtain a price with `create-backup-quote` first.
          */
         post: operations["create-backup"];
         delete?: never;
@@ -28,6 +30,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/backups/quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Quote a backup
+         * @description Prices the backup `create-backup` would order for the same disk, without ordering anything. Nothing is reserved and nothing is recorded, so this may be called as often as required.
+         *
+         *     The quantity priced is the size of the disk. When `price_id` is omitted, a price of the region's backup offering is selected; the returned line names it, and that `price_id` is the one to order with.
+         *
+         *     Prices may change between quoting and ordering. An order is charged at the price in effect when it is placed, so a quote should be refreshed before a final confirmation is shown.
+         */
+        post: operations["create-backup-quote"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/backups/{backupId}": {
         parameters: {
             query?: never;
@@ -45,6 +71,8 @@ export interface paths {
         /**
          * Delete a backup
          * @description Independent of the source disk: deletion succeeds whether or not that disk still exists.
+         *
+         *     Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the backup, including a pay-as-you-go subscription. `meta.resource_id` names the backup. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
          */
         delete: operations["delete-backup"];
         options?: never;
@@ -66,7 +94,7 @@ export interface paths {
          * Restore from a backup
          * @description Restores onto a **newly created** disk. The source disk is unaffected and need not still exist.
          *
-         *     The target disk type may belong to another availability zone of the same region, and its capacity must not be smaller than the backup. The disk cannot be attached until the restore completes; poll the disk retrieve endpoint.
+         *     The target disk type may belong to another availability zone of the same region, and its capacity must not be smaller than the backup. The disk cannot be attached until the restore completes; track the returned task.
          */
         post: operations["restore-backup"];
         delete?: never;
@@ -82,7 +110,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, both system disk types and data disk types; `for_system` narrows the list to one of the two. 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;
@@ -92,6 +123,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/disk-types/{diskTypeId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a disk type
+         * @description Retrieve capacity and performance constraints for an existing disk, including system disk types and types withdrawn from sale.
+         */
+        get: operations["get-disk-type"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/images": {
         parameters: {
             query?: never;
@@ -100,18 +151,99 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * 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.
+         * List images
+         * @description Lists the public images on sale together with the private images of this project. `visibility` narrows the list to one of the two.
+         *
+         *     A public image is offered to every project. Only public images currently on sale are listed: one 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.
+         *
+         *     A private image belongs to this project, which captured it from one of its instances, and is listed in every status, including while its capture is in progress and after the capture failed.
+         *
+         *     An image can only be used in the region that holds it. An image whose `min_ram_mb` exceeds the memory of the selected instance type cannot boot; filter the options accordingly.
          */
         get: operations["list-images"];
         put?: never;
-        post?: never;
+        /**
+         * Capture an instance as a private image
+         * @description Creates a private image of this project from the system disk of the instance; data disks are not included. The resulting image can create instances and rebuild them, and remains usable after the source instance is released.
+         *
+         *     **The image reflects the moment the capture started. Later changes to the instance are not included.**
+         *
+         *     The capture has two phases, reported by the status of the image:
+         *
+         *     - `provisioning` — the system disk is being read, usually for tens of seconds. The instance remains usable during this phase, although stopping it first is recommended for consistency.
+         *     - `uploading` — no longer tied to the system disk. **The instance may be started at this point; there is no need to wait for the capture to finish.** The duration of this phase is proportional to the size of the system disk, roughly 3 minutes for 20 GB.
+         *
+         *     The file system of a running instance may be captured mid-write, in which case the image is equivalent to the disk contents after a power loss. Where consistency matters, stop the instance before starting the capture and start it again once the status becomes `uploading`.
+         *
+         *     The instance can be started, stopped and used normally during the capture, but cannot be released.
+         *
+         *     The image is billed for the storage it occupies, at the private image price of its region. Obtain a price with `create-image-quote` first.
+         */
+        post: operations["create-image"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/images/quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Quote capturing an instance as a private image
+         * @description Prices the capture `create-image` would order for the same instance, without ordering anything. Nothing is reserved and nothing is recorded, so this may be called as often as required.
+         *
+         *     The quantity priced is the size of the system disk, which is the most the image can occupy. When `price_id` is omitted, a price of the region's private image offering is selected; the returned line names it, and that `price_id` is the one to order with.
+         *
+         *     Prices may change between quoting and ordering. An order is charged at the price in effect when it is placed, so a quote should be refreshed before a final confirmation is shown.
+         */
+        post: operations["create-image-quote"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
+    "/api/v1/images/{imageId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Retrieve an image
+         * @description Returns a public image, or a private image of this project; any other image is reported as not found. Use this endpoint to poll capture progress. When `status` is `error`, `failure` states the reason.
+         */
+        get: operations["get-image"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a private image
+         * @description Only a private image of this project can be deleted; any other image is reported as not found.
+         *
+         *     Deletion is rejected while instances created from the image still exist, as they need it in order to be rebuilt.
+         *
+         *     An image whose capture has not finished can be deleted; the capture is aborted.
+         *
+         *     Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the image, including a pay-as-you-go subscription. `meta.resource_id` names the image. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
+         */
+        delete: operations["delete-image"];
+        options?: never;
+        head?: never;
+        /**
+         * Rename a private image
+         * @description Only a private image of this project can be renamed; any other image is reported as not found.
+         */
+        patch: operations["rename-image"];
+        trace?: never;
+    };
     "/api/v1/instance-types": {
         parameters: {
             query?: never;
@@ -119,7 +251,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;
@@ -146,7 +281,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/regions/{regionCode}/availability-zones": {
+    "/api/v1/regions/{regionId}/availability-zones": {
         parameters: {
             query?: never;
             header?: never;
@@ -182,6 +317,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 is off sale is rejected with `DISK_TYPE_OFF_SALE`, even though its identifier still resolves. Types that are off sale do not appear in the disk type listing; disks already bought on one keep working and can still be resized.
          */
         post: operations["create-disk"];
         delete?: never;
@@ -207,6 +344,8 @@ export interface paths {
         /**
          * Delete a disk
          * @description Deletion is rejected while the disk is attached, or while snapshots created from it still exist.
+         *
+         *     Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the disk, including a pay-as-you-go subscription. `meta.resource_id` names the disk. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
          */
         delete: operations["delete-disk"];
         options?: never;
@@ -229,7 +368,13 @@ export interface paths {
         put?: never;
         /**
          * Resize a disk
-         * @description Capacity can only be increased; shrinking is not supported. Extend the file system inside the instance once the resize completes.
+         * @description Capacity can only be increased; shrinking is not supported. The resize is not complete when this endpoint returns; track the returned task, then extend the file system inside the instance.
+         *
+         *     **An attached data disk whose performance scales with its size must be detached before it is resized.** The performance of an attached disk does not change until the disk is detached and attached again, so such a request is refused with `DISK_RESIZE_NEEDS_DETACH` rather than providing the new capacity at the performance of the previous size. Detach the disk, resize it, and attach it again.
+         *
+         *     The request is refused only when the new size has a different performance level. A disk whose type has no QoS level, or whose performance has already reached the maximum of its type, can be resized while attached.
+         *
+         *     **A system disk can be resized while attached**, because a system disk cannot be detached. System disk types use a performance level that does not scale with size, so resizing a system disk does not change its performance.
          */
         post: operations["resize-disk"];
         delete?: never;
@@ -277,6 +422,8 @@ export interface paths {
          * @description If the private network is not yet connected to the internet, connectivity is established as part of this call.
          *
          *     IPv6 is not requested through this endpoint. IPv6 addresses are assigned to instances by the private network; enable IPv6 on that network instead.
+         *
+         *     Refused with `PRIVATE_NETWORK_UNAVAILABLE`, before any order is created, when the private network's `status` is not `available`. `meta.private_network_id` names it.
          */
         post: operations["allocate-floating-ip"];
         delete?: never;
@@ -298,7 +445,9 @@ export interface paths {
         post?: never;
         /**
          * Release a floating IP
-         * @description A released address enters a cooldown period before it is allocated again, so that DNS records and allow-lists still pointing at it do not break immediately. **The same address therefore cannot be re-allocated** for some time after release. Proceed with care.
+         * @description Releases the floating IP after unbinding it. Completion is reported by the returned task.
+         *
+         *     Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the address or for its bandwidth, including a pay-as-you-go subscription. `meta.resource_id` names the floating IP. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
          */
         delete: operations["release-floating-ip"];
         options?: never;
@@ -316,7 +465,9 @@ export interface paths {
         get?: never;
         /**
          * Set the bandwidth limit
-         * @description Limits both directions at once. Limiting egress alone does not prevent ingress traffic from saturating the uplink.
+         * @description The limit applies to inbound and outbound traffic alike. The new limit is not in effect when this endpoint returns; track the returned task.
+         *
+         *     While the address is bound to an instance, the limit must not exceed the `max_bandwidth_mbps` of that instance's type; a higher limit is refused with `INSTANCE_BANDWIDTH_CEILING`. The limit of an address that is not bound is checked when the address is bound to an instance.
          */
         put: operations["set-floating-ip-bandwidth"];
         post?: never;
@@ -354,22 +505,21 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** List instances */
+        /**
+         * List instances
+         * @description Every instance in the project, newest first. This endpoint does not query backend state; for the accurate state of one instance, use the retrieve endpoint.
+         */
         get: operations["list-instances"];
         put?: never;
         /**
          * Create instances
-         * @description **A password must be set in the request.** The request is rejected otherwise, since the resulting instance would be unreachable. The platform can generate one, in which case it is returned only in this response.
-         *
-         *     `count` creates several instances at once, 20 at most. Names are numbered `-1`, `-2` automatically and all instances share one password. **`instances` in the response is always an array**, including for a single instance.
+         * @description Creates a Billing order, including for metered pricing. The price must belong to the resource’s Billing Plan; applicable contract pricing is resolved by Billing. The instances are created after the order's invoice is paid, or without waiting when the order has no immediate invoice. Do not submit a new purchase after paying. After an uncertain response, look the order up before submitting again.
          *
-         *     Instances are created one by one in order. If the sequence stops part way through, because of a quota limit for example, **the instances already created are kept** and `failure` states why it stopped. A failure on the first instance is treated as a failure of the whole request and no instance is created.
+         *     Exactly one of image_id or boot_disk_id is required, and exactly one of port_id or subnet_id. Existing ports, boot disks or floating IPs require count=1. Image boots require boot_disk; existing disks retain their own subscription. Instances, disks and public IPs keep their own subscription items on the same order.
          *
-         *     Exactly one image source must be given: `image_id` for a platform image, `private_image_id` for a private image. Supplying both or neither is rejected.
+         *     A request for several instances is all or nothing: if any instance cannot be created, every instance of that request is released, the order fails, and any payment for it is refunded. Each instance is named after this request with a number appended, and each has its own task.
          *
-         *     Instances are created in the availability zone of the instance type. Disks to be attached later must reside in the same zone.
-         *
-         *     Creation is not complete when this endpoint returns and `status` is `provisioning`. Poll GET to observe the outcome.
+         *     The network is checked before the order is created, and a request it refuses orders and charges nothing. It is refused with `PRIVATE_NETWORK_UNAVAILABLE` when the private network's `status` is not `available`, `SUBNET_UNAVAILABLE` or `SECURITY_GROUP_UNAVAILABLE` when the subnet or a security group is not ready, `SECURITY_GROUP_OTHER_PRIVATE_NETWORK` when a security group belongs to another private network, and `PORT_UNAVAILABLE` when the port's `status` is not `available`. `meta` names the resource.
          */
         post: operations["launch-instance"];
         delete?: never;
@@ -397,6 +547,8 @@ export interface paths {
          * @description The system disk is deleted with the instance, and **snapshots created from the system disk are deleted with it**. Data disks are detached and kept, and their snapshots and backups are unaffected. The primary network interface is released with the instance.
          *
          *     An instance being captured as a private image cannot be released. Wait for the capture to finish, or delete that image first.
+         *
+         *     Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the instance, or for a disk that is deleted with it, including a pay-as-you-go subscription. `meta.resource_id` names that resource. The instance is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
          */
         delete: operations["delete-instance"];
         options?: never;
@@ -408,32 +560,6 @@ export interface paths {
         patch: operations["rename-instance"];
         trace?: never;
     };
-    "/api/v1/instances/{instanceId}/actions": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Start, stop or reboot an instance
-         * @description Reboot defaults to a soft reboot, in which the operating system shuts down normally before starting again.
-         *
-         *     A soft reboot has no effect once the system is unresponsive. Set `force` to reboot forcibly: a forced reboot does not wait for the operating system to shut down, so **unwritten data is lost**. `force` applies to `reboot` only.
-         *
-         *     An instance suspended by the platform must be unsuspended first.
-         *
-         *     This endpoint returns immediately and the `status` it returns is a transient state: `starting` for start, `stopping` for stop, `rebooting` for reboot. Poll the instance until it settles at `running` or `stopped`.
-         */
-        post: operations["act-on-instance"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/v1/instances/{instanceId}/commands": {
         parameters: {
             query?: never;
@@ -447,6 +573,10 @@ export interface paths {
          * Run a command on an instance
          * @description Runs one command over SSH and returns what it wrote. **This is not a shell.** There is no terminal, no standard input and no way to answer a prompt: a command that waits for input produces nothing and is killed at the timeout. Chain steps with `&&`, or write a script and run that.
          *
+         *     **A command that fails is still a 200.** Its failure is its own result, not this endpoint's: read `exit_code` for what it exited with and `stderr` for what it said, and decide from those. A `grep` that matches nothing exits 1 and is a perfectly successful call.
+         *
+         *     The status therefore answers a different question — did the command run at all. A non-2xx means it did not, and nothing about the instance was changed by this request: it was suspended, not running or had no floating IP; or it refused the platform key; or the connection could not be opened. Retrying is meaningful in those cases and is not for a non-zero `exit_code`.
+         *
          *     Three conditions must hold; the instance is unreachable otherwise:
          *
          *     - it is `running`
@@ -479,7 +609,7 @@ export interface paths {
          * Open a remote console
          * @description Operates the instance directly from a browser and does not require the instance to be reachable over the network, which makes it usable when a network misconfiguration prevents login.
          *
-         *     The returned address is single-use and expires within minutes. **Do not cache it**; request a new one before each use.
+         *     The returned address is single-use and expires within minutes. Request a new one before each use.
          */
         post: operations["open-instance-console"];
         delete?: never;
@@ -510,6 +640,54 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/instances/{instanceId}/labels": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Replace an instance's labels
+         * @description Records what this instance is for, as key-value pairs. Nothing on the platform reads them.
+         *
+         *     **The whole set is replaced**: whatever is absent from the request is removed.
+         *
+         *     Do not put credentials here. Labels are visible to platform operators.
+         */
+        put: operations["set-instance-labels"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/instances/{instanceId}/notes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Replace an instance's note
+         * @description A free-text note about this instance — what it runs, and what to be careful about before touching it.
+         *
+         *     **The whole note is replaced**; send an empty string to clear it.
+         *
+         *     Do not put credentials here. The note is visible to platform operators.
+         */
+        put: operations["set-instance-notes"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/instances/{instanceId}/password": {
         parameters: {
             query?: never;
@@ -534,6 +712,34 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/instances/{instanceId}/reboot": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reboot an instance
+         * @description A reboot defaults to soft, in which the operating system shuts down normally before starting again.
+         *
+         *     A soft reboot has no effect once the system is unresponsive. Set `force` to reboot forcibly: a forced reboot does not wait for the operating system to shut down, so **unwritten data is lost**.
+         *
+         *     A forced reboot is accepted while the instance is already `rebooting`, which is the way out of a soft reboot the instance never carried out. Every other endpoint refuses an instance in a transient state, and a second soft reboot is refused as well.
+         *
+         *     An instance suspended by the platform must be unsuspended first.
+         *
+         *     This endpoint returns immediately and the `status` it returns is the transient `rebooting`. Poll the instance until it settles at `running`.
+         */
+        post: operations["reboot-instance"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/instances/{instanceId}/rebuild": {
         parameters: {
             query?: never;
@@ -546,6 +752,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;
@@ -565,11 +773,9 @@ export interface paths {
         put?: never;
         /**
          * Resize an instance
-         * @description Only an instance type in the same region and availability zone can be selected, as attached disks cannot follow the instance elsewhere.
+         * @description Creates a Billing change order, including for metered pricing. The price must belong to the Billing Plan of the target instance type; applicable contract pricing is resolved by Billing. The resize is applied after the order's invoice is paid, or without waiting when the order has no immediate invoice. Do not submit a new purchase after paying. After an uncertain response, look the order up before submitting again.
          *
-         *     A resize has two steps. This endpoint restarts the instance on the new size and the status becomes `resize_verifying`, at which point the confirm or revert endpoint **must** be called. Until confirmation the target type is recorded in `pending_instance_type_id`, while `instance_type_id` remains the type in effect and billed.
-         *
-         *     **Both sizes hold resources while the resize is unconfirmed.** Confirm promptly once the status becomes `resize_verifying`.
+         *     The new instance type takes effect, and is billed from then on, when the returned task succeeds. A completed resize is final and cannot be reverted; to return to the previous type, submit another resize.
          */
         post: operations["resize-instance"];
         delete?: never;
@@ -578,7 +784,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/instances/{instanceId}/resize/confirm": {
+    "/api/v1/instances/{instanceId}/start": {
         parameters: {
             query?: never;
             header?: never;
@@ -588,17 +794,17 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Confirm a resize
-         * @description Releases the resources held by the previous size. `pending_instance_type_id` becomes the type in effect and is billed from then on.
+         * Start an instance
+         * @description Records the desired power state. An in-flight shutdown is allowed to finish before a subsequent start. Outstanding restrictions can prevent starting. A stopped instance keeps its disks, network attachments and sellable quota. Inspect operation, task_state, power_state and observed_at to determine completion.
          */
-        post: operations["confirm-instance-resize"];
+        post: operations["start-instance"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/v1/instances/{instanceId}/resize/revert": {
+    "/api/v1/instances/{instanceId}/stop": {
         parameters: {
             query?: never;
             header?: never;
@@ -608,10 +814,10 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Revert a resize
-         * @description The instance returns to its previous size, `pending_instance_type_id` is discarded, and billing is unaffected by the resize.
+         * Stop an instance
+         * @description Records the desired power state. An in-flight shutdown is allowed to finish before a subsequent start. Outstanding restrictions can prevent starting. A stopped instance keeps its disks, network attachments and sellable quota. Inspect operation, task_state, power_state and observed_at to determine completion.
          */
-        post: operations["revert-instance-resize"];
+        post: operations["stop-instance"];
         delete?: never;
         options?: never;
         head?: never;
@@ -652,6 +858,8 @@ export interface paths {
         /**
          * Detach a disk
          * @description Unmount the device inside the instance before calling this endpoint. Forcibly detaching a file system that is being written to corrupts data.
+         *
+         *     The disk the instance boots from cannot be detached, whether it is the system disk bought with the instance or a disk the instance was created from with `boot_disk_id`. Such a request is refused with `INSTANCE_BOOT_DISK_LOCKED` and creates no task; releasing the instance is what frees that disk.
          */
         delete: operations["detach-disk"];
         options?: never;
@@ -670,7 +878,7 @@ export interface paths {
         put?: never;
         /**
          * Bind a floating IP to an instance
-         * @description The floating IP is bound to the primary network interface of the instance.
+         * @description Changes the public IP binding on the instance's primary network interface. The returned task tracks confirmation of the binding change.
          */
         post: operations["attach-instance-floating-ip"];
         delete?: never;
@@ -689,7 +897,10 @@ export interface paths {
         get?: never;
         put?: never;
         post?: never;
-        /** Unbind the floating IP of an instance */
+        /**
+         * Unbind the floating IP of an instance
+         * @description Changes the public IP binding on the instance's primary network interface. The returned task tracks confirmation of the binding change.
+         */
         delete: operations["detach-instance-floating-ip"];
         options?: never;
         head?: never;
@@ -799,65 +1010,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/private-images": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /** List private images */
-        get: operations["list-private-images"];
-        put?: never;
-        /**
-         * Capture an instance as a private image
-         * @description Captured from the system disk of the instance; data disks are not included. The resulting image can create instances and rebuild them, and remains usable after the source instance is released.
-         *
-         *     **The image reflects the moment the capture started. Later changes to the instance are not included.**
-         *
-         *     The capture has two phases. Poll the retrieve endpoint:
-         *
-         *     - `provisioning` — the system disk is being read, usually for tens of seconds. The instance remains usable during this phase, although stopping it first is recommended for consistency.
-         *     - `uploading` — no longer tied to the system disk. **The instance may be started at this point; there is no need to wait for the capture to finish.** The duration of this phase is proportional to the size of the system disk, roughly 3 minutes for 20 GB.
-         *
-         *     The file system of a running instance may be captured mid-write, in which case the image is equivalent to the disk contents after a power loss. Where consistency matters, stop the instance before starting the capture and start it again once the status becomes `uploading`.
-         *
-         *     The instance can be started, stopped and used normally during the capture, but cannot be released.
-         */
-        post: operations["create-private-image"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/v1/private-images/{privateImageId}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * Retrieve a private image
-         * @description Use this endpoint to poll capture progress. When `status` is `error`, `failure` states the reason.
-         */
-        get: operations["get-private-image"];
-        put?: never;
-        post?: never;
-        /**
-         * Delete a private image
-         * @description Deletion is rejected while instances created from the image still exist, as they need it in order to be rebuilt.
-         *
-         *     An image whose capture has not finished can be deleted; the capture is aborted.
-         */
-        delete: operations["delete-private-image"];
-        options?: never;
-        head?: never;
-        /** Rename a private image */
-        patch: operations["rename-private-image"];
-        trace?: never;
-    };
     "/api/v1/private-networks": {
         parameters: {
             query?: never;
@@ -1148,7 +1300,10 @@ export interface paths {
         get: operations["get-snapshot"];
         put?: never;
         post?: never;
-        /** Delete a snapshot */
+        /**
+         * Delete a snapshot
+         * @description Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the snapshot, including a pay-as-you-go subscription. `meta.resource_id` names the snapshot. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
+         */
         delete: operations["delete-snapshot"];
         options?: never;
         head?: never;
@@ -1156,28 +1311,174 @@ export interface paths {
         patch: operations["rename-snapshot"];
         trace?: never;
     };
-}
-export type webhooks = Record<string, never>;
-export interface components {
-    schemas: {
-        Error: {
-            code?: string;
-            message: string;
-            meta?: {
-                [key: string]: unknown;
-            };
-            /** Format: int64 */
-            status: number;
-        };
+    "/api/v1/tasks/{taskId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a requested action */
+        get: operations["get-task"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/ipv4-pools": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List public IP pools
+         * @description Lists the public IP pools available for new allocations in this region.
+         */
+        get: operations["list-ipv4-pools"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/peerings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List peerings */
+        get: operations["list-peerings"];
+        put?: never;
+        /**
+         * Create peering
+         * @description Request IPv4 peering between non-overlapping VPCs in the same Region. The target project must accept before any connectivity is created. Does not change security groups or provide transitive routing.
+         */
+        post: operations["create-peering"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/peerings/{peeringId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get peering */
+        get: operations["get-peering"];
+        put?: never;
+        post?: never;
+        /** Delete peering */
+        delete: operations["delete-peering"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/peerings/{peeringId}/accept": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Accept peering */
+        post: operations["accept-peering"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/peerings/{peeringId}/reject": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Reject peering */
+        post: operations["reject-peering"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        PeeringResource: {
+            /** Format: uuid */
+            id: string;
+            name: string;
+            /** Format: uuid */
+            region_id: string;
+            /** Format: uuid */
+            requester_project_id: string;
+            /** Format: uuid */
+            accepter_project_id: string;
+            /** Format: uuid */
+            requester_network_id: string;
+            /** Format: uuid */
+            accepter_network_id: string;
+            /** @enum {string} */
+            status: "pending_acceptance" | "provisioning" | "active" | "deleting" | "deleted" | "rejected" | "error";
+            /** Format: date-time */
+            created_at: string;
+            failure_code?: string;
+        };
+        PeeringListResponseBody: {
+            items: components["schemas"]["PeeringResource"][];
+            pagination: components["schemas"]["OffsetPagination"];
+        };
+        CreatePeeringRequestBody: {
+            name: string;
+            /** Format: uuid */
+            requester_network_id: string;
+            /** Format: uuid */
+            accepter_project_id: string;
+            /** Format: uuid */
+            accepter_network_id: string;
+        };
+        Error: {
+            code?: string;
+            message: string;
+            /**
+             * @description What a given `code` carries alongside the message. The keys depend on the code,
+             *     and a client that does not recognise one ignores it.
+             */
+            meta?: {
+                [key: string]: unknown;
+            };
+            /** Format: int64 */
+            status: number;
+        };
         BackupResource: {
-            /** @description Availability zone of the source disk. A restore may target another zone in the same region */
-            availability_zone: string;
             /** Format: date-time */
             created_at: string;
             /** Format: uuid */
             id: string;
             name: string;
-            region_code: string;
+            /** Format: uuid */
+            region_id: string;
             /**
              * Format: int64
              * @description Capacity of the source disk when the backup was created. A restored disk cannot be smaller than this
@@ -1190,14 +1491,53 @@ export interface components {
             source_disk_id: string;
             /** @enum {string} */
             status: "provisioning" | "available" | "restoring" | "deleting" | "error";
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @description The subscriptions a cancellation through Billing has to cover to release this backup: its own. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+            release_subscription_ids: string[];
+            /** @description The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+            release_set: components["schemas"]["ReleaseSetItem"][];
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            task: components["schemas"]["Task"] | null;
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
+            /**
+             * Format: uuid
+             * @description Availability zone of the source disk. A restore may target another zone in the same region
+             */
+            source_availability_zone_id: string;
         };
         BackupListResponseBody: {
             items: components["schemas"]["BackupResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateBackupRequestBody: {
             /** Format: uuid */
             disk_id: string;
             name: string;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
+        };
+        /** @description The fields of `CreateBackupRequestBody` that decide the price */
+        CreateBackupQuoteRequestBody: {
+            /**
+             * Format: uuid
+             * @description The disk that would be backed up
+             */
+            disk_id: string;
+            /**
+             * Format: uuid
+             * @description A price of the region's backup offering. One is selected when omitted
+             */
+            price_id?: string;
         };
         RenameBackupRequestBody: {
             name: string;
@@ -1205,7 +1545,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 a data disk type on sale — restoring creates a new data disk, so a withdrawn type or a system disk type is rejected here as well
              */
             disk_type_id: string;
             name: string;
@@ -1214,33 +1554,83 @@ export interface components {
              * @description Matches the size of the backup when omitted. When given, it must not be smaller than the backup
              */
             size_gb?: number;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         DiskResource: {
-            attached_instance_id: string | null;
-            /** @description Availability zone the disk actually resides in. An instance must be in the same zone to attach it */
-            availability_zone: string;
+            /**
+             * Format: uuid
+             * @description Availability zone the disk actually resides in. An instance must be in the same zone to attach it
+             */
+            availability_zone_id: string;
             /** Format: date-time */
             created_at: string;
-            /** @description Device name assigned by the system, as seen inside the instance */
-            device: string | null;
             /** Format: uuid */
             disk_type_id: string;
             /** Format: uuid */
             id: string;
-            /** @description A system disk is released with its instance and can be neither detached nor deleted individually */
-            is_system: boolean;
             name: string;
-            region_code: string;
+            /** Format: uuid */
+            region_id: 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";
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @description The subscriptions a cancellation through Billing has to cover to release this disk: its own and those of its snapshots. A system disk is released only with its instance, so for a system disk the list is that of the instance. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+            release_subscription_ids: string[];
+            /** @description The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+            release_set: components["schemas"]["ReleaseSetItem"][];
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            task: components["schemas"]["Task"] | null;
+            attachment?: components["schemas"]["DiskAttachment"] | null;
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
         };
         DiskTypeResource: {
-            availability_zone_code: string;
+            /** Format: uuid */
+            availability_zone_id: string;
             /** Format: uuid */
             id: string;
-            iops_display: string;
+            /** @description True for a system disk type, the one chosen as `boot_disk.disk_type_id` when creating an instance from an image. A system disk type cannot be used to create a data disk, and a data disk type cannot be used for a system disk. */
+            for_system: boolean;
+            /**
+             * 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} */
@@ -1248,39 +1638,134 @@ export interface components {
             /** Format: int64 */
             min_size_gb: number;
             name: string;
-            region_code: string;
+            /** Format: uuid */
+            region_id: 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 Billing Product ID. Null when no Product is assigned; otherwise `compute`. */
+            product_id: string | null;
+            /** Format: uuid */
+            plan_id: string | null;
+            /** Format: uuid */
+            snapshot_plan_id: string | null;
         };
         DiskTypeListResponseBody: {
             items: components["schemas"]["DiskTypeResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
+        /**
+         * @description Who can see and use an image. `public` — offered to every project by the platform. `private` — usable only by the project that owns it.
+         * @enum {string}
+         */
+        ImageVisibility: "public" | "private";
+        /** @description An image that installs the system of an instance. Fields that describe a capture or its billing apply only to private images and are null, zero or empty for public ones. */
         ImageResource: {
-            architecture: string;
             /** Format: uuid */
             id: string;
-            /** Format: int64 */
-            min_disk_gb: number;
-            /** Format: int64 */
-            min_ram_mb: number;
+            /** Format: uuid */
+            region_id: string;
+            visibility: components["schemas"]["ImageVisibility"];
             name: string;
             os_family: string;
             os_version: string;
-            region_code: string;
+            architecture: string;
+            /** @description The account this image lets you log in as. The password set at creation belongs to this account */
+            login_username: string;
+            /**
+             * Format: int64
+             * @description The system disk of an instance created from this image cannot be smaller than this
+             */
+            min_disk_gb: number;
+            /**
+             * Format: int64
+             * @description The instance type of an instance created from this image must have at least this much memory
+             */
+            min_ram_mb: number;
             /** @description False means a new password can only be set by rebuilding an instance created from this image */
             supports_password_reset: boolean;
+            /**
+             * @description Only `available` images can install instances. A public image is always `available`; a private image goes through `provisioning` and `uploading` while it is captured.
+             * @enum {string}
+             */
+            status: "provisioning" | "uploading" | "available" | "deleting" | "error";
+            /** @description Reason the capture failed; non-empty only when `status` is `error` */
+            failure: string | null;
+            /**
+             * Format: int64
+             * @description Storage occupied by a private image, which is what it is billed for; 0 until its capture completes, and 0 for public images
+             */
+            size_bytes: number;
+            /**
+             * Format: uuid
+             * @description The instance a private image was captured from. The image remains usable after that instance is released. Null for public images
+             */
+            source_instance_id: string | null;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @description The subscriptions a cancellation through Billing has to cover to release this private image: its own. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for it, and for public images. */
+            release_subscription_ids: string[];
+            /** @description The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+            release_set: components["schemas"]["ReleaseSetItem"][];
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            task: components["schemas"]["Task"] | null;
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
         };
         ImageListResponseBody: {
-            items: components["schemas"]["ImageResource"][] | null;
+            items: components["schemas"]["ImageResource"][];
+            pagination: components["schemas"]["OffsetPagination"];
         };
         InstanceTypeResource: {
-            /** @description Availability zone of this instance type. A disk must be in the same zone to be attached */
-            availability_zone_code: string;
+            /** Format: uuid */
+            availability_zone_id: 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 */
@@ -1288,33 +1773,54 @@ export interface components {
             name: string;
             /** Format: int64 */
             ram_mb: number;
-            region_code: string;
+            /** Format: uuid */
+            region_id: string;
             /** Format: int64 */
             vcpus: number;
+            /** @description Billing Product ID. Null when no Product is assigned; otherwise `compute`. */
+            product_id: string | null;
+            /** Format: uuid */
+            plan_id: string | null;
         };
         InstanceTypeListResponseBody: {
-            items: components["schemas"]["InstanceTypeResource"][] | null;
+            items: components["schemas"]["InstanceTypeResource"][];
+            pagination: components["schemas"]["OffsetPagination"];
         };
         RegionResource: {
-            code: string;
+            /** @description ISO 3166-1 alpha-2 country this region sits in. Two letters, uppercase. */
             country_code: string;
+            /** @description Display name for this place, shown to tenants (Hong Kong). The stable handle is code. */
             name: string;
+            /** @description The region's code, the way the outside world names this place (hk-1). Stable and human-written; addressing is by id. */
+            code: string;
+            /** Format: uuid */
+            id: string;
         };
         RegionListResponseBody: {
             items: components["schemas"]["RegionResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         ZoneResource: {
-            code: string;
+            /** @description Display name for this zone, shown to tenants (Hong Kong A). The stable handle is code. */
             name: string;
+            /** @description The zone's code within its region (hk-1-a). Stable and human-written; addressing is by id. */
+            code: string;
+            /** Format: uuid */
+            id: string;
         };
         ZoneListResponseBody: {
             items: components["schemas"]["ZoneResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         DiskListResponseBody: {
             items: components["schemas"]["DiskResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateDiskRequestBody: {
-            /** Format: uuid */
+            /**
+             * Format: uuid
+             * @description A data disk type currently on sale, one whose `for_system` is false. A withdrawn one is rejected even though its identifier still resolves
+             */
             disk_type_id: string;
             name: string;
             /** Format: int64 */
@@ -1324,6 +1830,9 @@ export interface components {
              * @description Restore from this snapshot. When given, the capacity need only be no smaller than the snapshot
              */
             snapshot_id?: string;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         RenameDiskRequestBody: {
             name: string;
@@ -1334,6 +1843,9 @@ export interface components {
              * @description Must be larger than the current capacity
              */
             size_gb: number;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         RevertDiskRequestBody: {
             /**
@@ -1344,31 +1856,71 @@ export interface components {
         };
         FloatingIPResource: {
             address: string;
-            attached_fixed_ip: string | null;
-            attached_port_id: string | null;
             /** Format: int64 */
             bandwidth_mbps: number | null;
             /** Format: date-time */
             created_at: string;
-            /** Format: date-time */
-            detached_at: string | null;
             /** Format: uuid */
             id: string;
-            region_code: string;
-            /**
-             * @description `idle` means the address is not bound to a network interface
-             * @enum {string}
-             */
-            status: "idle" | "bound";
+            /** Format: uuid */
+            region_id: string;
+            /** @enum {string} */
+            status: "pending" | "available" | "deleting" | "error" | "unknown";
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @description The subscriptions a cancellation through Billing has to cover to release this address: the subscriptions of the address and of its bandwidth. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+            release_subscription_ids: string[];
+            /** @description The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+            release_set: components["schemas"]["ReleaseSetItem"][];
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            task: components["schemas"]["Task"] | null;
+            /** Format: uuid */
+            bandwidth_order_id: string | null;
+            /** Format: uuid */
+            bandwidth_price_id: string | null;
+            /** Format: uuid */
+            bandwidth_subscription_item_id: string | null;
+            /** @enum {string|null} */
+            bandwidth_access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
+            binding: components["schemas"]["IPv4Binding"] | null;
         };
         FloatingIPListResponseBody: {
             items: components["schemas"]["FloatingIPResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         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;
+            /** Format: uuid */
+            ipv4_pool_id: string;
+            /** Format: uuid */
+            price_id: string;
+            /** Format: uuid */
+            bandwidth_price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         SetBandwidthRequestBody: {
             /**
@@ -1376,13 +1928,17 @@ export interface components {
              * @description Applied to both directions
              */
             mbps: number;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         BindFloatingIPRequestBody: {
             /** Format: uuid */
-            port_id: string;
+            port_address_id: string;
         };
         InstanceResource: {
-            availability_zone: string;
+            /** Format: uuid */
+            availability_zone_id: string;
             /** Format: date-time */
             created_at: string;
             /** @description Hostname inside the instance; equals the instance id */
@@ -1391,7 +1947,7 @@ export interface components {
             id: string;
             /**
              * Format: uuid
-             * @description Non-empty when the instance was created from a platform image
+             * @description Non-empty when the instance was created from an image, public or private
              */
             image_id: string | null;
             /**
@@ -1401,79 +1957,112 @@ export interface components {
             instance_type_id: string;
             /** @description IPv6 address of the primary network interface. Assigned automatically once IPv6 is enabled on the private network */
             ipv6_address: string | null;
+            /** @description Your own classification of this instance, as key-value pairs. Empty when never set */
+            labels: {
+                [key: string]: string;
+            };
+            /** @description The account to log in as over SSH. The password set at creation belongs to this account */
+            login_username: string;
             name: string;
-            /**
-             * Format: uuid
-             * @description Non-empty while a resize awaits confirmation. Confirming puts this type into effect, reverting discards it
-             */
-            pending_instance_type_id: string | null;
-            /**
-             * Format: uuid
-             * @description Non-empty when the instance was created from a private image
-             */
-            private_image_id: string | null;
+            /** @description A free-text note about this instance. Empty when never set */
+            notes: string;
             /** @description Private address of the instance */
             private_ip: string | null;
-            /** @description Private network of the primary network interface */
+            /** Format: uuid */
             private_network_id: string | null;
             /** @description Floating IPv4 addresses bound to the primary network interface; an empty array when none are bound */
             public_ips: string[] | null;
-            region_code: string;
-            /**
-             * @description Only `running` and `stopped` accept commands. Every other value means the instance is changing, and start, stop, reboot, resize, rebuild and password reset are all rejected.
-             *
-             *     `transitioning` is the fallback for a change that falls into none of the categories above. It does not indicate an error; keep polling.
-             *
-             *     `resize_verifying` is not transient: the instance is running on the new size and stays there until the resize is confirmed or reverted, with both sizes billed in the meantime.
-             * @enum {string}
-             */
-            status: "provisioning" | "running" | "stopped" | "starting" | "stopping" | "rebooting" | "transitioning" | "resizing" | "resize_verifying" | "error" | "deleting" | "suspended";
-            /** @description Subnet of the primary network interface */
+            /** Format: uuid */
+            region_id: string;
+            /** @enum {string} */
+            status: "pending" | "building" | "active" | "stopped" | "paused" | "suspended" | "shelved" | "shelved_offloaded" | "rescued" | "deleting" | "deleted" | "error" | "unknown";
+            /** Format: uuid */
             subnet_id: string | null;
+            /** Format: date-time */
+            updated_at: string;
+            /** @enum {string} */
+            desired_state: "running" | "stopped" | "deleted";
+            /** @enum {string} */
+            power_state: "no_state" | "running" | "paused" | "shutdown" | "crashed" | "suspended" | "unknown";
+            /** @description Current provider task, such as scheduling, networking, block_device_mapping or spawning. none means no task; unknown tasks remain observable and do not imply failure. */
+            task_state: string;
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
+            restrictions: components["schemas"]["InstanceRestriction"][];
+            task: components["schemas"]["Task"] | null;
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @description The subscriptions a cancellation through Billing has to cover to release this instance: its own, those of the disks deleted with it, and those of the snapshots of those disks. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+            release_subscription_ids: string[];
+            /** @description The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+            release_set: components["schemas"]["ReleaseSetItem"][];
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
             /**
-             * Format: date-time
-             * @description Non-empty once the platform has suspended the instance, which must be lifted before any operation
+             * Format: uuid
+             * @description Non-empty when the instance was created from a disk you already had, instead of from an image
              */
-            suspended_at: string | null;
-            /** Format: date-time */
-            updated_at: string;
+            source_disk_id: string | null;
         };
         InstanceListResponseBody: {
-            items: components["schemas"]["InstanceResource"][] | null;
+            items: components["schemas"]["InstanceResource"][];
+            pagination: components["schemas"]["OffsetPagination"];
         };
         LaunchInstanceRequestBody: {
+            /**
+             * 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 Number of instances to create; 1 when omitted. Names are numbered automatically for several
+             * @default 1
              */
             count?: number;
             /** @description Have the platform generate a random password, returned only in this response */
             generate_password?: boolean;
             /**
              * Format: uuid
-             * @description A platform image. Exactly one of this and `private_image_id`
+             * @description Boot a disk you already have instead of installing an image. The disk must be available, unattached, and in the same availability zone as the instance type. Exactly one of this and `image_id`
+             */
+            boot_disk_id?: string;
+            /**
+             * Format: uuid
+             * @description A public image currently on sale, or an available private image of this project. Exactly one of this 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;
             name: string;
-            /** @description Root password. Only the SSH public keys of the project are used when omitted */
+            /** @description The password to set, on the login account and on root. Only the SSH public keys of the project are used when omitted */
             password?: string;
             /**
              * Format: uuid
              * @description Use an existing network interface, which may already have a floating IP bound. Exactly one of this and `subnet_id`; only one instance can be created when it is used
              */
             port_id?: string;
-            /**
-             * Format: uuid
-             * @description A private image. Exactly one of this and `image_id`
-             */
-            private_image_id?: string;
-            /**
-             * Format: int64
-             * @description System disk capacity in GB. Chosen automatically from the requirement of the image and the platform minimum when omitted
-             */
-            root_disk_gb?: number;
             /** @description Required when a primary network interface is created, at least one; the default security group is not applied automatically. Ignored together with `port_id`, as the security groups of that interface were fixed when it was created */
             security_group_ids?: string[] | null;
             /**
@@ -1481,22 +2070,27 @@ export interface components {
              * @description Create the primary network interface in this subnet. Exactly one of this and `port_id`
              */
             subnet_id?: string;
+            order: components["schemas"]["OrderOptions"];
+            /** Format: uuid */
+            price_id: string;
+            boot_disk?: components["schemas"]["NewBootDisk"];
+            floating_ip?: components["schemas"]["NewFloatingIP"];
         };
-        LaunchInstanceResponseBody: {
-            /** @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 */
-            instances: components["schemas"]["InstanceResource"][] | null;
-            /** @description Returned only in this response; store it immediately. All instances of a batch share it */
-            password: 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 */
+            labels: {
+                [key: string]: string;
+            };
+        };
+        SetInstanceNotesRequestBody: {
+            /** @description The complete note. Send an empty string to clear it */
+            notes: string;
         };
         RenameInstanceRequestBody: {
             name: string;
         };
-        ActOnInstanceRequestBody: {
-            /** @enum {string} */
-            action: "start" | "stop" | "reboot";
-            /** @description Applies to `reboot` only. A forced reboot does not wait for the operating system to shut down and unwritten data is lost; use it when the system is unresponsive */
+        RebootInstanceRequestBody: {
+            /** @description A forced reboot does not wait for the operating system to shut down and unwritten data is lost; use it when the system is unresponsive. False when omitted */
             force?: boolean;
         };
         RunCommandRequestBody: {
@@ -1507,16 +2101,11 @@ export interface components {
              * @description Kill the command after this long. 60 when omitted
              */
             timeout_seconds?: number;
-            /**
-             * @description The SSH user to log in as. It is the account the platform sets a password for at creation
-             * @default root
-             */
-            username?: string;
         };
         CommandResultResponseBody: {
             /**
              * Format: int64
-             * @description Null when the command was killed rather than finishing on its own, which includes the timeout
+             * @description What the command exited with, 0 being success. Any other value is the command's own verdict and still arrives as a 200. Null when it was killed rather than exiting on its own, which includes the timeout — null is the absence of a verdict, not a successful one
              */
             exit_code: number | null;
             stderr: string;
@@ -1548,15 +2137,10 @@ export interface components {
             generate_password?: boolean;
             /**
              * Format: uuid
-             * @description A platform image. Exactly one of this and `private_image_id`
+             * @description A public image, which must be on sale unless it is the one this instance already runs, or an available private image of this project
              */
-            image_id?: string;
+            image_id: string;
             password?: string;
-            /**
-             * Format: uuid
-             * @description A private image. Exactly one of this and `image_id`
-             */
-            private_image_id?: string;
         };
         RebuildInstanceResponseBody: {
             instance: components["schemas"]["InstanceResource"];
@@ -1569,6 +2153,9 @@ export interface components {
              * @description Must be in the same region and availability zone as the current instance type
              */
             instance_type_id: string;
+            order: components["schemas"]["OrderOptions"];
+            /** Format: uuid */
+            price_id: string;
         };
         AttachDiskRequestBody: {
             /** Format: uuid */
@@ -1579,24 +2166,26 @@ export interface components {
             floating_ip_id: string;
         };
         PortResource: {
-            attached_instance_id: string | null;
             /** Format: uuid */
             id: string;
-            ipv6_address: string | null;
-            /** @description A primary network interface is created and released with its instance and cannot be detached individually */
-            is_primary: boolean;
             mac: string | null;
             name: string;
-            private_ip: string | null;
             /** Format: uuid */
             private_network_id: string;
             /** @description Floating IPv4 addresses bound to this network interface; an empty array when none are bound */
             public_ips: string[] | null;
-            /** Format: uuid */
-            subnet_id: string;
+            addresses?: components["schemas"]["PortAddress"][];
+            attachment?: components["schemas"]["PortAttachment"] | null;
+            /** @enum {string} */
+            status: "pending" | "available" | "deleting" | "error" | "unknown";
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
         };
         PortListResponseBody: {
             items: components["schemas"]["PortResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         AttachPortRequestBody: {
             /** Format: uuid */
@@ -1607,6 +2196,12 @@ export interface components {
             action: string;
             /** @description The user who initiated the operation. Empty when the platform performed it */
             actor: string | null;
+            /**
+             * @description The name this user went by at the time of the operation, recorded alongside the operation itself. It is not refreshed afterwards: the record states who acted then, and a name read today is a statement about a different moment.
+             *
+             *     Null on entries recorded before this field existed, and on entries performed by the platform. An empty string means the account had no name recorded.
+             */
+            actor_name: string | null;
             /** @description True when the operation was performed by the platform */
             by_platform: boolean;
             /** Format: date-time */
@@ -1619,76 +2214,51 @@ export interface components {
             payload: {
                 [key: string]: unknown;
             };
-            region_code: string | null;
+            /** Format: uuid */
+            region_id: string | null;
             /** @description Empty for create operations: the id of the new resource is in the response, not in the request path */
             subject_id: string;
             subject_type: string;
             succeeded: boolean;
         };
         OperationLogListResponseBody: {
-            items: components["schemas"]["OperationLogResource"][] | null;
-            /** Format: int64 */
-            total: number;
+            items: components["schemas"]["OperationLogResource"][];
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreatePortRequestBody: {
             name?: string;
-            /** @description The private address to assign. Allocated automatically when omitted */
-            private_ip?: string;
             /** @description At least one, and all must belong to the same private network */
             security_group_ids: string[] | null;
             /** Format: uuid */
             subnet_id: string;
+            /** @description The private address to assign. Allocated automatically when omitted */
+            address?: string;
         };
-        PrivateImageResource: {
-            architecture: string;
-            /** Format: date-time */
-            created_at: string;
-            /** @description Reason the capture failed; non-empty only when `status` is `error` */
-            failure: string | null;
-            /** Format: uuid */
-            id: string;
-            /**
-             * Format: int64
-             * @description The system disk of an instance created from this image cannot be smaller than this
-             */
-            min_disk_gb: number;
+        CreateImageRequestBody: {
             /**
-             * Format: int64
-             * @description The instance type of an instance created from this image must have at least this much memory
+             * Format: uuid
+             * @description Captured from the system disk of this instance; data disks are not included
              */
-            min_ram_mb: number;
+            instance_id: string;
             name: string;
-            os_family: string;
-            os_version: string;
-            /** @description An image can only be used in the region that holds it */
-            region_code: string;
-            /**
-             * Format: int64
-             * @description Storage occupied by the image; 0 until the capture completes
-             */
-            size_bytes: number;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
+        };
+        /** @description The fields of `CreateImageRequestBody` that decide the price */
+        CreateImageQuoteRequestBody: {
             /**
              * Format: uuid
-             * @description The instance this image was captured from. The image remains usable after that instance is released
+             * @description The instance whose system disk would be captured
              */
-            source_instance_id: string | null;
-            /** @enum {string} */
-            status: "provisioning" | "uploading" | "available" | "deleting" | "error";
-            /** @description False means a new password can only be set by rebuilding an instance created from this image */
-            supports_password_reset: boolean;
-        };
-        PrivateImageListResponseBody: {
-            items: components["schemas"]["PrivateImageResource"][] | null;
-        };
-        CreatePrivateImageRequestBody: {
+            instance_id: string;
             /**
              * Format: uuid
-             * @description Captured from the system disk of this instance; data disks are not included
+             * @description A price of the region's private image offering. One is selected when omitted
              */
-            instance_id: string;
-            name: string;
+            price_id?: string;
         };
-        RenamePrivateImageRequestBody: {
+        RenameImageRequestBody: {
             name: string;
         };
         PrivateNetworkResource: {
@@ -1699,20 +2269,26 @@ export interface components {
             /** Format: uuid */
             id: string;
             name: string;
-            region_code: string;
-            /** @enum {string} */
-            status: "available" | "error";
+            /** Format: uuid */
+            region_id: string;
+            /**
+             * @description Only `available` accepts new instances, interfaces and floating IPs
+             * @enum {string}
+             */
+            status: "pending" | "available" | "deleting" | "error" | "unknown";
             /** Format: date-time */
             updated_at: string;
         };
         PrivateNetworkListResponseBody: {
             items: components["schemas"]["PrivateNetworkResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreatePrivateNetworkRequestBody: {
             /** @description Must be an RFC 1918 private CIDR with a prefix length between /8 and /24, for example `10.0.0.0/16` */
             cidr: string;
             name: string;
-            region_code: string;
+            /** Format: uuid */
+            region_id: string;
         };
         RenamePrivateNetworkRequestBody: {
             name: string;
@@ -1728,16 +2304,23 @@ export interface components {
             status: "pending" | "active" | "draining";
         };
         RouteResource: {
+            /**
+             * Format: uuid
+             * @description System-owned peering route. Delete the peering to remove this route.
+             */
+            peering_id?: string;
             /** Format: date-time */
             created_at: string;
             description: string;
             destination: string;
             /** Format: uuid */
             id: string;
-            nexthop: string;
+            /** @description Present for custom routes; peering routes expose peering_id instead. */
+            nexthop?: string;
         };
         RouteListResponseBody: {
             items: components["schemas"]["RouteResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateRouteRequestBody: {
             description?: string;
@@ -1762,6 +2345,7 @@ export interface components {
         };
         SubnetListResponseBody: {
             items: components["schemas"]["SubnetResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateSubnetRequestBody: {
             /** @description Must fall inside the CIDR of the private network and must not overlap an existing subnet */
@@ -1786,6 +2370,7 @@ export interface components {
         };
         SecurityGroupListResponseBody: {
             items: components["schemas"]["SecurityGroupResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateSecurityGroupRequestBody: {
             description?: string;
@@ -1818,6 +2403,7 @@ export interface components {
         };
         SecurityRuleListResponseBody: {
             items: components["schemas"]["SecurityRuleResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateSecurityRuleRequestBody: {
             description?: string;
@@ -1841,8 +2427,11 @@ export interface components {
             remote_ip_prefix?: string;
         };
         SnapshotResource: {
-            /** @description A disk restored from this snapshot must reside in this availability zone */
-            availability_zone: string;
+            /**
+             * Format: uuid
+             * @description A disk restored from this snapshot must reside in this availability zone
+             */
+            availability_zone_id: string;
             /** Format: date-time */
             created_at: string;
             /** Format: uuid */
@@ -1850,7 +2439,8 @@ export interface components {
             /** Format: uuid */
             id: string;
             name: string;
-            region_code: string;
+            /** Format: uuid */
+            region_id: string;
             /**
              * Format: int64
              * @description Capacity of the source disk when the snapshot was created. A disk restored from it cannot be smaller
@@ -1858,14 +2448,35 @@ export interface components {
             size_gb: number;
             /** @enum {string} */
             status: "provisioning" | "available" | "restoring" | "deleting" | "error";
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @description The subscriptions a cancellation through Billing has to cover to release this snapshot: its own. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+            release_subscription_ids: string[];
+            /** @description The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+            release_set: components["schemas"]["ReleaseSetItem"][];
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            task: components["schemas"]["Task"] | null;
+            /** Format: int64 */
+            generation: number;
+            /** Format: date-time */
+            observed_at: string | null;
         };
         SnapshotListResponseBody: {
             items: components["schemas"]["SnapshotResource"][] | null;
+            pagination: components["schemas"]["OffsetPagination"];
         };
         CreateSnapshotRequestBody: {
             /** Format: uuid */
             disk_id: string;
             name: string;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         RenameSecurityGroupRequestBody: {
             name: string;
@@ -1873,9 +2484,274 @@ export interface components {
         RenameSnapshotRequestBody: {
             name: string;
         };
+        /** @description Purchase options. Every request places an order of its own. */
+        OrderOptions: {
+            /**
+             * @description Defaults to true. When true, the purchase is paid from available account funds and applicable grants when it is placed. If they do not cover the amount due, the request fails with HTTP 422 and code BILLING_INSUFFICIENT_FUNDS; no order is created and nothing is charged. When false, the order is created without payment, and its invoice, if any, is paid through Billing.
+             * @default true
+             */
+            auto_pay?: boolean;
+            expected_amount?: string;
+            redemption_code?: string;
+        };
+        /** @description Identifies the purchase. Read the order for purchase progress and its invoice for amounts and payment status. */
+        PlacedOrder: {
+            /**
+             * Format: uuid
+             * @description The invoice for this purchase. Null when there is no immediate invoice. Read the invoice for its current payment state.
+             */
+            invoice_id: string | null;
+            /**
+             * Format: uuid
+             * @description The order, including for purchases without an immediate charge. Payment alone does not imply that the service has completed delivery.
+             */
+            order_id: string;
+        };
+        /** @description What a purchase would be charged, priced as a service would order it, without ordering anything. Nothing is reserved and nothing is recorded. */
+        PurchaseQuote: {
+            /** @description One line for each item the purchase would order, in the order it would order them. */
+            lines: components["schemas"]["PurchaseQuoteLine"][];
+            /** @description What would be owed for the whole purchase. Null when any line could not be priced: what would be owed is not knowable then. */
+            total: components["schemas"]["Money"] | null;
+            currency: string;
+        };
+        /** @description Identifies the Compute task and the Billing order of a purchase. Work on the purchase starts after the order's invoice is paid, or without waiting when the order has no immediate invoice. Track the task for completion. */
+        PurchaseResult: {
+            /**
+             * Format: uuid
+             * @description The Compute task that carries out the purchase.
+             */
+            task_id: string;
+            order: components["schemas"]["PlacedOrder"];
+        };
+        /** @description A system disk purchased in the same order. Required when booting from an image; mutually exclusive with boot_disk_id. */
+        NewBootDisk: {
+            /**
+             * Format: uuid
+             * @description A system disk type on sale in the availability zone of the instance, one whose `for_system` is true
+             */
+            disk_type_id: string;
+            /** Format: int64 */
+            size_gb: number;
+            /** Format: uuid */
+            price_id: string;
+            /** @default true */
+            delete_with_instance?: boolean;
+        };
+        /** @description An address and bandwidth purchased in the same order. Mutually exclusive with floating_ip_id. */
+        NewFloatingIP: {
+            /** Format: uuid */
+            price_id: string;
+            /** Format: uuid */
+            bandwidth_price_id: string;
+            /** Format: int64 */
+            bandwidth_mbps: number;
+            /** Format: uuid */
+            ipv4_pool_id: string;
+        };
+        /** @description An independent restriction on use. Removing one restriction never removes another source’s restriction or changes the user’s desired power state. */
+        InstanceRestriction: {
+            /** Format: uuid */
+            id: string;
+            /** @enum {string} */
+            source: "billing" | "iam" | "operator";
+            source_id: string;
+            reason_code: string;
+            /** Format: date-time */
+            created_at: string;
+        };
+        PowerRequest: {
+            /** Format: int64 */
+            expected_generation?: number;
+        };
+        /** @description A requested action and its outcome. Query it through the service that accepted the request, using the same project or administrator credentials. Only succeeded confirms completion. Stopping a wait does not cancel the action. Cancellation is available only where the action explicitly supports it. */
+        Task: {
+            /** Format: uuid */
+            id: string;
+            /** @description Action requested from the owning service. */
+            type: string;
+            /** @enum {string} */
+            state: "pending" | "running" | "succeeded" | "failed" | "canceled";
+            /** @description Terminal failure. Absent while work can still recover. */
+            error?: components["schemas"]["Error"];
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            started_at: string | null;
+            /** Format: date-time */
+            completed_at: string | null;
+        };
+        PortAddress: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            subnet_id: string;
+            address: string;
+            is_primary: boolean;
+            /** @enum {string} */
+            state: "reserved" | "assigned" | "releasing" | "released" | "unknown";
+            /** Format: date-time */
+            assigned_at: string | null;
+            /** Format: date-time */
+            released_at: string | null;
+        };
+        DiskAttachment: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            instance_id: string;
+            /** Format: uuid */
+            disk_id: string;
+            /** @enum {string} */
+            role: "boot" | "data";
+            delete_with_instance: boolean;
+            /** @enum {string} */
+            state: "reserved" | "attaching" | "attached" | "detaching" | "released" | "unknown";
+            /** Format: date-time */
+            attached_at: string | null;
+            /** Format: date-time */
+            detached_at: string | null;
+            /** Format: date-time */
+            released_at: string | null;
+            device: string | null;
+        };
+        DiskAttachmentList: {
+            items: components["schemas"]["DiskAttachment"][];
+            pagination: components["schemas"]["OffsetPagination"];
+        };
+        PortAttachment: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            instance_id: string;
+            /** Format: uuid */
+            port_id: string;
+            /** @enum {string} */
+            role: "primary" | "additional";
+            delete_with_instance: boolean;
+            /** @enum {string} */
+            state: "reserved" | "attaching" | "attached" | "detaching" | "released" | "unknown";
+            /** Format: date-time */
+            attached_at: string | null;
+            /** Format: date-time */
+            detached_at: string | null;
+            /** Format: date-time */
+            released_at: string | null;
+        };
+        PortAttachmentList: {
+            items: components["schemas"]["PortAttachment"][];
+            pagination: components["schemas"]["OffsetPagination"];
+        };
+        LaunchInstanceResponseBody: {
+            /** @description Instances created by this operation. Empty before resource creation starts. */
+            instance_ids: string[];
+            /**
+             * Format: uuid
+             * @description The Compute task that carries out the purchase.
+             */
+            task_id: string;
+            order: components["schemas"]["PlacedOrder"];
+            /** @description Generated login password, returned only by this response. Null when no password was generated. */
+            password: string | null;
+        };
+        IPv4PoolResource: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            region_id: string;
+            name: string;
+            /** Format: uuid */
+            plan_id: string | null;
+            /** Format: uuid */
+            bandwidth_plan_id: string | null;
+        };
+        IPv4PoolListResponseBody: {
+            items: components["schemas"]["IPv4PoolResource"][];
+            pagination: components["schemas"]["OffsetPagination"];
+        };
+        IPv4Binding: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            ipv4_allocation_id: string;
+            /** Format: uuid */
+            port_address_id: string;
+            address: string;
+            fixed_ip: string;
+            /** @enum {string} */
+            state: "binding" | "bound" | "unbinding" | "released" | "unknown";
+            /** Format: date-time */
+            bound_at: string | null;
+            /** Format: date-time */
+            unbound_at: string | null;
+            /** Format: date-time */
+            released_at: string | null;
+        };
+        /** @description One subscription of a release set and the resource it pays for. An address and its bandwidth are two subscriptions of the same floating IP. */
+        ReleaseSetItem: {
+            /** Format: uuid */
+            subscription_id: string;
+            resource: components["schemas"]["ReleaseResource"];
+        };
+        /** @description A resource a release set releases. */
+        ReleaseResource: {
+            /** @enum {string} */
+            type: "instance" | "disk" | "snapshot" | "backup" | "image" | "floating_ip";
+            /** Format: uuid */
+            id: string;
+            /** @description The resource's name. A floating IP is named by its address. */
+            name: string;
+        };
+        /** @description Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan. */
+        OffsetPagination: {
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
+        };
+        /**
+         * @description A decimal string, in the currency stated alongside it.
+         *
+         *     **The currency is not part of this type.** It is carried by a `currency` field next to the
+         *     amount, or by the account the amount belongs to. Reading an amount without that field is
+         *     reading a number with no unit.
+         *
+         *     It is a string rather than a JSON number because a JSON number is a float in most parsers,
+         *     and a float loses precision on the first arithmetic. Nothing on this platform puts an amount
+         *     through a float.
+         * @example 10.2500000000
+         */
+        Money: string;
+        PurchaseQuoteLine: {
+            /** @description Whether a price was found for this line. When false, `price_id`, `unit_amount` and `amount` are null and `unpriced_reason` states what is missing. */
+            priced: boolean;
+            /**
+             * @description Why no price was found; `none` while `priced` is true.
+             * @enum {string}
+             */
+            unpriced_reason: "none" | "no_price" | "no_rate_card" | "no_meter" | "no_dimensions" | "no_effective_rule";
+            /**
+             * Format: uuid
+             * @description The price selected, including when the request left the choice to the service. Order with this price.
+             */
+            price_id: string | null;
+            plan_name: string;
+            unit_amount: components["schemas"]["Money"] | null;
+            /** @description The quantity priced. */
+            quantity: string;
+            /** @description Not rounded. Round only for display. */
+            amount: components["schemas"]["Money"] | null;
+            tax_amount: components["schemas"]["Money"] | null;
+            currency: string;
+        };
     };
     responses: never;
-    parameters: never;
+    parameters: {
+        Page: number;
+        PageSize: number;
+    };
     requestBodies: never;
     headers: never;
     pathItems: never;
@@ -1887,20 +2763,55 @@ export interface operations {
             query?: {
                 /** @description Return only the backups of this disk */
                 disk_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BackupListResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
             };
+        };
+    };
+    "create-backup": {
+        parameters: {
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateBackupRequestBody"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["BackupListResponseBody"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -1914,7 +2825,7 @@ export interface operations {
             };
         };
     };
-    "create-backup": {
+    "create-backup-quote": {
         parameters: {
             query?: never;
             header?: never;
@@ -1923,17 +2834,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CreateBackupRequestBody"];
+                "application/json": components["schemas"]["CreateBackupQuoteRequestBody"];
             };
         };
         responses: {
-            /** @description Created */
-            201: {
+            /** @description OK */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["BackupResource"];
+                    "application/json": components["schemas"]["PurchaseQuote"];
                 };
             };
             /** @description Error */
@@ -1989,12 +2900,23 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
+            };
+            /** @description The deletion was refused. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
             };
             /** @description Error */
             default: {
@@ -2063,7 +2985,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2079,8 +3001,12 @@ export interface operations {
     };
     "list-disk-types": {
         parameters: {
-            query: {
-                region_code: string;
+            query?: {
+                region_id?: string;
+                /** @description `true` lists only system disk types and `false` only data disk types. Both are listed when omitted. */
+                for_system?: boolean;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -2108,10 +3034,46 @@ export interface operations {
             };
         };
     };
+    "get-disk-type": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                diskTypeId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DiskTypeResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "list-images": {
         parameters: {
-            query: {
-                region_code: string;
+            query?: {
+                /** @description Return only the images of this region */
+                region_id?: string;
+                /** @description Return only public or only private images. Both are returned when omitted */
+                visibility?: components["schemas"]["ImageVisibility"];
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -2139,10 +3101,184 @@ export interface operations {
             };
         };
     };
+    "create-image": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateImageRequestBody"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PurchaseResult"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "create-image-quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateImageQuoteRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PurchaseQuote"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-image": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                imageId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "delete-image": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                imageId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
+            };
+            /** @description The deletion was refused. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "rename-image": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                imageId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RenameImageRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "list-instance-types": {
         parameters: {
-            query: {
-                region_code: string;
+            query?: {
+                region_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -2172,7 +3308,10 @@ export interface operations {
     };
     "list-regions": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -2201,10 +3340,13 @@ export interface operations {
     };
     "list-availability-zones": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
-                regionCode: string;
+                regionId: string;
             };
             cookie?: never;
         };
@@ -2233,9 +3375,11 @@ export interface operations {
     "list-disks": {
         parameters: {
             query?: {
-                region_code?: string;
+                region_id?: string;
                 /** @description Supplied together with `region_code` to filter attachable disks */
-                availability_zone?: string;
+                availability_zone_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -2282,7 +3426,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2338,12 +3482,23 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
+            };
+            /** @description The deletion was refused. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
             };
             /** @description Error */
             default: {
@@ -2412,7 +3567,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2441,13 +3596,13 @@ export interface operations {
             };
         };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -2463,7 +3618,10 @@ export interface operations {
     };
     "list-floating-ips": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -2509,7 +3667,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["FloatingIPResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2565,12 +3723,23 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description The release has been accepted. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
+            };
+            /** @description The deletion was refused. */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
             };
             /** @description Error */
             default: {
@@ -2604,7 +3773,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["FloatingIPResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2686,7 +3855,12 @@ export interface operations {
     };
     "list-instances": {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description Only instances carrying this label, written as `key:value` — for example `env:prod`. Both halves are matched exactly */
+                label?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -2726,8 +3900,8 @@ export interface operations {
             };
         };
         responses: {
-            /** @description Created */
-            201: {
+            /** @description Accepted */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2788,46 +3962,22 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            /** @description Error */
-            default: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["Error"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
-        };
-    };
-    "rename-instance": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                instanceId: string;
-            };
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["RenameInstanceRequestBody"];
-            };
-        };
-        responses: {
-            /** @description OK */
-            200: {
+            /** @description The deletion was refused. */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["InstanceResource"];
+                    "application/json": components["schemas"]["Error"];
                 };
             };
             /** @description Error */
@@ -2841,7 +3991,7 @@ export interface operations {
             };
         };
     };
-    "act-on-instance": {
+    "rename-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -2852,7 +4002,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ActOnInstanceRequestBody"];
+                "application/json": components["schemas"]["RenameInstanceRequestBody"];
             };
         };
         responses: {
@@ -2976,7 +4126,7 @@ export interface operations {
             };
         };
     };
-    "reset-instance-password": {
+    "set-instance-labels": {
         parameters: {
             query?: never;
             header?: never;
@@ -2987,7 +4137,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ResetPasswordRequestBody"];
+                "application/json": components["schemas"]["SetInstanceLabelsRequestBody"];
             };
         };
         responses: {
@@ -2997,7 +4147,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ResetPasswordResponseBody"];
+                    "application/json": components["schemas"]["InstanceResource"];
                 };
             };
             /** @description Error */
@@ -3011,7 +4161,7 @@ export interface operations {
             };
         };
     };
-    "rebuild-instance": {
+    "set-instance-notes": {
         parameters: {
             query?: never;
             header?: never;
@@ -3022,7 +4172,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["RebuildInstanceRequestBody"];
+                "application/json": components["schemas"]["SetInstanceNotesRequestBody"];
             };
         };
         responses: {
@@ -3032,7 +4182,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["RebuildInstanceResponseBody"];
+                    "application/json": components["schemas"]["InstanceResource"];
                 };
             };
             /** @description Error */
@@ -3046,7 +4196,7 @@ export interface operations {
             };
         };
     };
-    "resize-instance": {
+    "reset-instance-password": {
         parameters: {
             query?: never;
             header?: never;
@@ -3057,7 +4207,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ResizeInstanceRequestBody"];
+                "application/json": components["schemas"]["ResetPasswordRequestBody"];
             };
         };
         responses: {
@@ -3067,7 +4217,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["InstanceResource"];
+                    "application/json": components["schemas"]["ResetPasswordResponseBody"];
                 };
             };
             /** @description Error */
@@ -3081,7 +4231,7 @@ export interface operations {
             };
         };
     };
-    "confirm-instance-resize": {
+    "reboot-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -3090,15 +4240,19 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RebootInstanceRequestBody"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["InstanceResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3112,7 +4266,7 @@ export interface operations {
             };
         };
     };
-    "revert-instance-resize": {
+    "rebuild-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -3121,7 +4275,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RebuildInstanceRequestBody"];
+            };
+        };
         responses: {
             /** @description OK */
             200: {
@@ -3129,7 +4287,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["InstanceResource"];
+                    "application/json": components["schemas"]["RebuildInstanceResponseBody"];
                 };
             };
             /** @description Error */
@@ -3143,7 +4301,7 @@ export interface operations {
             };
         };
     };
-    "list-instance-disks": {
+    "resize-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -3152,15 +4310,19 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ResizeInstanceRequestBody"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Accepted */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskListResponseBody"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -3174,7 +4336,7 @@ export interface operations {
             };
         };
     };
-    "attach-disk": {
+    "start-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -3185,17 +4347,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["AttachDiskRequestBody"];
+                "application/json": components["schemas"]["PowerRequest"];
             };
         };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3209,25 +4371,28 @@ export interface operations {
             };
         };
     };
-    "detach-disk": {
+    "stop-instance": {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 instanceId: string;
-                diskId: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PowerRequest"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3241,20 +4406,19 @@ export interface operations {
             };
         };
     };
-    "attach-instance-floating-ip": {
+    "list-instance-disks": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 instanceId: string;
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["AttachFloatingIPRequestBody"];
-            };
-        };
+        requestBody?: never;
         responses: {
             /** @description OK */
             200: {
@@ -3262,7 +4426,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["FloatingIPResource"];
+                    "application/json": components["schemas"]["DiskAttachmentList"];
                 };
             };
             /** @description Error */
@@ -3276,25 +4440,28 @@ export interface operations {
             };
         };
     };
-    "detach-instance-floating-ip": {
+    "attach-disk": {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 instanceId: string;
-                floatingIpId: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AttachDiskRequestBody"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["FloatingIPResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3308,24 +4475,25 @@ export interface operations {
             };
         };
     };
-    "list-instance-ports": {
+    "detach-disk": {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 instanceId: string;
+                diskId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PortListResponseBody"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3339,7 +4507,7 @@ export interface operations {
             };
         };
     };
-    "attach-port": {
+    "attach-instance-floating-ip": {
         parameters: {
             query?: never;
             header?: never;
@@ -3350,17 +4518,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["AttachPortRequestBody"];
+                "application/json": components["schemas"]["AttachFloatingIPRequestBody"];
             };
         };
         responses: {
-            /** @description OK */
+            /** @description The current floating IP binding */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PortResource"];
+                    "application/json": components["schemas"]["FloatingIPResource"];
                 };
             };
             /** @description Error */
@@ -3374,25 +4542,25 @@ export interface operations {
             };
         };
     };
-    "detach-port": {
+    "detach-instance-floating-ip": {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 instanceId: string;
-                portId: string;
+                floatingIpId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
+            /** @description The current floating IP binding */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PortResource"];
+                    "application/json": components["schemas"]["FloatingIPResource"];
                 };
             };
             /** @description Error */
@@ -3406,45 +4574,16 @@ export interface operations {
             };
         };
     };
-    "list-operation-logs": {
+    "list-instance-ports": {
         parameters: {
             query?: {
-                /** @description Return a single kind of operation; the value matches the operation id of the endpoint */
-                action?: string;
-                limit?: number;
-                offset?: number;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description OK */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["OperationLogListResponseBody"];
-                };
-            };
-            /** @description Error */
-            default: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["Error"];
-                };
+            path: {
+                instanceId: string;
             };
-        };
-    };
-    "list-ports": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
             cookie?: never;
         };
         requestBody?: never;
@@ -3455,7 +4594,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PortListResponseBody"];
+                    "application/json": components["schemas"]["PortAttachmentList"];
                 };
             };
             /** @description Error */
@@ -3469,26 +4608,28 @@ export interface operations {
             };
         };
     };
-    "create-port": {
+    "attach-port": {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                instanceId: string;
+            };
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CreatePortRequestBody"];
+                "application/json": components["schemas"]["AttachPortRequestBody"];
             };
         };
         responses: {
-            /** @description Created */
-            201: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PortResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3502,23 +4643,26 @@ export interface operations {
             };
         };
     };
-    "delete-port": {
+    "detach-port": {
         parameters: {
             query?: never;
             header?: never;
             path: {
+                instanceId: string;
                 portId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
             };
             /** @description Error */
             default: {
@@ -3531,11 +4675,13 @@ export interface operations {
             };
         };
     };
-    "list-private-images": {
+    "list-operation-logs": {
         parameters: {
             query?: {
-                /** @description Return only the images of this region. An image can only be used in the region that holds it */
-                region_code?: string;
+                /** @description Return a single kind of operation; the value matches the operation id of the endpoint */
+                action?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -3549,7 +4695,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PrivateImageListResponseBody"];
+                    "application/json": components["schemas"]["OperationLogListResponseBody"];
                 };
             };
             /** @description Error */
@@ -3563,46 +4709,14 @@ export interface operations {
             };
         };
     };
-    "create-private-image": {
+    "list-ports": {
         parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CreatePrivateImageRequestBody"];
-            };
-        };
-        responses: {
-            /** @description Created */
-            201: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["PrivateImageResource"];
-                };
-            };
-            /** @description Error */
-            default: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["Error"];
-                };
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
-        };
-    };
-    "get-private-image": {
-        parameters: {
-            query?: never;
             header?: never;
-            path: {
-                privateImageId: string;
-            };
+            path?: never;
             cookie?: never;
         };
         requestBody?: never;
@@ -3613,7 +4727,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PrivateImageResource"];
+                    "application/json": components["schemas"]["PortListResponseBody"];
                 };
             };
             /** @description Error */
@@ -3627,23 +4741,27 @@ export interface operations {
             };
         };
     };
-    "delete-private-image": {
+    "create-port": {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                privateImageId: string;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreatePortRequestBody"];
+            };
+        };
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description Created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["PortResource"];
+                };
             };
             /** @description Error */
             default: {
@@ -3656,29 +4774,23 @@ export interface operations {
             };
         };
     };
-    "rename-private-image": {
+    "delete-port": {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                privateImageId: string;
+                portId: string;
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["RenamePrivateImageRequestBody"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description No Content */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["PrivateImageResource"];
-                };
+                content?: never;
             };
             /** @description Error */
             default: {
@@ -3695,7 +4807,9 @@ export interface operations {
         parameters: {
             query?: {
                 /** @description Returns every region when omitted */
-                region_code?: string;
+                region_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -3944,7 +5058,10 @@ export interface operations {
     };
     "list-routes": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 privateNetworkId: string;
@@ -4040,7 +5157,10 @@ export interface operations {
     };
     "list-subnets": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 privateNetworkId: string;
@@ -4170,9 +5290,11 @@ export interface operations {
     "list-security-groups": {
         parameters: {
             query?: {
-                region_code?: string;
+                region_id?: string;
                 /** @description Return only the security groups of this private network */
                 private_network_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -4330,7 +5452,10 @@ export interface operations {
     };
     "list-security-group-rules": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
             header?: never;
             path: {
                 securityGroupId: string;
@@ -4429,6 +5554,8 @@ export interface operations {
             query?: {
                 /** @description Return only the snapshots of this disk */
                 disk_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
             };
             header?: never;
             path?: never;
@@ -4475,7 +5602,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["SnapshotResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -4531,12 +5658,23 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description The action was accepted. Wait for the returned task to finish. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
+            };
+            /** @description The deletion was refused. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
             };
             /** @description Error */
             default: {
@@ -4584,4 +5722,257 @@ export interface operations {
             };
         };
     };
+    "get-task": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                taskId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The task. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Task"];
+                };
+            };
+            /** @description The request could not be completed. */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-ipv4-pools": {
+        parameters: {
+            query?: {
+                region_id?: string;
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IPv4PoolListResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-peerings": {
+        parameters: {
+            query?: {
+                page?: components["parameters"]["Page"];
+                page_size?: components["parameters"]["PageSize"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Success */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PeeringListResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "create-peering": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreatePeeringRequestBody"];
+            };
+        };
+        responses: {
+            /** @description Success */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PeeringResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-peering": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                peeringId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Success */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PeeringResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "delete-peering": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                peeringId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Success */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PeeringResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "accept-peering": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                peeringId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Success */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PeeringResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "reject-peering": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                peeringId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Success */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PeeringResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
 }