@leaflow/sdk 0.0.0-dev.529.g6a1b7de → 0.0.0-dev.535.g1eeb8a5

package/dist/compute/v2/generated/schemas.zod.js

@@ -16,7 +16,7 @@
  * - **Quotas.** A creation, purchase or resize that adds to what a project holds in a region is checked against the project's quota there before anything is ordered or created, and is refused with HTTP 409 `COMPUTE_PROJECT_QUOTA_EXCEEDED`, whose `meta` names the `resource`, its `limit`, the amount `used` and the amount `requested`. An instance purchase counts the volumes, the new primary network interface and the new elastic IP bought with each instance. Read the limits with `list-quotas`; a limit no operator set is the platform default.
  * - **Projects.** Resource ownership and project identifiers refer to IAM platform projects, not OpenStack tenants. Instances, images and networks share one infrastructure OpenStack project; the platform project remains the authorization and ownership boundary.
  * - **Custom methods.** An action that is not one of the standard methods (list, get, create, update, delete) is a custom method, `POST` on the resource's path followed by `:` and the verb, as in `POST /api/v2/instances/{id}:reboot` (AIP-136). A state is changed by its custom method, never by writing the state: `:start` and `:stop`, `:rescue` and `:unrescue`, `:associate` and `:disassociate`.
- * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only mutable fields, all optional and at least one given, and answers 200 when only descriptive fields changed and 202 when an operation started. An operational field (`instance_type_id`, `size_gib`, `bandwidth_mbps`) cannot be combined with any other field in the same request: it is refused with 422 `UPDATE_FIELDS_COMBINED`, because a rename that committed beside a change that was then refused would leave the request half applied.
+ * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only descriptive fields, all optional and at least one given, and answers 200. A change that starts an operation or a purchase, such as a resize, is its own method (`:resize`, `:retype`, `:changeBandwidth`).
  * - **Billing relationships.** A purchased resource records its `checkout_session_id` and, once checkout completes, its `order_id`, `order_item_id` and `subscription_id`. Its `access_state` is `pending` until the order is accepted and delivery settles it, then `enabled`; a subscription that lapses suspends or reclaims the resource it pays for. Deleting a resource that subscriptions pay for cancels the subscriptions of its `release_set` in Billing, and the deletion answers with that cancellation.
  * - **Availability zones.** A volume and an instance must reside in the same availability zone to be attached. An instance type and a volume type each belong to one availability zone, as on GCP, so a purchase names the type and the type names the zone; the volumes bought with an instance have to be of types of the instance type's zone.
  * - **IPv6 is routed, not translated.** A virtual private cloud with IPv6 holds a /56 and each of its subnets a /64 of it, as on Alibaba Cloud, Tencent Cloud and Azure; IPv6 and its security groups require no EIP or NAT gateway. EIP and NATGateway are IPv4 products; IPv6 EIP, NAT66 and IPv6 port forwarding are not supported.
@@ -33,10 +33,12 @@
  * OpenAPI spec version: 2.0.0
  */
 import * as zod from "zod";
-import { AssociateElasticIPRequestBody } from "./validators/associateElasticIPRequestBody.zod.js";
+import { AssociateElasticIpRequestBody } from "./validators/associateElasticIpRequestBody.zod.js";
 import { AttachNetworkInterfaceRequestBody } from "./validators/attachNetworkInterfaceRequestBody.zod.js";
 import { AttachVolumeRequestBody } from "./validators/attachVolumeRequestBody.zod.js";
-import { CreateElasticIPRequestBody } from "./validators/createElasticIPRequestBody.zod.js";
+import { ChangeElasticIpBandwidthRequestBody } from "./validators/changeElasticIpBandwidthRequestBody.zod.js";
+import { ChangeElasticIpChargeTypeRequestBody } from "./validators/changeElasticIpChargeTypeRequestBody.zod.js";
+import { CreateElasticIpRequestBody } from "./validators/createElasticIpRequestBody.zod.js";
 import { CreateInstanceRequestBody } from "./validators/createInstanceRequestBody.zod.js";
 import { CreateLaunchTemplateRequestBody } from "./validators/createLaunchTemplateRequestBody.zod.js";
 import { CreateNetworkInterfaceAddressRequestBody } from "./validators/createNetworkInterfaceAddressRequestBody.zod.js";
@@ -55,9 +57,12 @@ import { NewLaunchTemplateVersion } from "./validators/newLaunchTemplateVersion.
 import { PasswordChoice } from "./validators/passwordChoice.zod.js";
 import { RebootInstanceRequestBody } from "./validators/rebootInstanceRequestBody.zod.js";
 import { RebuildInstanceRequestBody } from "./validators/rebuildInstanceRequestBody.zod.js";
+import { ReplaceNetworkInterfaceSecurityGroupsRequestBody } from "./validators/replaceNetworkInterfaceSecurityGroupsRequestBody.zod.js";
+import { ResizeInstanceRequestBody } from "./validators/resizeInstanceRequestBody.zod.js";
+import { ResizeVolumeRequestBody } from "./validators/resizeVolumeRequestBody.zod.js";
+import { RetypeVolumeRequestBody } from "./validators/retypeVolumeRequestBody.zod.js";
 import { RevertVolumeRequestBody } from "./validators/revertVolumeRequestBody.zod.js";
 import { RunInstanceCommandRequestBody } from "./validators/runInstanceCommandRequestBody.zod.js";
-import { UpdateElasticIPRequestBody } from "./validators/updateElasticIPRequestBody.zod.js";
 import { UpdateInstanceRequestBody } from "./validators/updateInstanceRequestBody.zod.js";
 import { UpdateLaunchTemplateRequestBody } from "./validators/updateLaunchTemplateRequestBody.zod.js";
 import { UpdateNetworkInterfaceRequestBody } from "./validators/updateNetworkInterfaceRequestBody.zod.js";
@@ -167,7 +172,7 @@ export const GetElasticIpLineParams = zod.strictObject({
         .min(getElasticIpLinePathElasticIpLineIdMin)
         .max(getElasticIpLinePathElasticIpLineIdMax)
         .regex(getElasticIpLinePathElasticIpLineIdRegExp)
-        .describe("Compute ElasticIPLine TypeID. UUID text is not accepted."),
+        .describe("Compute ElasticIpLine TypeID. UUID text is not accepted."),
 });
 /**
  * @summary List elastic IPs
@@ -201,10 +206,14 @@ export const ListElasticIpsQueryParams = zod.strictObject({
  *
  * Allocation does not select or create a virtual private cloud. A later association selects an assigned network-interface address; Compute then establishes the required network connectivity.
  *
+ * An elastic IP bought on its own has a Billing subscription of its own, with two items: the address, always pay-as-you-go and charged while the address is not associated with anything, and the network, on the chosen terms.
+ *
+ * **Buying for an instance.** With `instance_id`, the elastic IP is associated with the primary network interface of that instance of the project once created, and its two items join the instance's Billing subscription: a prepaid network item is charged up to the instance's term end, the rest of the current period in proportion to the time left, and from then on renews, renews automatically and expires with the instance. `billing` may be omitted to take the instance's terms; given, its usage type and period must be the instance's (422 `ELASTIC_IP_BILLING_TERMS_MISMATCH`). An instance that cannot take another elastic IP, or whose type allows less bandwidth than `bandwidth_mbps`, is refused before anything is ordered, as associating would be.
+ *
  * The elastic IP is `pending` from the moment its Checkout Session is created until it is delivered or its checkout or order ends. Every other operation on it is refused with `COMPUTE_RESOURCE_BUSY` meanwhile, and its deletion with `COMPUTE_PURCHASE_PENDING` while its purchase awaits checkout or payment.
  * @summary Allocate an elastic IP
  */
-export const CreateElasticIpBody = CreateElasticIPRequestBody;
+export const CreateElasticIpBody = CreateElasticIpRequestBody;
 /**
  * @summary Retrieve an elastic IP
  */
@@ -219,39 +228,12 @@ export const GetElasticIpParams = zod.strictObject({
         .regex(getElasticIpPathElasticIpIdRegExp)
         .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
-/**
- * Changes the bandwidth of this elastic IP, or what its pay-as-you-go network subscription charges for. `bandwidth_mbps` and `internet_charge_type` are operational fields: each starts a change and cannot be combined with any other field in the same request. Such a request is refused with 422 `UPDATE_FIELDS_COMBINED`, because a change that committed beside another that was then refused would leave the request half applied. An elastic IP has no descriptive field today, so 200 is reserved for the fields that may be added to it and every accepted update answers 202. `checkout` and `proration_date` belong to the purchase of the `bandwidth_mbps` change and are accepted only together with it.
- *
- * No separate bandwidth resource is created, and the limit applies to inbound and outbound traffic alike. The new value may be any whole number of Mbps within the line's bandwidth range, otherwise the request is refused with `ELASTIC_IP_BANDWIDTH_RANGE`. How the change is paid follows the elastic IP's network subscription:
- *
- * - **Prepaid**: the change goes through a Checkout Session that changes the network subscription, priced for the rest of its period. It starts once Billing accepts the order; if checkout is not completed, the order is not accepted or the change fails, `bandwidth_mbps` keeps its value and Billing shows the outcome.
- * - **Pay-as-you-go**: there is no checkout. The change starts at once, `checkout_session_id` and `order_id` are null, and the new limit is metered from the instant it is applied; if it fails, the old limit stays in effect and metered. `checkout` and `proration_date` are refused with `ELASTIC_IP_CHECKOUT_UNUSED`.
- *
- * A change of `internet_charge_type` needs no checkout and is `updating_internet_charge_type` until it is applied; see the field.
- *
- * The elastic IP is `updating_bandwidth` until the change is applied or ends, so other operations and a second change are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The current limit stays in effect until the change is applied.
- *
- * While the address is associated with 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 associated is checked when the address is associated with an instance.
- * @summary Update an elastic IP
- */
-export const updateElasticIpPathElasticIpIdMin = 30;
-export const updateElasticIpPathElasticIpIdMax = 34;
-export const updateElasticIpPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
-export const UpdateElasticIpParams = zod.strictObject({
-    elasticIpId: zod
-        .string()
-        .min(updateElasticIpPathElasticIpIdMin)
-        .max(updateElasticIpPathElasticIpIdMax)
-        .regex(updateElasticIpPathElasticIpIdRegExp)
-        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
-});
-export const UpdateElasticIpBody = UpdateElasticIPRequestBody;
 /**
  * Releases the elastic IP after dissociating it. The elastic IP is `deleting` until cleanup is confirmed; the address then immediately returns to available inventory, with no cooldown period. Deleting the association or replacing it alone does not release the address.
  *
  * Refused with `COMPUTE_PURCHASE_PENDING` while the purchase that created it still awaits checkout or payment; `meta.checkout_session_id` names its Checkout Session and `meta.order_id` its order once checkout created one. Expire the session or cancel the order in Billing instead.
  *
- * While subscriptions pay for the elastic IP (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed subscription being refunded under its terms, and `period_end` keeps the elastic IP working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
+ * While subscription items pay for the elastic IP (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed item being refunded under its terms, and `period_end` keeps the elastic IP working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
  * @summary Release an elastic IP
  */
 export const deleteElasticIpPathElasticIpIdMin = 30;
@@ -269,8 +251,49 @@ export const DeleteElasticIpQueryParams = zod.strictObject({
     cancellation_mode: zod
         .enum(["immediate", "period_end"])
         .optional()
-        .describe("When the subscriptions that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each subscription was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go subscription ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+        .describe("When the subscription items that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their subscription's paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each item was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go item ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+});
+/**
+ * Changes the bandwidth ceiling of this elastic IP. No separate bandwidth resource is created, and the limit applies to inbound and outbound traffic alike. The new value may be any whole number of Mbps within the line's bandwidth range, otherwise the request is refused with `ELASTIC_IP_BANDWIDTH_RANGE`. How the change is paid follows the elastic IP's network item:
+ *
+ * - **Prepaid**: the change goes through a Checkout Session that changes the network item, priced for the rest of its period. It starts once Billing accepts the order; if checkout is not completed, the order is not accepted or the change fails, `bandwidth_mbps` keeps its value and Billing shows the outcome.
+ * - **Pay-as-you-go**: there is no checkout. The change starts at once, `checkout_session_id` and `order_id` are null, and the new limit is metered from the instant it is applied; if it fails, the old limit stays in effect and metered. `checkout` and `proration_date` are refused with `ELASTIC_IP_CHECKOUT_UNUSED`.
+ *
+ * The elastic IP is `updating_bandwidth` until the change is applied or ends, so other operations and a second change are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The current limit stays in effect until the change is applied.
+ *
+ * While the address is associated with 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 associated is checked when the address is associated with an instance.
+ * @summary Change the bandwidth of an elastic IP
+ */
+export const changeElasticIpBandwidthPathElasticIpIdMin = 30;
+export const changeElasticIpBandwidthPathElasticIpIdMax = 34;
+export const changeElasticIpBandwidthPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ChangeElasticIpBandwidthParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(changeElasticIpBandwidthPathElasticIpIdMin)
+        .max(changeElasticIpBandwidthPathElasticIpIdMax)
+        .regex(changeElasticIpBandwidthPathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
+export const ChangeElasticIpBandwidthBody = ChangeElasticIpBandwidthRequestBody;
+/**
+ * Moves a pay-as-you-go elastic IP between charging for its bandwidth and charging for its traffic, within the same network item and without checkout. A prepaid network item has paid for its bandwidth and is refused with `ELASTIC_IP_CHARGE_TYPE_PREPAID`; `traffic` on a line whose `traffic_sale_status` is `off_sale` is refused with `ELASTIC_IP_TRAFFIC_UNAVAILABLE`, the type already in effect with `ELASTIC_IP_CHARGE_TYPE_UNCHANGED`, and a type the currency of the network item does not offer on the line with HTTP 403 `ELASTIC_IP_CHARGE_TYPE_NOT_OFFERED`: prices are set per currency, and a currency without one there does not sell that type.
+ *
+ * The change takes effect at the instant it is applied: bandwidth stops being metered then and traffic starts being, or the other way round. Traffic is counted in windows, and a window is charged the way the elastic IP was charged for most of it, so a report that arrives late is still charged as it was at the time and a window the change falls in is never charged both ways. `bandwidth_mbps` stays the ceiling either way. The elastic IP is `updating_internet_charge_type` until the change is applied.
+ * @summary Change what an elastic IP is charged for
+ */
+export const changeElasticIpChargeTypePathElasticIpIdMin = 30;
+export const changeElasticIpChargeTypePathElasticIpIdMax = 34;
+export const changeElasticIpChargeTypePathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ChangeElasticIpChargeTypeParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(changeElasticIpChargeTypePathElasticIpIdMin)
+        .max(changeElasticIpChargeTypePathElasticIpIdMax)
+        .regex(changeElasticIpChargeTypePathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const ChangeElasticIpChargeTypeBody = ChangeElasticIpChargeTypeRequestBody;
 /**
  * The bytes and packets the elastic IP's address sent upstream while the elastic IP held it, summed by hour or by day in UTC over `[start_time, end_time)`. Only intervals with traffic are listed. Inbound traffic is not measured.
  *
@@ -346,7 +369,7 @@ export const AssociateElasticIpParams = zod.strictObject({
         .regex(associateElasticIpPathElasticIpIdRegExp)
         .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
-export const AssociateElasticIpBody = AssociateElasticIPRequestBody;
+export const AssociateElasticIpBody = AssociateElasticIpRequestBody;
 /**
  * The address remains held by the project and simply no longer points at any network interface. The elastic IP is `disassociating` until the change is confirmed, and an instance whose primary interface it pointed at is `disassociating_elastic_ip`. Removing an association that does not exist is refused with 404 `ELASTIC_IP_NOT_ASSOCIATED`.
  * @summary Remove the association of an elastic IP
@@ -511,7 +534,7 @@ export const ListInstancesQueryParams = zod.strictObject({
  *
  * The instances are created in the availability zone of their instance type, and the volumes bought with them have to be of volume types of that zone (422 `VOLUME_TYPE_OTHER_AVAILABILITY_ZONE`). The types have to have room for all of them, checked before anything is ordered: refused with 409 `INSTANCE_TYPE_SOLD_OUT` or `VOLUME_TYPE_SOLD_OUT` when a type takes no new orders for now, `INSTANCE_TYPE_CAPACITY_REACHED` or `VOLUME_TYPE_CAPACITY_REACHED` when what is sold of it is used up, `INSTANCE_TYPE_NO_HOST_ROOM` when no host of the zone can take the machine, `VOLUME_TYPE_NO_POOL_ROOM` when the storage of the zone cannot take the boot volume, and `ELASTIC_IP_LINE_EXHAUSTED` when the line of the new elastic IPs has fewer addresses left than instances. Two orders placed at the same moment can both pass; an instance that finds a type full when its order is accepted is not created and is refunded, ending `failed` with `provisioning_failed`.
  *
- * Choose an image or existing volume through boot_volume, and exactly one of network_interface_id or subnet_id. Existing network interfaces, boot volumes or elastic IPs require count=1. They are not held while the instance is pending; if one is no longer usable when the order is accepted, the instance ends `failed` with `provisioning_failed`. Image boots require boot_volume; existing volumes retain their own subscription. Instances, volumes and public IPs keep their own subscription items on the same order.
+ * Choose an image or existing volume through boot_volume, and exactly one of network_interface_id or subnet_id. Existing network interfaces, boot volumes or elastic IPs require count=1. They are not held while the instance is pending; if one is no longer usable when the order is accepted, the instance ends `failed` with `provisioning_failed`. Image boots require boot_volume; existing volumes retain their own subscription. Each instance gets its own Billing subscription, with the boot volume, data volumes and elastic IP bought with it as items of it: they renew, renew automatically and expire with the machine as a whole, while each can still be changed or released alone. `checkout.auto_renew` turns automatic renewal on for each machine.
  *
  * Instances of one request succeed or fail individually. Each instance, with its boot volume, network interface and elastic IP, is created or fails as a whole. Instances that were created are kept; each failed instance ends `failed` with `provisioning_failed`, its part of the order is refunded, and the order then ends `partially_completed`. An instance is delivered whole or not at all: when the customer cancels any of its order items before the order is accepted, it is not created, its remaining items are canceled and refunded, and it ends `failed` with `order_canceled`. Each instance is named after this request with a number appended.
  *
@@ -537,19 +560,11 @@ export const GetInstanceParams = zod.strictObject({
         .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
 /**
- * Changes the descriptive fields (`name`, `labels`, `notes`) or the operational field `instance_type_id`. All fields are optional and at least one is required. Starting and stopping are the `:start` and `:stop` methods.
- *
- * `instance_type_id` starts a workflow and cannot be combined with any other field in the same request. Such a request is refused with 422 `UPDATE_FIELDS_COMBINED`, because a rename that committed beside a change that was then refused would leave the request half applied. `checkout` and `proration_date` belong to the purchase of the `instance_type_id` change and are accepted only together with it.
- *
- * **Descriptive fields** are not operations and are accepted at any time, whatever the instance is doing. The request returns 200 with `checkout_session_id` and `order_id` null.
+ * Changes the descriptive fields `name`, `labels` and `description`; all are optional and at least one is required. They are not operations and are accepted at any time, whatever the instance is doing. Changing the instance type is the `:resize` method; starting and stopping are `:start` and `:stop`.
  *
  * - `name` changes the display name only. The hostname inside the instance is unchanged; it equals the instance id.
  * - `labels` 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, and an empty object clears them all. Do not put credentials here. Labels are visible to platform operators.
- * - `notes` is 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.
- *
- * **`instance_type_id`** changes the instance's type **cold**: the instance has to be stopped, and is refused with 409 `INSTANCE_RESIZE_REQUIRES_STOP` otherwise. Its operating system is not booted for the change, and it is still stopped once the change is applied; start it when you are ready. An instance stopped by the legacy stop, which released its host, is refused with 409 `INSTANCE_SHELVED`; start it once and stop it again. A target type that cannot hold what the instance already uses is refused before anything is ordered: fewer network interfaces than are attached with 409 `INSTANCE_RESIZE_NETWORK_INTERFACES_EXCEED`, fewer elastic IPs than are associated with 409 `INSTANCE_RESIZE_ELASTIC_IPS_EXCEED`, and less purchasable bandwidth than an associated elastic IP has with 409 `INSTANCE_BANDWIDTH_CEILING` naming it in `meta.elastic_ip_id`. The request returns 202 with the instance and the Checkout Session for the change, including for metered terms. The instance keeps its usage type and period, priced with the target type's matching option; a target type without that option is refused with 409 `BILLING_OPTION_UNAVAILABLE`. The resize starts once Billing accepts the order. Do not submit the change again after paying. After an uncertain response, look the Checkout Session up in Billing before submitting again.
- *
- * The instance is `resizing` until the resize is applied, its Checkout Session expires or its order is canceled, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. It keeps its current type until the resize is applied; the new type takes effect, and is billed from then on, when `instance_type_id` shows it. If checkout is not completed, the order is not accepted or the resize fails, the instance keeps its current type and Billing shows the outcome. A completed resize is final and cannot be reverted; to return to the previous type, submit another resize.
+ * - `description` is 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.
  * @summary Update an instance
  */
 export const updateInstancePathInstanceIdMin = 30;
@@ -571,7 +586,7 @@ export const UpdateInstanceBody = UpdateInstanceRequestBody;
  *
  * Refused with `COMPUTE_PURCHASE_PENDING` while the purchase that created it still awaits checkout or payment; `meta.checkout_session_id` names its Checkout Session and `meta.order_id` its order once checkout created one. Expire the session or cancel the order in Billing instead.
  *
- * While subscriptions pay for the instance (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed subscription being refunded under its terms, and `period_end` keeps the instance working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
+ * While subscription items pay for the instance (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed item being refunded under its terms, and `period_end` keeps the instance working until `scheduled_at` and releases it then. Volumes and elastic IPs kept after the release keep their items, and the subscription continues with them. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
  * @summary Release an instance
  */
 export const deleteInstancePathInstanceIdMin = 30;
@@ -589,8 +604,26 @@ export const DeleteInstanceQueryParams = zod.strictObject({
     cancellation_mode: zod
         .enum(["immediate", "period_end"])
         .optional()
-        .describe("When the subscriptions that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each subscription was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go subscription ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+        .describe("When the subscription items that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their subscription's paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each item was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go item ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+});
+/**
+ * Changes the instance's type **cold**, through a change of its subscription item purchased in Billing: the instance has to be stopped, and is refused with 409 `INSTANCE_RESIZE_REQUIRES_STOP` otherwise. Its operating system is not booted for the change, and it is still stopped once the change is applied; start it when you are ready. An instance stopped by the legacy stop, which released its host, is refused with 409 `INSTANCE_SHELVED`; start it once and stop it again. A target type that cannot hold what the instance already uses is refused before anything is ordered: fewer network interfaces than are attached with 409 `INSTANCE_RESIZE_NETWORK_INTERFACES_EXCEED`, fewer elastic IPs than are associated with 409 `INSTANCE_RESIZE_ELASTIC_IPS_EXCEED`, and less purchasable bandwidth than an associated elastic IP has with 409 `INSTANCE_BANDWIDTH_CEILING` naming it in `meta.elastic_ip_id`. The request returns 202 with the instance and the Checkout Session for the change, including for metered terms. The instance keeps its usage type and period, priced with the target type's matching option; a target type without that option is refused with 409 `BILLING_OPTION_UNAVAILABLE`. The resize starts once Billing accepts the order. Do not submit the change again after paying. After an uncertain response, look the Checkout Session up in Billing before submitting again.
+ *
+ * The instance is `resizing` until the resize is applied, its Checkout Session expires or its order is canceled, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. It keeps its current type until the resize is applied; the new type takes effect, and is billed from then on, when `instance_type_id` shows it. If checkout is not completed, the order is not accepted or the resize fails, the instance keeps its current type and Billing shows the outcome. A completed resize is final and cannot be reverted; to return to the previous type, submit another resize.
+ * @summary Resize an instance
+ */
+export const resizeInstancePathInstanceIdMin = 30;
+export const resizeInstancePathInstanceIdMax = 30;
+export const resizeInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ResizeInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(resizeInstancePathInstanceIdMin)
+        .max(resizeInstancePathInstanceIdMax)
+        .regex(resizeInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
+export const ResizeInstanceBody = ResizeInstanceRequestBody;
 /**
  * Boots the stopped instance on the host it kept; outstanding restrictions can prevent starting. It is `starting` until it is running or the start has failed. Starting a running instance changes nothing.
  *
@@ -611,7 +644,7 @@ export const StartInstanceParams = zod.strictObject({
 /**
  * Shuts the instance down **on its host**, as Alibaba Cloud's ordinary stop does: it keeps its volumes, network interfaces, addresses and quota, and the vCPU and memory of its host stay reserved for it, so it starts again without asking for room. **A metered instance keeps being charged for compute while stopped**; its volumes and elastic IPs are charged as always. An instance stopped by a suspension, for non-payment or by the platform, is not charged for compute while the suspension lasts. It is `stopping` until it is stopped. Stopping a stopped instance changes nothing.
  *
- * Changing `instance_type_id` is done on a stopped instance and only then. A stopped instance can also be rebuilt and have network interfaces and volumes attached and detached; rescuing it needs it running.
+ * Resizing is done on a stopped instance and only then. A stopped instance can also be rebuilt and have network interfaces and volumes attached and detached; rescuing it needs it running.
  * @summary Stop an instance
  */
 export const stopInstancePathInstanceIdMin = 30;
@@ -658,20 +691,20 @@ export const RunInstanceCommandParams = zod.strictObject({
 });
 export const RunInstanceCommandBody = RunInstanceCommandRequestBody;
 /**
- * The instance's VNC console, operated from a browser through a noVNC client. It does not require the instance to be reachable over the network, which makes it usable when a network misconfiguration prevents login.
+ * Issues an address for the instance's VNC console, operated from a browser through a noVNC client. It 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. Every request issues a new address, so request one before each use and do not cache the response.
- * @summary Retrieve a VNC console
+ * The address is single-use and expires within minutes. Every request issues a new address, so request one before each use and do not cache the response.
+ * @summary Create a VNC console address
  */
-export const getInstanceConsolePathInstanceIdMin = 30;
-export const getInstanceConsolePathInstanceIdMax = 30;
-export const getInstanceConsolePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
-export const GetInstanceConsoleParams = zod.strictObject({
+export const createInstanceConsoleUrlPathInstanceIdMin = 30;
+export const createInstanceConsoleUrlPathInstanceIdMax = 30;
+export const createInstanceConsoleUrlPathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const CreateInstanceConsoleUrlParams = zod.strictObject({
     instanceId: zod
         .string()
-        .min(getInstanceConsolePathInstanceIdMin)
-        .max(getInstanceConsolePathInstanceIdMax)
-        .regex(getInstanceConsolePathInstanceIdRegExp)
+        .min(createInstanceConsoleUrlPathInstanceIdMin)
+        .max(createInstanceConsoleUrlPathInstanceIdMax)
+        .regex(createInstanceConsoleUrlPathInstanceIdRegExp)
         .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
 /**
@@ -1135,10 +1168,7 @@ export const GetNetworkInterfaceParams = zod.strictObject({
         .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
 /**
- * Changes the name, or replaces the security groups. The two are never combined (422 `UPDATE_FIELDS_COMBINED`).
- *
- * - `name` is not an operation, is accepted at any time and answers 200.
- * - `security_group_ids` is the complete new set, one to five groups of the network interface's virtual private cloud; groups left out are removed. It applies to traffic of the running instance as soon as it is in place, and answers 202 with the network interface `updating_security_groups` until then.
+ * Changes the name. It is not an operation and is accepted at any time. Replacing the security groups is `:replaceSecurityGroups`.
  *
  * Secondary IPv4 addresses are added and removed under `/network-interfaces/{networkInterfaceId}/addresses`.
  * @summary Update a network interface
@@ -1170,6 +1200,22 @@ export const DeleteNetworkInterfaceParams = zod.strictObject({
         .regex(deleteNetworkInterfacePathNetworkInterfaceIdRegExp)
         .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
 });
+/**
+ * `security_group_ids` is the complete new set, one to five groups of the network interface's virtual private cloud; groups left out are removed. It applies to traffic of the running instance as soon as it is in place, and the network interface is `updating_security_groups` until then.
+ * @summary Replace the security groups of a network interface
+ */
+export const replaceNetworkInterfaceSecurityGroupsPathNetworkInterfaceIdMin = 30;
+export const replaceNetworkInterfaceSecurityGroupsPathNetworkInterfaceIdMax = 30;
+export const replaceNetworkInterfaceSecurityGroupsPathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ReplaceNetworkInterfaceSecurityGroupsParams = zod.strictObject({
+    networkInterfaceId: zod
+        .string()
+        .min(replaceNetworkInterfaceSecurityGroupsPathNetworkInterfaceIdMin)
+        .max(replaceNetworkInterfaceSecurityGroupsPathNetworkInterfaceIdMax)
+        .regex(replaceNetworkInterfaceSecurityGroupsPathNetworkInterfaceIdRegExp)
+        .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const ReplaceNetworkInterfaceSecurityGroupsBody = ReplaceNetworkInterfaceSecurityGroupsRequestBody;
 /**
  * Adds an IPv4 address in the network interface's subnet, given or chosen by the network, and answers 202 with the network interface `adding_address` until the address is in place; it then appears among `addresses` with `role` `secondary`. An elastic IP can be associated with it like the primary address.
  *
@@ -1348,7 +1394,7 @@ export const UpdatePrivateImageBody = UpdatePrivateImageRequestBody;
  *
  * A resource whose purchase still awaits checkout or payment is refused with `COMPUTE_PURCHASE_PENDING`; `meta.checkout_session_id` names its Checkout Session and `meta.order_id` its order once checkout created one. Expire the session or cancel the order in Billing instead. A subscribed resource is released through its subscription cancellation. Cleanup must be confirmed before metering is stopped; unknown cleanup is not proof of release.
  *
- * While subscriptions pay for the private image (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed subscription being refunded under its terms, and `period_end` keeps the private image working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
+ * While subscription items pay for the private image (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed item being refunded under its terms, and `period_end` keeps the private image working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
  * @summary Delete a private image
  */
 export const deletePrivateImagePathPrivateImageIdMin = 32;
@@ -1366,7 +1412,7 @@ export const DeletePrivateImageQueryParams = zod.strictObject({
     cancellation_mode: zod
         .enum(["immediate", "period_end"])
         .optional()
-        .describe("When the subscriptions that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each subscription was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go subscription ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+        .describe("When the subscription items that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their subscription's paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each item was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go item ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
 });
 /**
  * Lists the platform's public images that are on sale. A public image is offered to every project. One the platform withdraws disappears from here and can no longer install new instances, while the instances already running it keep running and can still be rebuilt onto it; retrieve it by id to see it.
@@ -2212,7 +2258,7 @@ export const UpdateVolumeBackupBody = UpdateVolumeBackupRequestBody;
  *
  * A resource whose purchase still awaits checkout or payment is refused with `COMPUTE_PURCHASE_PENDING`; `meta.checkout_session_id` names its Checkout Session and `meta.order_id` its order once checkout created one. Expire the session or cancel the order in Billing instead. A subscribed resource is released through its subscription cancellation. Cleanup must be confirmed before metering is stopped; unknown cleanup is not proof of release.
  *
- * While subscriptions pay for the volume backup (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed subscription being refunded under its terms, and `period_end` keeps the volume backup working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
+ * While subscription items pay for the volume backup (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed item being refunded under its terms, and `period_end` keeps the volume backup working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
  * @summary Delete a volume backup
  */
 export const deleteVolumeBackupPathVolumeBackupIdMin = 36;
@@ -2230,7 +2276,7 @@ export const DeleteVolumeBackupQueryParams = zod.strictObject({
     cancellation_mode: zod
         .enum(["immediate", "period_end"])
         .optional()
-        .describe("When the subscriptions that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each subscription was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go subscription ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+        .describe("When the subscription items that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their subscription's paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each item was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go item ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
 });
 /**
  * @summary List snapshots
@@ -2307,7 +2353,7 @@ export const UpdateVolumeSnapshotBody = UpdateVolumeSnapshotRequestBody;
  *
  * A resource whose purchase still awaits checkout or payment is refused with `COMPUTE_PURCHASE_PENDING`; `meta.checkout_session_id` names its Checkout Session and `meta.order_id` its order once checkout created one. Expire the session or cancel the order in Billing instead. A subscribed resource is released through its subscription cancellation. Cleanup must be confirmed before metering is stopped; unknown cleanup is not proof of release.
  *
- * While subscriptions pay for the snapshot (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed subscription being refunded under its terms, and `period_end` keeps the snapshot working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
+ * While subscription items pay for the snapshot (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed item being refunded under its terms, and `period_end` keeps the snapshot working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
  * @summary Delete a snapshot
  */
 export const deleteVolumeSnapshotPathVolumeSnapshotIdMin = 38;
@@ -2325,7 +2371,7 @@ export const DeleteVolumeSnapshotQueryParams = zod.strictObject({
     cancellation_mode: zod
         .enum(["immediate", "period_end"])
         .optional()
-        .describe("When the subscriptions that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each subscription was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go subscription ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+        .describe("When the subscription items that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their subscription's paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each item was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go item ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
 });
 /**
  * Volume types on sale are listed, and sold-out ones with `sale_status` `sold_out`. Any of them boots an instance of its zone, holds data or takes a restore. A withdrawn one disappears from here and can no longer be bought, while the volumes already on it keep working and can still be resized.
@@ -2438,7 +2484,9 @@ export const ListVolumesQueryParams = zod.strictObject({
  *
  * A volume type that is off sale is rejected with `VOLUME_TYPE_OFF_SALE`, even though its identifier still resolves. Types that are off sale do not appear in the volume type listing; volumes already bought on one keep working and can still be resized.
  *
- * A volume bought on its own is licensed: `billing.usage_type` `metered` is refused with `VOLUME_USAGE_TYPE_UNAVAILABLE`. A volume created with an instance follows the machine's terms instead and may be metered.
+ * A volume bought on its own is licensed, with a Billing subscription of its own: `billing.usage_type` `metered` is refused with `VOLUME_USAGE_TYPE_UNAVAILABLE`. A volume created with an instance follows the machine's terms instead and may be metered.
+ *
+ * **Buying for an instance.** With `instance_id`, the volume is attached to that instance of the project once created, and becomes an item of the instance's Billing subscription: it is charged up to the instance's term end, the rest of the current period in proportion to the time left, and from then on renews, renews automatically and expires with the instance. Its volume type has to be of the instance's availability zone (422 `VOLUME_TYPE_OTHER_AVAILABILITY_ZONE`). `billing` may be omitted to take the instance's terms; given, its usage type and period must be the instance's (422 `VOLUME_BILLING_TERMS_MISMATCH`), while its termination policy may differ. An instance with no room for another volume is refused before anything is ordered, as attaching would be.
  *
  * The volume is `pending` from the moment its Checkout Session is created until it is delivered or its checkout or order ends. Every other operation on it is refused with `COMPUTE_RESOURCE_BUSY` meanwhile, and its deletion with `COMPUTE_PURCHASE_PENDING` while its purchase awaits checkout or payment.
  * @summary Create a volume
@@ -2460,17 +2508,7 @@ export const GetVolumeParams = zod.strictObject({
         .describe("Compute Volume TypeID. UUID text is not accepted."),
 });
 /**
- * Changes the name, the capacity or the volume type. The availability zone is immutable.
- *
- * `size_gib` and `volume_type_id` are operational fields: each starts a change and cannot be combined with any other field in the same request, including the other one. Such a request is refused with 422 `UPDATE_FIELDS_COMBINED`, because a rename that committed beside a change that was then refused would leave the request half applied. `checkout` and `proration_date` belong to the purchase of the change and are accepted only together with one of them.
- *
- * **Renaming** is not an operation and is accepted at any time. It returns 200 with `checkout_session_id` and `order_id` null.
- *
- * **Resizing** accepts only an increase; a smaller `size_gib` is refused with `VOLUME_CANNOT_SHRINK` (422), since a file system cannot be shrunk from outside the instance. It returns 202 with the volume and the Checkout Session for the resize, which keeps the volume's usage type and period. The volume is `resizing` until the resize is applied, its Checkout Session expires or its order is canceled, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The volume keeps its current size until the resize is applied; once `size_gib` shows the new size, extend the file system inside the instance. If checkout is not completed, the order is not accepted or the resize fails, the volume keeps its size and Billing shows the outcome.
- *
- * **Changing the type** moves the volume to another volume type at the same capacity, priced as that type, and returns 202 with the volume and the Checkout Session for the change, which keeps the volume's usage type and period. The volume has to be detached (409 `VOLUME_RETYPE_ATTACHED`), so a boot volume cannot change its type. The target has to be on sale (`VOLUME_TYPE_OFF_SALE`), in the volume's region (422 `VOLUME_RETYPE_OTHER_REGION`), of the volume's availability zone (422 `VOLUME_TYPE_OTHER_AVAILABILITY_ZONE`) with room for the volume (409 `VOLUME_TYPE_SOLD_OUT`, `VOLUME_TYPE_CAPACITY_REACHED`, `VOLUME_TYPE_NO_POOL_ROOM`), admit the volume's capacity (422 `VOLUME_SIZE_OUT_OF_RANGE`, `VOLUME_SIZE_NOT_ON_STEP`) and differ from the current one (422 `VOLUME_RETYPE_SAME_TYPE`). The volume is `retyping` until the change is applied, its Checkout Session expires or its order is canceled. A target on the same storage backend takes effect at once; one on another backend copies the volume's data there first, which takes longer the larger the volume is. The volume keeps its type until `volume_type_id` shows the new one, and its `performance` follows from then on; a change that did not take effect leaves the volume as it was and is refunded.
- *
- * An attached volume, including a boot volume, can be resized. The capacity is usable at once, and the volume's `performance` shows what its type gives the new size. **That performance applies from the volume's next attachment, or the next start of its stopped instance**: the storage reads a volume's limits only while connecting it. Until then the attachment's `performance` shows what is in effect.
+ * Changes the name. It is not an operation and is accepted at any time. Growing the volume is `:resize` and moving it to another type is `:retype`.
  * @summary Update a volume
  */
 export const updateVolumePathVolumeIdMin = 30;
@@ -2490,7 +2528,7 @@ export const UpdateVolumeBody = UpdateVolumeRequestBody;
  *
  * Refused with `COMPUTE_PURCHASE_PENDING` while the purchase that created it still awaits checkout or payment; `meta.checkout_session_id` names its Checkout Session and `meta.order_id` its order once checkout created one. Expire the session or cancel the order in Billing instead.
  *
- * While subscriptions pay for the volume (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed subscription being refunded under its terms, and `period_end` keeps the volume working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
+ * While subscription items pay for the volume (those in its `release_set`), deleting it cancels them rather than being refused: Compute creates one Billing cancellation for the whole set and answers with it in `cancellation`. `cancellation_mode` chooses when: `immediate` cancels the set now, a licensed item being refunded under its terms, and `period_end` keeps the volume working until `scheduled_at` and releases it then. Asking again while that cancellation is pending answers with it again, whatever mode is asked for.
  * @summary Delete a volume
  */
 export const deleteVolumePathVolumeIdMin = 30;
@@ -2508,8 +2546,42 @@ export const DeleteVolumeQueryParams = zod.strictObject({
     cancellation_mode: zod
         .enum(["immediate", "period_end"])
         .optional()
-        .describe("When the subscriptions that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each subscription was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go subscription ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+        .describe("When the subscription items that pay for what is deleted end. `immediate` cancels them now and refunds a licensed one under its terms; `period_end` cancels them at the end of their subscription's paid period and keeps what is deleted working until then. Omitted, they are canceled now where the terms of every one of them allow it, and otherwise all at the end of the paid period, since one cancellation releases the whole set at one instant.\n\nBilling alone judges the mode against the terms each item was bought with. It refuses with 422 `BILLING_CANCELLATION_MODE_FIXED` a mode those terms do not allow: a pay-as-you-go item ends only now, and a prepaid one whose terms allow only the end of its period only then. It refuses `period_end` with 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when the paid periods end at different times. Ignored when nothing is subscribed, and when a cancellation is already open: deleting again answers with that one as it is."),
+});
+/**
+ * Grows the volume through a change of its subscription item purchased in Billing. Only an increase is accepted; a smaller `size_gib` is refused with `VOLUME_CANNOT_SHRINK` (422), since a file system cannot be shrunk from outside the instance. It returns 202 with the volume and the Checkout Session for the resize, which keeps the volume's usage type and period. The volume is `resizing` until the resize is applied, its Checkout Session expires or its order is canceled, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The volume keeps its current size until the resize is applied; once `size_gib` shows the new size, extend the file system inside the instance. If checkout is not completed, the order is not accepted or the resize fails, the volume keeps its size and Billing shows the outcome.
+ *
+ * An attached volume, including a boot volume, can be resized. The capacity is usable at once, and the volume's `performance` shows what its type gives the new size. **That performance applies from the volume's next attachment, or the next start of its stopped instance**: the storage reads a volume's limits only while connecting it. Until then the attachment's `performance` shows what is in effect.
+ * @summary Resize a volume
+ */
+export const resizeVolumePathVolumeIdMin = 30;
+export const resizeVolumePathVolumeIdMax = 30;
+export const resizeVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ResizeVolumeParams = zod.strictObject({
+    volumeId: zod
+        .string()
+        .min(resizeVolumePathVolumeIdMin)
+        .max(resizeVolumePathVolumeIdMax)
+        .regex(resizeVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
+});
+export const ResizeVolumeBody = ResizeVolumeRequestBody;
+/**
+ * Moves the volume to another volume type at the same capacity, priced as that type, through a change of its subscription item purchased in Billing, and returns 202 with the volume and the Checkout Session for the change, which keeps the volume's usage type and period. The volume has to be detached (409 `VOLUME_RETYPE_ATTACHED`), so a boot volume cannot change its type. The target has to be on sale (`VOLUME_TYPE_OFF_SALE`), in the volume's region (422 `VOLUME_RETYPE_OTHER_REGION`), of the volume's availability zone (422 `VOLUME_TYPE_OTHER_AVAILABILITY_ZONE`) with room for the volume (409 `VOLUME_TYPE_SOLD_OUT`, `VOLUME_TYPE_CAPACITY_REACHED`, `VOLUME_TYPE_NO_POOL_ROOM`), admit the volume's capacity (422 `VOLUME_SIZE_OUT_OF_RANGE`, `VOLUME_SIZE_NOT_ON_STEP`) and differ from the current one (422 `VOLUME_RETYPE_SAME_TYPE`). The volume is `retyping` until the change is applied, its Checkout Session expires or its order is canceled. A target on the same storage backend takes effect at once; one on another backend copies the volume's data there first, which takes longer the larger the volume is. The volume keeps its type until `volume_type_id` shows the new one, and its `performance` follows from then on; a change that did not take effect leaves the volume as it was and is refunded.
+ * @summary Change the type of a volume
+ */
+export const retypeVolumePathVolumeIdMin = 30;
+export const retypeVolumePathVolumeIdMax = 30;
+export const retypeVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RetypeVolumeParams = zod.strictObject({
+    volumeId: zod
+        .string()
+        .min(retypeVolumePathVolumeIdMin)
+        .max(retypeVolumePathVolumeIdMax)
+        .regex(retypeVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
 });
+export const RetypeVolumeBody = RetypeVolumeRequestBody;
 /**
  * Restores the contents of the volume to the moment the snapshot was taken. **All data written after that moment is lost and cannot be recovered.**
  *

package/dist/compute/v2/generated/validators/{associateElasticIPRequestBody.zod.d.ts → associateElasticIpRequestBody.zod.d.ts}

@@ -16,7 +16,7 @@
  * - **Quotas.** A creation, purchase or resize that adds to what a project holds in a region is checked against the project's quota there before anything is ordered or created, and is refused with HTTP 409 `COMPUTE_PROJECT_QUOTA_EXCEEDED`, whose `meta` names the `resource`, its `limit`, the amount `used` and the amount `requested`. An instance purchase counts the volumes, the new primary network interface and the new elastic IP bought with each instance. Read the limits with `list-quotas`; a limit no operator set is the platform default.
  * - **Projects.** Resource ownership and project identifiers refer to IAM platform projects, not OpenStack tenants. Instances, images and networks share one infrastructure OpenStack project; the platform project remains the authorization and ownership boundary.
  * - **Custom methods.** An action that is not one of the standard methods (list, get, create, update, delete) is a custom method, `POST` on the resource's path followed by `:` and the verb, as in `POST /api/v2/instances/{id}:reboot` (AIP-136). A state is changed by its custom method, never by writing the state: `:start` and `:stop`, `:rescue` and `:unrescue`, `:associate` and `:disassociate`.
- * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only mutable fields, all optional and at least one given, and answers 200 when only descriptive fields changed and 202 when an operation started. An operational field (`instance_type_id`, `size_gib`, `bandwidth_mbps`) cannot be combined with any other field in the same request: it is refused with 422 `UPDATE_FIELDS_COMBINED`, because a rename that committed beside a change that was then refused would leave the request half applied.
+ * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only descriptive fields, all optional and at least one given, and answers 200. A change that starts an operation or a purchase, such as a resize, is its own method (`:resize`, `:retype`, `:changeBandwidth`).
  * - **Billing relationships.** A purchased resource records its `checkout_session_id` and, once checkout completes, its `order_id`, `order_item_id` and `subscription_id`. Its `access_state` is `pending` until the order is accepted and delivery settles it, then `enabled`; a subscription that lapses suspends or reclaims the resource it pays for. Deleting a resource that subscriptions pay for cancels the subscriptions of its `release_set` in Billing, and the deletion answers with that cancellation.
  * - **Availability zones.** A volume and an instance must reside in the same availability zone to be attached. An instance type and a volume type each belong to one availability zone, as on GCP, so a purchase names the type and the type names the zone; the volumes bought with an instance have to be of types of the instance type's zone.
  * - **IPv6 is routed, not translated.** A virtual private cloud with IPv6 holds a /56 and each of its subnets a /64 of it, as on Alibaba Cloud, Tencent Cloud and Azure; IPv6 and its security groups require no EIP or NAT gateway. EIP and NATGateway are IPv4 products; IPv6 EIP, NAT66 and IPv6 port forwarding are not supported.
@@ -33,10 +33,10 @@
  * OpenAPI spec version: 2.0.0
  */
 import * as zod from "zod";
-export declare const AssociateElasticIPRequestBody: zod.ZodUnion<readonly [zod.ZodObject<{
+export declare const AssociateElasticIpRequestBody: zod.ZodUnion<readonly [zod.ZodObject<{
     instance_id: zod.ZodString;
 }, zod.z.core.$strict>, zod.ZodObject<{
     network_interface_address_id: zod.ZodString;
 }, zod.z.core.$strict>]>;
-export type AssociateElasticIPRequestBody = zod.input<typeof AssociateElasticIPRequestBody>;
-export type AssociateElasticIPRequestBodyOutput = zod.output<typeof AssociateElasticIPRequestBody>;
+export type AssociateElasticIpRequestBody = zod.input<typeof AssociateElasticIpRequestBody>;
+export type AssociateElasticIpRequestBodyOutput = zod.output<typeof AssociateElasticIpRequestBody>;

package/dist/compute/v2/generated/validators/{associateElasticIPRequestBody.zod.js → associateElasticIpRequestBody.zod.js}

@@ -16,7 +16,7 @@
  * - **Quotas.** A creation, purchase or resize that adds to what a project holds in a region is checked against the project's quota there before anything is ordered or created, and is refused with HTTP 409 `COMPUTE_PROJECT_QUOTA_EXCEEDED`, whose `meta` names the `resource`, its `limit`, the amount `used` and the amount `requested`. An instance purchase counts the volumes, the new primary network interface and the new elastic IP bought with each instance. Read the limits with `list-quotas`; a limit no operator set is the platform default.
  * - **Projects.** Resource ownership and project identifiers refer to IAM platform projects, not OpenStack tenants. Instances, images and networks share one infrastructure OpenStack project; the platform project remains the authorization and ownership boundary.
  * - **Custom methods.** An action that is not one of the standard methods (list, get, create, update, delete) is a custom method, `POST` on the resource's path followed by `:` and the verb, as in `POST /api/v2/instances/{id}:reboot` (AIP-136). A state is changed by its custom method, never by writing the state: `:start` and `:stop`, `:rescue` and `:unrescue`, `:associate` and `:disassociate`.
- * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only mutable fields, all optional and at least one given, and answers 200 when only descriptive fields changed and 202 when an operation started. An operational field (`instance_type_id`, `size_gib`, `bandwidth_mbps`) cannot be combined with any other field in the same request: it is refused with 422 `UPDATE_FIELDS_COMBINED`, because a rename that committed beside a change that was then refused would leave the request half applied.
+ * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only descriptive fields, all optional and at least one given, and answers 200. A change that starts an operation or a purchase, such as a resize, is its own method (`:resize`, `:retype`, `:changeBandwidth`).
  * - **Billing relationships.** A purchased resource records its `checkout_session_id` and, once checkout completes, its `order_id`, `order_item_id` and `subscription_id`. Its `access_state` is `pending` until the order is accepted and delivery settles it, then `enabled`; a subscription that lapses suspends or reclaims the resource it pays for. Deleting a resource that subscriptions pay for cancels the subscriptions of its `release_set` in Billing, and the deletion answers with that cancellation.
  * - **Availability zones.** A volume and an instance must reside in the same availability zone to be attached. An instance type and a volume type each belong to one availability zone, as on GCP, so a purchase names the type and the type names the zone; the volumes bought with an instance have to be of types of the instance type's zone.
  * - **IPv6 is routed, not translated.** A virtual private cloud with IPv6 holds a /56 and each of its subnets a /64 of it, as on Alibaba Cloud, Tencent Cloud and Azure; IPv6 and its security groups require no EIP or NAT gateway. EIP and NATGateway are IPv4 products; IPv6 EIP, NAT66 and IPv6 port forwarding are not supported.
@@ -35,6 +35,6 @@
 import * as zod from "zod";
 import { InstanceAssociationTarget } from "./instanceAssociationTarget.zod.js";
 import { NetworkInterfaceAddressAssociationTarget } from "./networkInterfaceAddressAssociationTarget.zod.js";
-export const AssociateElasticIPRequestBody = zod
+export const AssociateElasticIpRequestBody = zod
     .union([InstanceAssociationTarget, NetworkInterfaceAddressAssociationTarget])
     .describe("The target an elastic IP points at. Exactly one of the two forms.");

package/dist/compute/v2/generated/validators/attachNetworkInterfaceRequestBody.zod.d.ts

@@ -16,7 +16,7 @@
  * - **Quotas.** A creation, purchase or resize that adds to what a project holds in a region is checked against the project's quota there before anything is ordered or created, and is refused with HTTP 409 `COMPUTE_PROJECT_QUOTA_EXCEEDED`, whose `meta` names the `resource`, its `limit`, the amount `used` and the amount `requested`. An instance purchase counts the volumes, the new primary network interface and the new elastic IP bought with each instance. Read the limits with `list-quotas`; a limit no operator set is the platform default.
  * - **Projects.** Resource ownership and project identifiers refer to IAM platform projects, not OpenStack tenants. Instances, images and networks share one infrastructure OpenStack project; the platform project remains the authorization and ownership boundary.
  * - **Custom methods.** An action that is not one of the standard methods (list, get, create, update, delete) is a custom method, `POST` on the resource's path followed by `:` and the verb, as in `POST /api/v2/instances/{id}:reboot` (AIP-136). A state is changed by its custom method, never by writing the state: `:start` and `:stop`, `:rescue` and `:unrescue`, `:associate` and `:disassociate`.
- * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only mutable fields, all optional and at least one given, and answers 200 when only descriptive fields changed and 202 when an operation started. An operational field (`instance_type_id`, `size_gib`, `bandwidth_mbps`) cannot be combined with any other field in the same request: it is refused with 422 `UPDATE_FIELDS_COMBINED`, because a rename that committed beside a change that was then refused would leave the request half applied.
+ * - **Operations.** Requests such as `:start`, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `status` names it, as in `starting` or `deleting`; once it has finished the resource shows its new status and the result. A resource with an operation in progress refuses another operation with HTTP 409 `COMPUTE_RESOURCE_BUSY`; an operation involving two resources, such as attaching a volume, is refused when either has one. A purchased change, such as a resize, is an operation from the moment its Checkout Session is created until the change is applied, the session expires or its order is canceled. Renaming and replacing labels or notes are not operations and are accepted at any time. **Updating.** A `PATCH` carries only descriptive fields, all optional and at least one given, and answers 200. A change that starts an operation or a purchase, such as a resize, is its own method (`:resize`, `:retype`, `:changeBandwidth`).
  * - **Billing relationships.** A purchased resource records its `checkout_session_id` and, once checkout completes, its `order_id`, `order_item_id` and `subscription_id`. Its `access_state` is `pending` until the order is accepted and delivery settles it, then `enabled`; a subscription that lapses suspends or reclaims the resource it pays for. Deleting a resource that subscriptions pay for cancels the subscriptions of its `release_set` in Billing, and the deletion answers with that cancellation.
  * - **Availability zones.** A volume and an instance must reside in the same availability zone to be attached. An instance type and a volume type each belong to one availability zone, as on GCP, so a purchase names the type and the type names the zone; the volumes bought with an instance have to be of types of the instance type's zone.
  * - **IPv6 is routed, not translated.** A virtual private cloud with IPv6 holds a /56 and each of its subnets a /64 of it, as on Alibaba Cloud, Tencent Cloud and Azure; IPv6 and its security groups require no EIP or NAT gateway. EIP and NATGateway are IPv4 products; IPv6 EIP, NAT66 and IPv6 port forwarding are not supported.