@leaflow/sdk 0.0.0-dev.23.g7fcf334 → 0.0.0-dev.232.g18ca775

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

@@ -19,7 +19,7 @@ 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.
          */
         post: operations["create-backup"];
         delete?: never;
@@ -45,6 +45,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 when its subscription ends.
          */
         delete: operations["delete-backup"];
         options?: never;
@@ -66,7 +68,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 +84,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 +97,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;
@@ -102,6 +127,8 @@ export interface paths {
         /**
          * List images on sale
          * @description An image whose `min_ram_mb` exceeds the memory of the selected instance type cannot boot. Filter the options accordingly.
+         *
+         *     Only images currently on sale are listed. An image the platform withdraws disappears from here and can no longer install new instances, while the instances already running it keep running and can still be rebuilt onto it.
          */
         get: operations["list-images"];
         put?: never;
@@ -119,7 +146,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 +176,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 +212,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 +239,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 when its subscription ends.
          */
         delete: operations["delete-disk"];
         options?: never;
@@ -229,7 +263,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 +317,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 +340,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 when its subscriptions end.
          */
         delete: operations["release-floating-ip"];
         options?: never;
@@ -316,7 +360,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 +400,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.
+         * @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.
          *
-         *     `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.
+         *     Exactly one of image_id, private_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.
          *
-         *     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.
+         *     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.
          *
-         *     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.
-         *
-         *     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 +442,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. It is released when its subscription ends.
          */
         delete: operations["delete-instance"];
         options?: never;
@@ -408,32 +455,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 +468,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`
@@ -455,7 +480,7 @@ export interface paths {
          *
          *     Authentication uses the key the platform attaches to every instance at creation, so nothing has to be set up first. The instance must have applied that key at first boot, which images without a full cloud-init do not do.
          *
-         *     **The host key is not verified.** Anyone in a position to intercept the connection can read the command and all of its output, so do not pass credentials this way.
+         *     **Do not pass secrets in the command.** Read them from a file on the instance instead: neither the command nor its output is a confidential channel.
          *
          *     Each stream is capped at 1 MiB. Beyond that the rest is discarded and `truncated` is true.
          */
@@ -479,7 +504,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 +535,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 +607,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 +647,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 +668,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.
-         *
-         *     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.
+         * @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.
          *
-         *     **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 +679,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 +689,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 +709,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;
@@ -670,7 +771,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 +790,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;
@@ -815,7 +919,7 @@ export interface paths {
          *
          *     **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:
+         *     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.
@@ -850,6 +954,8 @@ export interface paths {
          * @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.
+         *
+         *     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 when its subscription ends.
          */
         delete: operations["delete-private-image"];
         options?: never;
@@ -1148,7 +1254,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 when its subscription ends.
+         */
         delete: operations["delete-snapshot"];
         options?: never;
         head?: never;
@@ -1156,13 +1265,160 @@ export interface paths {
         patch: operations["rename-snapshot"];
         trace?: never;
     };
+    "/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"][];
+            total: number;
+        };
+        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;
             };
@@ -1170,14 +1426,13 @@ export interface components {
             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,6 +1445,24 @@ 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;
+            /** @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;
@@ -1198,6 +1471,9 @@ export interface components {
             /** Format: uuid */
             disk_id: string;
             name: string;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         RenameBackupRequestBody: {
             name: string;
@@ -1205,7 +1481,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 +1490,79 @@ 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;
+            /** @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,10 +1570,34 @@ 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;
+            /** Format: uuid */
+            backup_plan_id: string | null;
+            /** Format: uuid */
+            private_image_plan_id: string | null;
         };
         DiskTypeListResponseBody: {
             items: components["schemas"]["DiskTypeResource"][] | null;
@@ -1260,6 +1606,8 @@ export interface components {
             architecture: string;
             /** Format: uuid */
             id: 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 */
             min_disk_gb: number;
             /** Format: int64 */
@@ -1267,20 +1615,48 @@ export interface components {
             name: string;
             os_family: string;
             os_version: string;
-            region_code: string;
+            /** Format: uuid */
+            region_id: string;
             /** @description False means a new password can only be set by rebuilding an instance created from this image */
             supports_password_reset: boolean;
         };
         ImageListResponseBody: {
-            items: components["schemas"]["ImageResource"][] | null;
+            items: components["schemas"]["ImageResource"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
         };
         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,24 +1664,44 @@ 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"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
         };
         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;
         };
         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;
@@ -1314,7 +1710,10 @@ export interface components {
             items: components["schemas"]["DiskResource"][] | null;
         };
         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 +1723,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 +1736,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,22 +1749,38 @@ 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;
+            /** @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;
@@ -1367,8 +1788,27 @@ export interface components {
         AllocateFloatingIPRequestBody: {
             /** @description The address to allocate. Allocated by the platform when omitted */
             address?: string;
+            /**
+             * Format: int64
+             * @description The bandwidth ceiling of this address, in Mbit/s, applied to both directions.
+             *
+             *     Required, and there is no "unlimited": an address with no ceiling runs at line rate and is
+             *     charged nothing for the traffic, while the address itself bills normally — so the invoice
+             *     looks correct and nothing anywhere reports it.
+             *
+             *     It is billed separately from the address, per Mbit/s-hour, and appears as its own line on
+             *     the order. Changing it later goes through the bandwidth endpoint.
+             */
+            bandwidth_mbps: number;
             /** Format: uuid */
             private_network_id: string;
+            /** Format: uuid */
+            ipv4_pool_id: string;
+            /** Format: uuid */
+            price_id: string;
+            /** Format: uuid */
+            bandwidth_price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         SetBandwidthRequestBody: {
             /**
@@ -1376,13 +1816,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 */
@@ -1401,12 +1845,15 @@ 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;
+            /** @description A free-text note about this instance. Empty when never set */
+            notes: string;
             /**
              * Format: uuid
              * @description Non-empty when the instance was created from a private image
@@ -1414,50 +1861,96 @@ export interface components {
             private_image_id: string | null;
             /** @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
-             * @description Non-empty once the platform has suspended the instance, which must be lifted before any operation
-             */
-            suspended_at: 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;
+            /** @enum {string|null} */
+            access_state: "pending" | "enabled" | "suspended" | "reclaimed" | null;
+            /**
+             * Format: uuid
+             * @description Non-empty when the instance was created from a disk you already had, instead of from an image
+             */
+            source_disk_id: string | null;
         };
         InstanceListResponseBody: {
-            items: components["schemas"]["InstanceResource"][] | null;
+            items: components["schemas"]["InstanceResource"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
         };
         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, `image_id` and `private_image_id`
+             */
+            boot_disk_id?: string;
+            /**
+             * Format: uuid
+             * @description A platform image, and it must be one currently on sale. Exactly one of this, `private_image_id` and `boot_disk_id`
              */
             image_id?: string;
-            /** Format: uuid */
+            /**
+             * Format: uuid
+             * @description An instance type currently on sale. A withdrawn one is rejected even though its identifier still resolves
+             */
             instance_type_id: string;
+            /** @description The account the disk lets you log in as. Required with `boot_disk_id`, and rejected without it since an image states its own */
+            login_username?: string;
             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
@@ -1466,14 +1959,9 @@ export interface components {
             port_id?: string;
             /**
              * Format: uuid
-             * @description A private image. Exactly one of this and `image_id`
+             * @description A private image. Exactly one of this, `image_id` and `boot_disk_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 +1969,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 +2000,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,7 +2036,7 @@ export interface components {
             generate_password?: boolean;
             /**
              * Format: uuid
-             * @description A platform image. Exactly one of this and `private_image_id`
+             * @description A platform image, which must be on sale unless it is the one this instance already runs. Exactly one of this and `private_image_id`
              */
             image_id?: string;
             password?: string;
@@ -1569,6 +2057,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,21 +2070,22 @@ 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;
@@ -1607,6 +2099,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,25 +2117,30 @@ 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;
+            items: components["schemas"]["OperationLogResource"][];
             /** Format: int64 */
-            total: number;
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
         };
         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;
@@ -1647,6 +2150,8 @@ export interface components {
             failure: string | null;
             /** Format: uuid */
             id: 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
@@ -1660,8 +2165,8 @@ export interface components {
             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: uuid */
+            region_id: string;
             /**
              * Format: int64
              * @description Storage occupied by the image; 0 until the capture completes
@@ -1676,9 +2181,28 @@ export interface components {
             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;
+            /** Format: uuid */
+            order_id: string | null;
+            /** Format: uuid */
+            price_id: string | null;
+            /** Format: uuid */
+            subscription_item_id: string | null;
+            /** @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;
         };
         PrivateImageListResponseBody: {
-            items: components["schemas"]["PrivateImageResource"][] | null;
+            items: components["schemas"]["PrivateImageResource"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
         };
         CreatePrivateImageRequestBody: {
             /**
@@ -1687,6 +2211,9 @@ export interface components {
              */
             instance_id: string;
             name: string;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
         };
         RenamePrivateImageRequestBody: {
             name: string;
@@ -1699,9 +2226,13 @@ 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;
         };
@@ -1712,7 +2243,8 @@ export interface components {
             /** @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,13 +2260,19 @@ 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;
@@ -1840,38 +2378,268 @@ export interface components {
             /** @description Equivalent to `0.0.0.0/0` or `::/0` when omitted */
             remote_ip_prefix?: string;
         };
-        SnapshotResource: {
-            /** @description A disk restored from this snapshot must reside in this availability zone */
-            availability_zone: string;
-            /** Format: date-time */
-            created_at: string;
-            /** Format: uuid */
-            disk_id: string;
-            /** Format: uuid */
-            id: string;
-            name: string;
-            region_code: string;
+        SnapshotResource: {
+            /**
+             * 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 */
+            disk_id: string;
+            /** Format: uuid */
+            id: string;
+            name: 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
+             */
+            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;
+            /** @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;
+        };
+        CreateSnapshotRequestBody: {
+            /** Format: uuid */
+            disk_id: string;
+            name: string;
+            /** Format: uuid */
+            price_id: string;
+            order: components["schemas"]["OrderOptions"];
+        };
+        RenameSecurityGroupRequestBody: {
+            name: string;
+        };
+        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 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"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count: number;
+        };
+        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"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count: number;
+        };
+        LaunchInstanceResponseBody: {
+            /** @description Instances created by this operation. Empty before resource creation starts. */
+            instance_ids: string[];
             /**
-             * Format: int64
-             * @description Capacity of the source disk when the snapshot was created. A disk restored from it cannot be smaller
+             * Format: uuid
+             * @description The Compute task that carries out the purchase.
              */
-            size_gb: number;
-            /** @enum {string} */
-            status: "provisioning" | "available" | "restoring" | "deleting" | "error";
-        };
-        SnapshotListResponseBody: {
-            items: components["schemas"]["SnapshotResource"][] | null;
+            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;
         };
-        CreateSnapshotRequestBody: {
+        IPv4PoolResource: {
             /** Format: uuid */
-            disk_id: string;
+            id: string;
+            /** Format: uuid */
+            region_id: string;
             name: string;
+            /** Format: uuid */
+            plan_id: string | null;
+            /** Format: uuid */
+            bandwidth_plan_id: string | null;
         };
-        RenameSecurityGroupRequestBody: {
-            name: string;
+        IPv4PoolListResponseBody: {
+            items: components["schemas"]["IPv4PoolResource"][];
+            /** Format: int64 */
+            page: number;
+            /** Format: int64 */
+            page_size: number;
+            /** Format: int64 */
+            total_count?: number;
         };
-        RenameSnapshotRequestBody: {
-            name: string;
+        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;
         };
     };
     responses: never;
@@ -1933,7 +2701,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["BackupResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -1989,12 +2757,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 +2842,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2080,7 +2859,9 @@ export interface operations {
     "list-disk-types": {
         parameters: {
             query: {
-                region_code: string;
+                region_id: string;
+                /** @description `true` lists only system disk types and `false` only data disk types. Both are listed when omitted. */
+                for_system?: boolean;
             };
             header?: never;
             path?: never;
@@ -2108,10 +2889,43 @@ 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;
+                region_id: string;
+                page?: number;
+                page_size?: number;
             };
             header?: never;
             path?: never;
@@ -2142,7 +2956,9 @@ export interface operations {
     "list-instance-types": {
         parameters: {
             query: {
-                region_code: string;
+                region_id: string;
+                page?: number;
+                page_size?: number;
             };
             header?: never;
             path?: never;
@@ -2204,7 +3020,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                regionCode: string;
+                regionId: string;
             };
             cookie?: never;
         };
@@ -2233,9 +3049,9 @@ 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;
             };
             header?: never;
             path?: never;
@@ -2282,7 +3098,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2338,12 +3154,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 +3239,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2441,13 +3268,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 */
@@ -2509,7 +3336,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["FloatingIPResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2565,12 +3392,23 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description The release has been accepted. */
+            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: {
@@ -2604,7 +3442,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["FloatingIPResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -2686,7 +3524,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?: number;
+                page_size?: number;
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -2726,8 +3569,8 @@ export interface operations {
             };
         };
         responses: {
-            /** @description Created */
-            201: {
+            /** @description Accepted */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2788,12 +3631,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: {
@@ -2841,7 +3695,7 @@ export interface operations {
             };
         };
     };
-    "act-on-instance": {
+    "run-instance-command": {
         parameters: {
             query?: never;
             header?: never;
@@ -2852,7 +3706,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ActOnInstanceRequestBody"];
+                "application/json": components["schemas"]["RunCommandRequestBody"];
             };
         };
         responses: {
@@ -2862,7 +3716,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["InstanceResource"];
+                    "application/json": components["schemas"]["CommandResultResponseBody"];
                 };
             };
             /** @description Error */
@@ -2876,7 +3730,7 @@ export interface operations {
             };
         };
     };
-    "run-instance-command": {
+    "open-instance-console": {
         parameters: {
             query?: never;
             header?: never;
@@ -2885,11 +3739,41 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["RunCommandRequestBody"];
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ConsoleResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-instance-console-output": {
+        parameters: {
+            query?: {
+                /** @description Number of trailing lines to return; 0 returns the entire output */
+                lines?: number;
+            };
+            header?: never;
+            path: {
+                instanceId: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             /** @description OK */
             200: {
@@ -2897,7 +3781,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["CommandResultResponseBody"];
+                    "application/json": components["schemas"]["ConsoleOutputResponseBody"];
                 };
             };
             /** @description Error */
@@ -2911,7 +3795,7 @@ export interface operations {
             };
         };
     };
-    "open-instance-console": {
+    "set-instance-labels": {
         parameters: {
             query?: never;
             header?: never;
@@ -2920,7 +3804,11 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SetInstanceLabelsRequestBody"];
+            };
+        };
         responses: {
             /** @description OK */
             200: {
@@ -2928,7 +3816,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ConsoleResponseBody"];
+                    "application/json": components["schemas"]["InstanceResource"];
                 };
             };
             /** @description Error */
@@ -2942,19 +3830,20 @@ export interface operations {
             };
         };
     };
-    "get-instance-console-output": {
+    "set-instance-notes": {
         parameters: {
-            query?: {
-                /** @description Number of trailing lines to return; 0 returns the entire output */
-                lines?: number;
-            };
+            query?: never;
             header?: never;
             path: {
                 instanceId: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SetInstanceNotesRequestBody"];
+            };
+        };
         responses: {
             /** @description OK */
             200: {
@@ -2962,7 +3851,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ConsoleOutputResponseBody"];
+                    "application/json": components["schemas"]["InstanceResource"];
                 };
             };
             /** @description Error */
@@ -3011,6 +3900,41 @@ export interface operations {
             };
         };
     };
+    "reboot-instance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                instanceId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RebootInstanceRequestBody"];
+            };
+        };
+        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 Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "rebuild-instance": {
         parameters: {
             query?: never;
@@ -3061,13 +3985,13 @@ export interface operations {
             };
         };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Accepted */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["InstanceResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -3081,7 +4005,7 @@ export interface operations {
             };
         };
     };
-    "confirm-instance-resize": {
+    "start-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -3090,15 +4014,19 @@ export interface operations {
             };
             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"]["InstanceResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3112,7 +4040,7 @@ export interface operations {
             };
         };
     };
-    "revert-instance-resize": {
+    "stop-instance": {
         parameters: {
             query?: never;
             header?: never;
@@ -3121,15 +4049,19 @@ export interface operations {
             };
             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"]["InstanceResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3145,7 +4077,10 @@ export interface operations {
     };
     "list-instance-disks": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: number;
+                page_size?: number;
+            };
             header?: never;
             path: {
                 instanceId: string;
@@ -3160,7 +4095,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DiskListResponseBody"];
+                    "application/json": components["schemas"]["DiskAttachmentList"];
                 };
             };
             /** @description Error */
@@ -3189,13 +4124,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 */
@@ -3221,13 +4156,13 @@ export interface operations {
         };
         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"]["DiskResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3256,7 +4191,7 @@ export interface operations {
             };
         };
         responses: {
-            /** @description OK */
+            /** @description The current floating IP binding */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -3288,7 +4223,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
+            /** @description The current floating IP binding */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -3310,7 +4245,10 @@ export interface operations {
     };
     "list-instance-ports": {
         parameters: {
-            query?: never;
+            query?: {
+                page?: number;
+                page_size?: number;
+            };
             header?: never;
             path: {
                 instanceId: string;
@@ -3325,7 +4263,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PortListResponseBody"];
+                    "application/json": components["schemas"]["PortAttachmentList"];
                 };
             };
             /** @description Error */
@@ -3354,13 +4292,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"]["PortResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3386,13 +4324,13 @@ export interface operations {
         };
         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"]["PortResource"];
+                    "application/json": components["schemas"]["Task"];
                 };
             };
             /** @description Error */
@@ -3411,8 +4349,8 @@ export interface operations {
             query?: {
                 /** @description Return a single kind of operation; the value matches the operation id of the endpoint */
                 action?: string;
-                limit?: number;
-                offset?: number;
+                page?: number;
+                page_size?: number;
             };
             header?: never;
             path?: never;
@@ -3535,7 +4473,9 @@ export interface operations {
         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;
+                region_id?: string;
+                page?: number;
+                page_size?: number;
             };
             header?: never;
             path?: never;
@@ -3582,7 +4522,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PrivateImageResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -3638,12 +4578,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: {
@@ -3695,7 +4646,7 @@ export interface operations {
         parameters: {
             query?: {
                 /** @description Returns every region when omitted */
-                region_code?: string;
+                region_id?: string;
             };
             header?: never;
             path?: never;
@@ -4170,7 +5121,7 @@ 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;
             };
@@ -4475,7 +5426,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["SnapshotResource"];
+                    "application/json": components["schemas"]["PurchaseResult"];
                 };
             };
             /** @description Error */
@@ -4531,12 +5482,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 +5546,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?: number;
+                page_size?: number;
+            };
+            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?: {
+                limit?: number;
+                offset?: number;
+            };
+            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"];
+                };
+            };
+        };
+    };
 }