@leaflow/sdk 0.0.0-dev.53.gd8db059 → 0.0.0-dev.535.g1eeb8a5

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

@@ -0,0 +1,2604 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Compute API
+ * Leaflow Compute user API for managing instances, volumes, snapshots, volume backups, public and private images, virtual private clouds, subnets, routes, security groups, network interfaces and elastic IPs.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `scopedTokenAuth` security scheme. The catalog reads, which list and retrieve regions, availability zones, instance types, volume types, public images and elastic IP lines, also answer without a token, so a visitor can configure a purchase and price it with Billing before signing in. A token given to them is still verified, and an invalid one is refused.
+ *
+ * ## Conventions
+ *
+ * - **Purchases.** A purchase that creates resources returns them together with the `checkout_session_id` of its Billing Checkout Session and, once checkout completes, its `order_id`. They are readable at once and start as `pending`: checkout may not be complete, the order has not been accepted, nothing exists in the cloud, no inventory such as an address is held, and fields known only after allocation, such as addresses, are null. Once Billing accepts the order, the resource is created: it stays `pending`, then reaches its usual status, such as `running` or `available`. When the Checkout Session expires, the order is declined, canceled or expires, or creation fails, the resource ends `failed` and `failure_reason` states why; the charge for a resource that failed after acceptance is refunded. A purchased change, such as a resize requested with `instance_type_id`, `size_gib` or `bandwidth_mbps` on the resource, returns the resource unchanged with the Checkout Session for the change, and applies once its order is accepted.
+ * - **Commercial terms.** Compute catalogs describe technical specifications and, for each order line a purchase makes, how it is sold in Billing (a `BillingComponent`: its Plan, dimensions, what its quantity counts and what its meters read); prices, amounts and currency belong to Billing. A purchase chooses its terms with `billing`, and Billing selects the matching price. Read prices and their rates with Billing's `search-prices` from those components, quote a proposed purchase with `get-quote`, and a change of a resource by its `subscription_id`; Compute has no quote or price proxy endpoint and returns no amounts.
+ * - **Checkout.** `checkout` is passed to Billing unchanged. Omit it for automatic checkout, which completes checkout within the request and pays from eligible credit grants and balance; insufficient funds refuse the request with HTTP 422 `BILLING_INSUFFICIENT_FUNDS`, and nothing is created. With `checkout.mode` set to `deferred`, the resources are returned `pending` with an open Checkout Session and no order, even for a zero total; nothing is created until the customer completes checkout in Billing, where a promotion code can be applied, and the order is paid. Do not submit the purchase again after paying; after an uncertain response, look the Checkout Session up in Billing first.
+ * - **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 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.
+ * - **Elastic IP release.** A released address returns to available inventory as soon as its cleanup is confirmed, with no cooldown period. Removing or replacing an elastic IP's association keeps the address held by the project and does not release it.
+ * - **Passwords are returned once.** A password generated by the platform during creation or rebuild appears only in that response. Store it immediately.
+ *
+ * ## Resource identifiers
+ *
+ * Compute resource IDs use the fixed TypeID prefix declared in their schema. UUID text is not accepted for these resource IDs. Project, order, subscription and Billing Plan identifiers remain UUIDs. Historical operation-log subject IDs are audit facts and are not rewritten.
+ *
+ * ## Error meta
+ *
+ * Resource identifiers in an error's `meta` (`resource_id`, `volume_id`, `network_interface_id` and the like) are TypeIDs, in the same form as the identifiers in resources. `meta.resource_type` is the resource's name as written in paths, with underscores: `instance`, `volume`, `elastic_ip`, `network_interface`, `virtual_private_cloud`, `private_image`, `volume_backup`, and so on.
+ * OpenAPI spec version: 2.0.0
+ */
+import * as zod from "zod";
+import { AssociateElasticIpRequestBody } from "./validators/associateElasticIpRequestBody.zod.js";
+import { AttachNetworkInterfaceRequestBody } from "./validators/attachNetworkInterfaceRequestBody.zod.js";
+import { AttachVolumeRequestBody } from "./validators/attachVolumeRequestBody.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";
+import { CreateNetworkInterfaceRequestBody } from "./validators/createNetworkInterfaceRequestBody.zod.js";
+import { CreatePrivateImageRequestBody } from "./validators/createPrivateImageRequestBody.zod.js";
+import { CreateSecurityGroupRequestBody } from "./validators/createSecurityGroupRequestBody.zod.js";
+import { CreateSecurityGroupRuleRequestBody } from "./validators/createSecurityGroupRuleRequestBody.zod.js";
+import { CreateVirtualPrivateCloudPeeringRequestBody } from "./validators/createVirtualPrivateCloudPeeringRequestBody.zod.js";
+import { CreateVirtualPrivateCloudRequestBody } from "./validators/createVirtualPrivateCloudRequestBody.zod.js";
+import { CreateVirtualPrivateCloudRouteRequestBody } from "./validators/createVirtualPrivateCloudRouteRequestBody.zod.js";
+import { CreateVirtualPrivateCloudSubnetRequestBody } from "./validators/createVirtualPrivateCloudSubnetRequestBody.zod.js";
+import { CreateVolumeBackupRequestBody } from "./validators/createVolumeBackupRequestBody.zod.js";
+import { CreateVolumeRequestBody } from "./validators/createVolumeRequestBody.zod.js";
+import { CreateVolumeSnapshotRequestBody } from "./validators/createVolumeSnapshotRequestBody.zod.js";
+import { NewLaunchTemplateVersion } from "./validators/newLaunchTemplateVersion.zod.js";
+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 { UpdateInstanceRequestBody } from "./validators/updateInstanceRequestBody.zod.js";
+import { UpdateLaunchTemplateRequestBody } from "./validators/updateLaunchTemplateRequestBody.zod.js";
+import { UpdateNetworkInterfaceRequestBody } from "./validators/updateNetworkInterfaceRequestBody.zod.js";
+import { UpdatePrivateImageRequestBody } from "./validators/updatePrivateImageRequestBody.zod.js";
+import { UpdateSecurityGroupRequestBody } from "./validators/updateSecurityGroupRequestBody.zod.js";
+import { UpdateVirtualPrivateCloudRequestBody } from "./validators/updateVirtualPrivateCloudRequestBody.zod.js";
+import { UpdateVirtualPrivateCloudSubnetRequestBody } from "./validators/updateVirtualPrivateCloudSubnetRequestBody.zod.js";
+import { UpdateVolumeBackupRequestBody } from "./validators/updateVolumeBackupRequestBody.zod.js";
+import { UpdateVolumeRequestBody } from "./validators/updateVolumeRequestBody.zod.js";
+import { UpdateVolumeSnapshotRequestBody } from "./validators/updateVolumeSnapshotRequestBody.zod.js";
+/**
+ * A volume and an instance must reside in the same availability zone to be attached. Confirm the zone before creating either. Without `region_id`, the zones of every region are listed.
+ * @summary List availability zones
+ */
+export const listAvailabilityZonesQueryRegionIdMin = 33;
+export const listAvailabilityZonesQueryRegionIdMax = 33;
+export const listAvailabilityZonesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listAvailabilityZonesQueryPageDefault = 1;
+export const listAvailabilityZonesQueryPageMax = 2147483647;
+export const listAvailabilityZonesQueryPageSizeDefault = 50;
+export const listAvailabilityZonesQueryPageSizeMax = 200;
+export const ListAvailabilityZonesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listAvailabilityZonesQueryRegionIdMin)
+        .max(listAvailabilityZonesQueryRegionIdMax)
+        .regex(listAvailabilityZonesQueryRegionIdRegExp)
+        .optional()
+        .describe("Return only the zones of this region"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listAvailabilityZonesQueryPageMax)
+        .default(listAvailabilityZonesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listAvailabilityZonesQueryPageSizeMax)
+        .default(listAvailabilityZonesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * A volume and an instance must reside in the same availability zone to be attached.
+ * @summary Retrieve an availability zone
+ */
+export const getAvailabilityZonePathAvailabilityZoneIdMin = 31;
+export const getAvailabilityZonePathAvailabilityZoneIdMax = 31;
+export const getAvailabilityZonePathAvailabilityZoneIdRegExp = new RegExp("^zone_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetAvailabilityZoneParams = zod.strictObject({
+    availabilityZoneId: zod
+        .string()
+        .min(getAvailabilityZonePathAvailabilityZoneIdMin)
+        .max(getAvailabilityZonePathAvailabilityZoneIdMax)
+        .regex(getAvailabilityZonePathAvailabilityZoneIdRegExp)
+        .describe("Compute AvailabilityZone TypeID. UUID text is not accepted."),
+});
+/**
+ * Lists the lines on sale. A line is the network an elastic IP is bought on, with the bandwidth that can be chosen and the two Billing Plans its elastic IPs are paid under. Region is optional. Prices, commercial terms and checkout are read directly from Billing. `q` searches the names and descriptions of the lines on sale; filters combine with AND, and pagination is independent of them.
+ * @summary List and search elastic IP lines
+ */
+export const listElasticIpLinesQueryRegionIdMin = 33;
+export const listElasticIpLinesQueryRegionIdMax = 33;
+export const listElasticIpLinesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listElasticIpLinesQueryQMax = 255;
+export const listElasticIpLinesQueryPageDefault = 1;
+export const listElasticIpLinesQueryPageMax = 2147483647;
+export const listElasticIpLinesQueryPageSizeDefault = 50;
+export const listElasticIpLinesQueryPageSizeMax = 200;
+export const ListElasticIpLinesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listElasticIpLinesQueryRegionIdMin)
+        .max(listElasticIpLinesQueryRegionIdMax)
+        .regex(listElasticIpLinesQueryRegionIdRegExp)
+        .optional()
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+    q: zod
+        .string()
+        .min(1)
+        .max(listElasticIpLinesQueryQMax)
+        .optional()
+        .describe("Search text matched against line names and descriptions; combined with the other filters using AND."),
+    page: zod
+        .int()
+        .min(1)
+        .max(listElasticIpLinesQueryPageMax)
+        .default(listElasticIpLinesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listElasticIpLinesQueryPageSizeMax)
+        .default(listElasticIpLinesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Includes lines off sale that existing elastic IPs are on. No inventory or gateway facts are returned.
+ * @summary Get an elastic IP line
+ */
+export const getElasticIpLinePathElasticIpLineIdMin = 34;
+export const getElasticIpLinePathElasticIpLineIdMax = 34;
+export const getElasticIpLinePathElasticIpLineIdRegExp = new RegExp("^eipline_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetElasticIpLineParams = zod.strictObject({
+    elasticIpLineId: zod
+        .string()
+        .min(getElasticIpLinePathElasticIpLineIdMin)
+        .max(getElasticIpLinePathElasticIpLineIdMax)
+        .regex(getElasticIpLinePathElasticIpLineIdRegExp)
+        .describe("Compute ElasticIpLine TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary List elastic IPs
+ */
+export const listElasticIpsQueryPageDefault = 1;
+export const listElasticIpsQueryPageMax = 2147483647;
+export const listElasticIpsQueryPageSizeDefault = 50;
+export const listElasticIpsQueryPageSizeMax = 200;
+export const ListElasticIpsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listElasticIpsQueryPageMax)
+        .default(listElasticIpsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listElasticIpsQueryPageSizeMax)
+        .default(listElasticIpsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Select an elastic IP line. The elastic IP is bought through a Billing Checkout Session, and no address is allocated before its order is accepted.
+ *
+ * The line has to have an address left, counted before anything is ordered: refused with 409 `ELASTIC_IP_LINE_EXHAUSTED` when every address it sells is held or already promised to a purchase waiting for its order. Two purchases checked at the same moment can both pass on the last address; the later one ends `failed` with `provisioning_failed` and its charge is refunded.
+ *
+ * Returns the elastic IP as `pending` with its Checkout Session; `address` is null until the address is allocated after the order is accepted. A requested `address` is not held while pending; if it is no longer available then, the elastic IP ends `failed` with `provisioning_failed` and its charge is refunded.
+ *
+ * IPv6 is not requested through this endpoint. IPv6 addresses are assigned to instances by the virtual private cloud; enable IPv6 on that network instead.
+ *
+ * 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;
+/**
+ * @summary Retrieve an elastic IP
+ */
+export const getElasticIpPathElasticIpIdMin = 30;
+export const getElasticIpPathElasticIpIdMax = 34;
+export const getElasticIpPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetElasticIpParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(getElasticIpPathElasticIpIdMin)
+        .max(getElasticIpPathElasticIpIdMax)
+        .regex(getElasticIpPathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * 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 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;
+export const deleteElasticIpPathElasticIpIdMax = 34;
+export const deleteElasticIpPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteElasticIpParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(deleteElasticIpPathElasticIpIdMin)
+        .max(deleteElasticIpPathElasticIpIdMax)
+        .regex(deleteElasticIpPathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const DeleteElasticIpQueryParams = zod.strictObject({
+    cancellation_mode: zod
+        .enum(["immediate", "period_end"])
+        .optional()
+        .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.
+ *
+ * Traffic is reported by the region's collectors and appears some minutes after it is sent. Every elastic IP's traffic is shown, whatever it is billed by; only one billed by traffic is charged for it. A span longer than 31 days by hour, or 366 days by day, is refused with `TRAFFIC_USAGE_QUERY_INVALID`.
+ * @summary List the traffic an elastic IP sent
+ */
+export const listElasticIpTrafficUsagePathElasticIpIdMin = 30;
+export const listElasticIpTrafficUsagePathElasticIpIdMax = 34;
+export const listElasticIpTrafficUsagePathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ListElasticIpTrafficUsageParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(listElasticIpTrafficUsagePathElasticIpIdMin)
+        .max(listElasticIpTrafficUsagePathElasticIpIdMax)
+        .regex(listElasticIpTrafficUsagePathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const listElasticIpTrafficUsageQueryIntervalDefault = `hour`;
+export const listElasticIpTrafficUsageQueryPageDefault = 1;
+export const listElasticIpTrafficUsageQueryPageMax = 2147483647;
+export const listElasticIpTrafficUsageQueryPageSizeDefault = 50;
+export const listElasticIpTrafficUsageQueryPageSizeMax = 200;
+export const ListElasticIpTrafficUsageQueryParams = zod.strictObject({
+    interval: zod.enum(["hour", "day"]).default(listElasticIpTrafficUsageQueryIntervalDefault),
+    start_time: zod.iso.datetime({ offset: true }),
+    end_time: zod.iso.datetime({ offset: true }),
+    page: zod
+        .int()
+        .min(1)
+        .max(listElasticIpTrafficUsageQueryPageMax)
+        .default(listElasticIpTrafficUsageQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listElasticIpTrafficUsageQueryPageSizeMax)
+        .default(listElasticIpTrafficUsageQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * The private address of a network interface this elastic IP currently points at. Returns the stored state; it does not query the cloud.
+ *
+ * An elastic IP that points at nothing has no association: the request is refused with 404 `ELASTIC_IP_NOT_ASSOCIATED`.
+ * @summary Retrieve the association of an elastic IP
+ */
+export const getElasticIpAssociationPathElasticIpIdMin = 30;
+export const getElasticIpAssociationPathElasticIpIdMax = 34;
+export const getElasticIpAssociationPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetElasticIpAssociationParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(getElasticIpAssociationPathElasticIpIdMin)
+        .max(getElasticIpAssociationPathElasticIpIdMax)
+        .regex(getElasticIpAssociationPathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Points the elastic IP at a target: an instance, which means the primary private IPv4 address of its primary network interface, or a network interface address (`network_interface_address_id`) given directly. Exactly one of `instance_id` and `network_interface_address_id`. A network interface address must be an assigned, unreleased IPv4 address on a network interface in this project and region; IPv6 addresses are rejected.
+ *
+ * The target becomes what the elastic IP points at. Repeating the request for the target it already points at changes nothing; an elastic IP associated with another target is refused with `ELASTIC_IP_ALREADY_ASSOCIATED` (409), and is moved by disassociating it first, so that the moment traffic stops reaching the old target is one the caller chose. The elastic IP is `associating` until the association is confirmed, and with an instance as the target that instance is `associating_elastic_ip` as well, so the instance must not have another operation in progress.
+ *
+ * The elastic IP must be in the same region as the target. With an instance as the target, the elastic IP's `bandwidth_mbps` must not exceed the `max_bandwidth_mbps` of that instance's type; a higher limit is refused with `INSTANCE_BANDWIDTH_CEILING`.
+ * @summary Associate an elastic IP with a target
+ */
+export const associateElasticIpPathElasticIpIdMin = 30;
+export const associateElasticIpPathElasticIpIdMax = 34;
+export const associateElasticIpPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const AssociateElasticIpParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(associateElasticIpPathElasticIpIdMin)
+        .max(associateElasticIpPathElasticIpIdMax)
+        .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;
+/**
+ * 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
+ */
+export const disassociateElasticIpPathElasticIpIdMin = 30;
+export const disassociateElasticIpPathElasticIpIdMax = 34;
+export const disassociateElasticIpPathElasticIpIdRegExp = new RegExp("^eip_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DisassociateElasticIpParams = zod.strictObject({
+    elasticIpId: zod
+        .string()
+        .min(disassociateElasticIpPathElasticIpIdMin)
+        .max(disassociateElasticIpPathElasticIpIdMax)
+        .regex(disassociateElasticIpPathElasticIpIdRegExp)
+        .describe("The public eip resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * An instance family is one hardware line of a region, such as `g7`, and its instance types are its sizes in each availability zone. A family shows here while it has an instance type on sale or sold out.
+ * @summary List instance families
+ */
+export const listInstanceFamiliesQueryRegionIdMin = 33;
+export const listInstanceFamiliesQueryRegionIdMax = 33;
+export const listInstanceFamiliesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listInstanceFamiliesQueryPageDefault = 1;
+export const listInstanceFamiliesQueryPageMax = 2147483647;
+export const listInstanceFamiliesQueryPageSizeDefault = 50;
+export const listInstanceFamiliesQueryPageSizeMax = 200;
+export const ListInstanceFamiliesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listInstanceFamiliesQueryRegionIdMin)
+        .max(listInstanceFamiliesQueryRegionIdMax)
+        .regex(listInstanceFamiliesQueryRegionIdRegExp)
+        .optional()
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+    page: zod
+        .int()
+        .min(1)
+        .max(listInstanceFamiliesQueryPageMax)
+        .default(listInstanceFamiliesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listInstanceFamiliesQueryPageSizeMax)
+        .default(listInstanceFamiliesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Returns an instance family under the same rule as listing; a family with no instance type on sale or sold out returns 404.
+ * @summary Get an instance family
+ */
+export const getInstanceFamilyPathInstanceFamilyIdMin = 36;
+export const getInstanceFamilyPathInstanceFamilyIdMax = 36;
+export const getInstanceFamilyPathInstanceFamilyIdRegExp = new RegExp("^insfamily_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetInstanceFamilyParams = zod.strictObject({
+    instanceFamilyId: zod
+        .string()
+        .min(getInstanceFamilyPathInstanceFamilyIdMin)
+        .max(getInstanceFamilyPathInstanceFamilyIdMax)
+        .regex(getInstanceFamilyPathInstanceFamilyIdRegExp)
+        .describe("Compute InstanceFamily TypeID. UUID text is not accepted."),
+});
+/**
+ * Instance types on sale are listed, and sold-out ones with `sale_status` `sold_out`. A withdrawn one disappears from here and can no longer be ordered, while the instances already running it keep running.
+ * @summary List instance types on sale
+ */
+export const listInstanceTypesQueryRegionIdMin = 33;
+export const listInstanceTypesQueryRegionIdMax = 33;
+export const listInstanceTypesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listInstanceTypesQueryInstanceFamilyIdMin = 36;
+export const listInstanceTypesQueryInstanceFamilyIdMax = 36;
+export const listInstanceTypesQueryInstanceFamilyIdRegExp = new RegExp("^insfamily_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listInstanceTypesQueryAvailabilityZoneIdMin = 31;
+export const listInstanceTypesQueryAvailabilityZoneIdMax = 31;
+export const listInstanceTypesQueryAvailabilityZoneIdRegExp = new RegExp("^zone_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listInstanceTypesQueryPageDefault = 1;
+export const listInstanceTypesQueryPageMax = 2147483647;
+export const listInstanceTypesQueryPageSizeDefault = 50;
+export const listInstanceTypesQueryPageSizeMax = 200;
+export const ListInstanceTypesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listInstanceTypesQueryRegionIdMin)
+        .max(listInstanceTypesQueryRegionIdMax)
+        .regex(listInstanceTypesQueryRegionIdRegExp)
+        .optional()
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+    instance_family_id: zod
+        .string()
+        .min(listInstanceTypesQueryInstanceFamilyIdMin)
+        .max(listInstanceTypesQueryInstanceFamilyIdMax)
+        .regex(listInstanceTypesQueryInstanceFamilyIdRegExp)
+        .optional()
+        .describe("Return only the types of this instance family."),
+    availability_zone_id: zod
+        .string()
+        .min(listInstanceTypesQueryAvailabilityZoneIdMin)
+        .max(listInstanceTypesQueryAvailabilityZoneIdMax)
+        .regex(listInstanceTypesQueryAvailabilityZoneIdRegExp)
+        .optional()
+        .describe("Return only the types of this availability zone, sold out or not."),
+    page: zod
+        .int()
+        .min(1)
+        .max(listInstanceTypesQueryPageMax)
+        .default(listInstanceTypesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listInstanceTypesQueryPageSizeMax)
+        .default(listInstanceTypesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Returns an instance type on sale or sold out, under the same access rules as listing. Off-sale, retired or absent types return 404.
+ * @summary Get an instance type
+ */
+export const getInstanceTypePathInstanceTypeIdMin = 34;
+export const getInstanceTypePathInstanceTypeIdMax = 34;
+export const getInstanceTypePathInstanceTypeIdRegExp = new RegExp("^instype_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetInstanceTypeParams = zod.strictObject({
+    instanceTypeId: zod
+        .string()
+        .min(getInstanceTypePathInstanceTypeIdMin)
+        .max(getInstanceTypePathInstanceTypeIdMax)
+        .regex(getInstanceTypePathInstanceTypeIdRegExp)
+        .describe("Compute InstanceType TypeID. UUID text is not accepted."),
+});
+/**
+ * Every instance in the project, newest first, in their stored state.
+ * @summary List instances
+ */
+export const listInstancesQueryLabelMax = 128;
+export const listInstancesQueryPageDefault = 1;
+export const listInstancesQueryPageMax = 2147483647;
+export const listInstancesQueryPageSizeDefault = 50;
+export const listInstancesQueryPageSizeMax = 200;
+export const ListInstancesQueryParams = zod.strictObject({
+    label: zod
+        .string()
+        .max(listInstancesQueryLabelMax)
+        .optional()
+        .describe("Only instances carrying this label, written as `key:value` — for example `env:prod`. Both halves are matched exactly"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listInstancesQueryPageMax)
+        .default(listInstancesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listInstancesQueryPageSizeMax)
+        .default(listInstancesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Creates a Billing Checkout Session, including for metered terms, and returns one `pending` instance per requested instance with it. Each new component carries its own commercial terms; their usage type and period must match. A pending instance has no server, boot volume or address, and is not metered.
+ *
+ * Creation starts once Billing accepts the order: the instance stays `pending` while it is created, then becomes `running`. With automatic checkout, insufficient funds refuse the request and nothing is created. With deferred checkout, the instances stay `pending` until the customer completes checkout in Billing and the order is paid; an expired Checkout Session, or a canceled or expired order, leaves them `failed` with `checkout_expired`, `order_canceled` or `order_expired`. Do not submit another creation request after paying. After an uncertain response, look the Checkout Session up in Billing before submitting again.
+ *
+ * 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. 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.
+ *
+ * The network is checked before the Checkout Session is created, and a request it refuses orders and charges nothing. It is refused with `VIRTUAL_PRIVATE_CLOUD_UNAVAILABLE` when the virtual private cloud's `status` is not `available`, `VIRTUAL_PRIVATE_CLOUD_SUBNET_UNAVAILABLE` or `SECURITY_GROUP_UNAVAILABLE` when the subnet or a security group is not ready, `SECURITY_GROUP_OTHER_VIRTUAL_PRIVATE_CLOUD` when a security group belongs to another virtual private cloud, and `NETWORK_INTERFACE_UNAVAILABLE` when the port's `status` is not `available`. `meta` names the resource.
+ *
+ * Each instance is `pending` from the moment the Checkout Session is created until it is delivered or the checkout or order ends. Every other operation on it is refused with `COMPUTE_RESOURCE_BUSY` meanwhile, and its release with `COMPUTE_PURCHASE_PENDING` while its purchase awaits checkout or payment.
+ * @summary Create instances
+ */
+export const CreateInstanceBody = CreateInstanceRequestBody;
+/**
+ * Returns the stored state of the instance; it does not query the cloud. Use it to poll creation progress.
+ * @summary Retrieve an instance
+ */
+export const getInstancePathInstanceIdMin = 30;
+export const getInstancePathInstanceIdMax = 30;
+export const getInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(getInstancePathInstanceIdMin)
+        .max(getInstancePathInstanceIdMax)
+        .regex(getInstancePathInstanceIdRegExp)
+        .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` 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.
+ * - `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;
+export const updateInstancePathInstanceIdMax = 30;
+export const updateInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(updateInstancePathInstanceIdMin)
+        .max(updateInstancePathInstanceIdMax)
+        .regex(updateInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const UpdateInstanceBody = UpdateInstanceRequestBody;
+/**
+ * The boot volume is deleted with the instance, and **snapshots created from the boot volume are deleted with it**. Data volumes 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_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 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;
+export const deleteInstancePathInstanceIdMax = 30;
+export const deleteInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(deleteInstancePathInstanceIdMin)
+        .max(deleteInstancePathInstanceIdMax)
+        .regex(deleteInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const DeleteInstanceQueryParams = zod.strictObject({
+    cancellation_mode: zod
+        .enum(["immediate", "period_end"])
+        .optional()
+        .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.
+ *
+ * When its boot volume grew since it was last connected, the start connects its volumes afresh so that the boot volume runs at the performance of its new size: the instance is taken off its host for that moment and placed again. Only then can the start find no room in the zone; it is refused with 409 `INSTANCE_START_NO_HOST_ROOM`, or ends with the instance still stopped, and can be tried again later. An instance stopped by the legacy stop, which released its host, is placed again the same way.
+ * @summary Start an instance
+ */
+export const startInstancePathInstanceIdMin = 30;
+export const startInstancePathInstanceIdMax = 30;
+export const startInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const StartInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(startInstancePathInstanceIdMin)
+        .max(startInstancePathInstanceIdMax)
+        .regex(startInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * 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.
+ *
+ * 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;
+export const stopInstancePathInstanceIdMax = 30;
+export const stopInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const StopInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(stopInstancePathInstanceIdMin)
+        .max(stopInstancePathInstanceIdMax)
+        .regex(stopInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * 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 elastic IP associated; 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`
+ * - an elastic IP is associated with it, since this endpoint connects over the public internet
+ * - its security group permits inbound TCP 22
+ *
+ * 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.
+ *
+ * **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.
+ * @summary Run a command on an instance
+ */
+export const runInstanceCommandPathInstanceIdMin = 30;
+export const runInstanceCommandPathInstanceIdMax = 30;
+export const runInstanceCommandPathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RunInstanceCommandParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(runInstanceCommandPathInstanceIdMin)
+        .max(runInstanceCommandPathInstanceIdMax)
+        .regex(runInstanceCommandPathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const RunInstanceCommandBody = RunInstanceCommandRequestBody;
+/**
+ * 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 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 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(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."),
+});
+/**
+ * Sets the password of the login account (`login_username`) without a reboot; root is never given one. The instance must be running.
+ *
+ * **Not every image supports this.** Images whose `supports_password_reset` is false cannot, and a new password can then only be set by rebuilding the instance, which erases all data on the boot volume.
+ *
+ * The request is also rejected when the image is marked as supported but the corresponding component has been removed or stopped inside the instance.
+ * @summary Reset the login password
+ */
+export const resetInstancePasswordPathInstanceIdMin = 30;
+export const resetInstancePasswordPathInstanceIdMax = 30;
+export const resetInstancePasswordPathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ResetInstancePasswordParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(resetInstancePasswordPathInstanceIdMin)
+        .max(resetInstancePasswordPathInstanceIdMax)
+        .regex(resetInstancePasswordPathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const ResetInstancePasswordBody = PasswordChoice;
+/**
+ * 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 a soft reboot is in progress, which is the way out of a soft reboot the instance never carried out. Any other request for an operation, including a second soft reboot, is refused with `COMPUTE_RESOURCE_BUSY` while the reboot is in progress.
+ *
+ * An instance suspended by the platform must be unsuspended first.
+ *
+ * The instance is `rebooting` until the reboot has finished.
+ * @summary Reboot an instance
+ */
+export const rebootInstancePathInstanceIdMin = 30;
+export const rebootInstancePathInstanceIdMax = 30;
+export const rebootInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RebootInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(rebootInstancePathInstanceIdMin)
+        .max(rebootInstancePathInstanceIdMax)
+        .regex(rebootInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const RebootInstanceBody = RebootInstanceRequestBody;
+/**
+ * **All data on the boot volume is erased and cannot be recovered.** Attached data volumes are unaffected.
+ *
+ * The instance has to be running or stopped. An instance stopped by the legacy stop, which released its host, is refused with 409 `INSTANCE_SHELVED`; start it once first, which works even when its operating system no longer boots.
+ *
+ * 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.
+ *
+ * The instance is `rebuilding` until the rebuild has finished.
+ * @summary Rebuild an instance
+ */
+export const rebuildInstancePathInstanceIdMin = 30;
+export const rebuildInstancePathInstanceIdMax = 30;
+export const rebuildInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RebuildInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(rebuildInstancePathInstanceIdMin)
+        .max(rebuildInstancePathInstanceIdMax)
+        .regex(rebuildInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const RebuildInstanceBody = RebuildInstanceRequestBody;
+/**
+ * @summary List the volumes attached to an instance
+ */
+export const listInstanceVolumesPathInstanceIdMin = 30;
+export const listInstanceVolumesPathInstanceIdMax = 30;
+export const listInstanceVolumesPathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ListInstanceVolumesParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(listInstanceVolumesPathInstanceIdMin)
+        .max(listInstanceVolumesPathInstanceIdMax)
+        .regex(listInstanceVolumesPathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const listInstanceVolumesQueryPageDefault = 1;
+export const listInstanceVolumesQueryPageMax = 2147483647;
+export const listInstanceVolumesQueryPageSizeDefault = 50;
+export const listInstanceVolumesQueryPageSizeMax = 200;
+export const ListInstanceVolumesQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listInstanceVolumesQueryPageMax)
+        .default(listInstanceVolumesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listInstanceVolumesQueryPageSizeMax)
+        .default(listInstanceVolumesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * The volume must be in the same region and availability zone as the instance. Returns the volume; the instance is `attaching_volume` and the volume is `attaching` until the attachment is confirmed. Partition the volume and mount the file system inside the instance once it is attached.
+ * @summary Attach a volume
+ */
+export const attachInstanceVolumePathInstanceIdMin = 30;
+export const attachInstanceVolumePathInstanceIdMax = 30;
+export const attachInstanceVolumePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const AttachInstanceVolumeParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(attachInstanceVolumePathInstanceIdMin)
+        .max(attachInstanceVolumePathInstanceIdMax)
+        .regex(attachInstanceVolumePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const AttachInstanceVolumeBody = AttachVolumeRequestBody;
+/**
+ * Unmount the device inside the instance before calling this endpoint. Forcibly detaching a file system that is being written to corrupts data.
+ *
+ * The volume the instance boots from cannot be detached, whether it is the boot volume bought with the instance or a volume supplied as the existing boot_volume at launch. Such a request is refused with `INSTANCE_BOOT_VOLUME_LOCKED` and changes nothing; releasing the instance is what frees that volume.
+ *
+ * Returns the volume; the instance is `detaching_volume` and the volume is `detaching` until the volume is detached.
+ * @summary Detach a volume
+ */
+export const detachInstanceVolumePathInstanceIdMin = 30;
+export const detachInstanceVolumePathInstanceIdMax = 30;
+export const detachInstanceVolumePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const detachInstanceVolumePathVolumeIdMin = 30;
+export const detachInstanceVolumePathVolumeIdMax = 30;
+export const detachInstanceVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DetachInstanceVolumeParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(detachInstanceVolumePathInstanceIdMin)
+        .max(detachInstanceVolumePathInstanceIdMax)
+        .regex(detachInstanceVolumePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    volumeId: zod
+        .string()
+        .min(detachInstanceVolumePathVolumeIdMin)
+        .max(detachInstanceVolumePathVolumeIdMax)
+        .regex(detachInstanceVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary List the network interfaces of an instance
+ */
+export const listInstanceNetworkInterfacesPathInstanceIdMin = 30;
+export const listInstanceNetworkInterfacesPathInstanceIdMax = 30;
+export const listInstanceNetworkInterfacesPathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ListInstanceNetworkInterfacesParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(listInstanceNetworkInterfacesPathInstanceIdMin)
+        .max(listInstanceNetworkInterfacesPathInstanceIdMax)
+        .regex(listInstanceNetworkInterfacesPathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const listInstanceNetworkInterfacesQueryPageDefault = 1;
+export const listInstanceNetworkInterfacesQueryPageMax = 2147483647;
+export const listInstanceNetworkInterfacesQueryPageSizeDefault = 50;
+export const listInstanceNetworkInterfacesQueryPageSizeMax = 200;
+export const ListInstanceNetworkInterfacesQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listInstanceNetworkInterfacesQueryPageMax)
+        .default(listInstanceNetworkInterfacesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listInstanceNetworkInterfacesQueryPageSizeMax)
+        .default(listInstanceNetworkInterfacesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Returns the network interface; the instance is `attaching_network_interface` and the interface is `attaching` until the attachment is confirmed. The instance has to be running or stopped; one stopped by the legacy stop, which released its host, is refused with 409 `INSTANCE_SHELVED`.
+ * @summary Attach a network interface
+ */
+export const attachInstanceNetworkInterfacePathInstanceIdMin = 30;
+export const attachInstanceNetworkInterfacePathInstanceIdMax = 30;
+export const attachInstanceNetworkInterfacePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const AttachInstanceNetworkInterfaceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(attachInstanceNetworkInterfacePathInstanceIdMin)
+        .max(attachInstanceNetworkInterfacePathInstanceIdMax)
+        .regex(attachInstanceNetworkInterfacePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const AttachInstanceNetworkInterfaceBody = AttachNetworkInterfaceRequestBody;
+/**
+ * The primary network interface cannot be detached; the instance would lose its network address. The instance has to be running or stopped; one stopped by the legacy stop, which released its host, is refused with 409 `INSTANCE_SHELVED`.
+ *
+ * Returns the network interface; the instance is `detaching_network_interface` and the interface is `detaching` until it is detached.
+ * @summary Detach a network interface
+ */
+export const detachInstanceNetworkInterfacePathInstanceIdMin = 30;
+export const detachInstanceNetworkInterfacePathInstanceIdMax = 30;
+export const detachInstanceNetworkInterfacePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const detachInstanceNetworkInterfacePathNetworkInterfaceIdMin = 30;
+export const detachInstanceNetworkInterfacePathNetworkInterfaceIdMax = 30;
+export const detachInstanceNetworkInterfacePathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DetachInstanceNetworkInterfaceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(detachInstanceNetworkInterfacePathInstanceIdMin)
+        .max(detachInstanceNetworkInterfacePathInstanceIdMax)
+        .regex(detachInstanceNetworkInterfacePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    networkInterfaceId: zod
+        .string()
+        .min(detachInstanceNetworkInterfacePathNetworkInterfaceIdMin)
+        .max(detachInstanceNetworkInterfacePathNetworkInterfaceIdMax)
+        .regex(detachInstanceNetworkInterfacePathNetworkInterfaceIdRegExp)
+        .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Boots a temporary rescue environment in place of the instance's own system, with the original boot volume attached to it as a further disk to repair. A running instance can be rescued, and so can one in `error`. A stopped instance is refused with 409 `INSTANCE_NOT_RUNNING`; start it first, which works even when its operating system no longer boots.
+ *
+ * In rescue mode, everything only the instance's own system can take is refused with 409 `INSTANCE_UNRESCUE_REQUIRED`: starting, stopping, rebooting, rebuilding, resetting the password, changing `instance_type_id`, attaching or detaching volumes and network interfaces, capturing a private image and running commands. Leave rescue mode with `:unrescue` first. The console stays available, releasing the instance works as usual, and the instance is charged as when running. A suspension that begins in rescue mode takes the instance out of rescue before stopping it, and starting it again once the suspension ends boots its own system.
+ *
+ * The rescue environment does not accept passwords. The remote console signs in as `login_username` automatically, and SSH accepts `login_username` with the public keys the instance was created or last rebuilt with.
+ *
+ * A rescue the compute service could not boot leaves the instance as it was, or in `error`; request it again or reboot the instance.
+ *
+ * The request does not name an image. The rescue image is the region's enabled rescue image for the architecture of the instance's boot volume. A region and architecture with no enabled rescue image is refused with `RESCUE_IMAGE_NOT_CONFIGURED` (409).
+ * @summary Put an instance into rescue mode
+ */
+export const rescueInstancePathInstanceIdMin = 30;
+export const rescueInstancePathInstanceIdMax = 30;
+export const rescueInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RescueInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(rescueInstancePathInstanceIdMin)
+        .max(rescueInstancePathInstanceIdMax)
+        .regex(rescueInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Restores boot from the original boot volume. Completion is shown by the instance state, and the instance is `unrescuing` until then.
+ * @summary Take an instance out of rescue mode
+ */
+export const unrescueInstancePathInstanceIdMin = 30;
+export const unrescueInstancePathInstanceIdMax = 30;
+export const unrescueInstancePathInstanceIdRegExp = new RegExp("^ins_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UnrescueInstanceParams = zod.strictObject({
+    instanceId: zod
+        .string()
+        .min(unrescueInstancePathInstanceIdMin)
+        .max(unrescueInstancePathInstanceIdMax)
+        .regex(unrescueInstancePathInstanceIdRegExp)
+        .describe("The public ins resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * @summary List launch templates
+ */
+export const listLaunchTemplatesQueryRegionIdMin = 33;
+export const listLaunchTemplatesQueryRegionIdMax = 33;
+export const listLaunchTemplatesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listLaunchTemplatesQueryPageDefault = 1;
+export const listLaunchTemplatesQueryPageMax = 2147483647;
+export const listLaunchTemplatesQueryPageSizeDefault = 50;
+export const listLaunchTemplatesQueryPageSizeMax = 200;
+export const ListLaunchTemplatesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listLaunchTemplatesQueryRegionIdMin)
+        .max(listLaunchTemplatesQueryRegionIdMax)
+        .regex(listLaunchTemplatesQueryRegionIdRegExp)
+        .optional()
+        .describe("Only launch templates of this region."),
+    page: zod
+        .int()
+        .min(1)
+        .max(listLaunchTemplatesQueryPageMax)
+        .default(listLaunchTemplatesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listLaunchTemplatesQueryPageSizeMax)
+        .default(listLaunchTemplatesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Creates a launch template with its first version, which becomes its default. A launch template describes how to create instances in one region, and creating an instance can name it (`launch_template`) instead of repeating every part. It costs nothing.
+ *
+ * A template holds no billing terms, checkout options or password: those belong to each purchase. **What a version names is checked when an instance is created from it**, against the catalog as it is then, so a version naming an image retired since is refused at that creation as any creation would be.
+ *
+ * A project holds at most 100 launch templates in a region (`LAUNCH_TEMPLATE_LIMIT`), and names are unique among them (`LAUNCH_TEMPLATE_EXISTS`).
+ * @summary Create a launch template
+ */
+export const CreateLaunchTemplateBody = CreateLaunchTemplateRequestBody;
+/**
+ * @summary Get a launch template
+ */
+export const getLaunchTemplatePathLaunchTemplateIdMin = 29;
+export const getLaunchTemplatePathLaunchTemplateIdMax = 29;
+export const getLaunchTemplatePathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetLaunchTemplateParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(getLaunchTemplatePathLaunchTemplateIdMin)
+        .max(getLaunchTemplatePathLaunchTemplateIdMax)
+        .regex(getLaunchTemplatePathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Changes the name or description, or makes another live version the default, the one a creation naming no version uses. Versions themselves never change; describe something else by creating a version.
+ * @summary Update a launch template
+ */
+export const updateLaunchTemplatePathLaunchTemplateIdMin = 29;
+export const updateLaunchTemplatePathLaunchTemplateIdMax = 29;
+export const updateLaunchTemplatePathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateLaunchTemplateParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(updateLaunchTemplatePathLaunchTemplateIdMin)
+        .max(updateLaunchTemplatePathLaunchTemplateIdMax)
+        .regex(updateLaunchTemplatePathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const UpdateLaunchTemplateBody = UpdateLaunchTemplateRequestBody;
+/**
+ * Deletes the template with every version. Instances created from it are not affected and keep naming the version they were created from.
+ * @summary Delete a launch template
+ */
+export const deleteLaunchTemplatePathLaunchTemplateIdMin = 29;
+export const deleteLaunchTemplatePathLaunchTemplateIdMax = 29;
+export const deleteLaunchTemplatePathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteLaunchTemplateParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(deleteLaunchTemplatePathLaunchTemplateIdMin)
+        .max(deleteLaunchTemplatePathLaunchTemplateIdMax)
+        .regex(deleteLaunchTemplatePathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Newest first.
+ * @summary List the versions of a launch template
+ */
+export const listLaunchTemplateVersionsPathLaunchTemplateIdMin = 29;
+export const listLaunchTemplateVersionsPathLaunchTemplateIdMax = 29;
+export const listLaunchTemplateVersionsPathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ListLaunchTemplateVersionsParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(listLaunchTemplateVersionsPathLaunchTemplateIdMin)
+        .max(listLaunchTemplateVersionsPathLaunchTemplateIdMax)
+        .regex(listLaunchTemplateVersionsPathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const listLaunchTemplateVersionsQueryPageDefault = 1;
+export const listLaunchTemplateVersionsQueryPageMax = 2147483647;
+export const listLaunchTemplateVersionsQueryPageSizeDefault = 50;
+export const listLaunchTemplateVersionsQueryPageSizeMax = 200;
+export const ListLaunchTemplateVersionsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listLaunchTemplateVersionsQueryPageMax)
+        .default(listLaunchTemplateVersionsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listLaunchTemplateVersionsQueryPageSizeMax)
+        .default(listLaunchTemplateVersionsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Adds a version, numbered after every version the template ever had, so a deleted version's number is never reused. It does not become the default by itself; set `default_version_number` on the template for that. A template holds at most 100 live versions (`LAUNCH_TEMPLATE_VERSION_LIMIT`).
+ * @summary Create a launch template version
+ */
+export const createLaunchTemplateVersionPathLaunchTemplateIdMin = 29;
+export const createLaunchTemplateVersionPathLaunchTemplateIdMax = 29;
+export const createLaunchTemplateVersionPathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const CreateLaunchTemplateVersionParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(createLaunchTemplateVersionPathLaunchTemplateIdMin)
+        .max(createLaunchTemplateVersionPathLaunchTemplateIdMax)
+        .regex(createLaunchTemplateVersionPathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const CreateLaunchTemplateVersionBody = NewLaunchTemplateVersion;
+/**
+ * @summary Get a launch template version
+ */
+export const getLaunchTemplateVersionPathLaunchTemplateIdMin = 29;
+export const getLaunchTemplateVersionPathLaunchTemplateIdMax = 29;
+export const getLaunchTemplateVersionPathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetLaunchTemplateVersionParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(getLaunchTemplateVersionPathLaunchTemplateIdMin)
+        .max(getLaunchTemplateVersionPathLaunchTemplateIdMax)
+        .regex(getLaunchTemplateVersionPathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    versionNumber: zod.int().min(1),
+});
+/**
+ * The default version cannot be deleted (`LAUNCH_TEMPLATE_VERSION_DEFAULT`); make another version the default first.
+ * @summary Delete a launch template version
+ */
+export const deleteLaunchTemplateVersionPathLaunchTemplateIdMin = 29;
+export const deleteLaunchTemplateVersionPathLaunchTemplateIdMax = 29;
+export const deleteLaunchTemplateVersionPathLaunchTemplateIdRegExp = new RegExp("^lt_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteLaunchTemplateVersionParams = zod.strictObject({
+    launchTemplateId: zod
+        .string()
+        .min(deleteLaunchTemplateVersionPathLaunchTemplateIdMin)
+        .max(deleteLaunchTemplateVersionPathLaunchTemplateIdMax)
+        .regex(deleteLaunchTemplateVersionPathLaunchTemplateIdRegExp)
+        .describe("The public lt resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    versionNumber: zod.int().min(1),
+});
+/**
+ * @summary List network interfaces
+ */
+export const listNetworkInterfacesQueryPageDefault = 1;
+export const listNetworkInterfacesQueryPageMax = 2147483647;
+export const listNetworkInterfacesQueryPageSizeDefault = 50;
+export const listNetworkInterfacesQueryPageSizeMax = 200;
+export const ListNetworkInterfacesQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listNetworkInterfacesQueryPageMax)
+        .default(listNetworkInterfacesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listNetworkInterfacesQueryPageSizeMax)
+        .default(listNetworkInterfacesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * The new network interface is not attached to any instance. Primary network interfaces are not created here; they are created with the instance.
+ * @summary Create a network interface
+ */
+export const CreateNetworkInterfaceBody = CreateNetworkInterfaceRequestBody;
+/**
+ * Returns the stored state of the network interface; it does not query the cloud.
+ * @summary Retrieve a network interface
+ */
+export const getNetworkInterfacePathNetworkInterfaceIdMin = 30;
+export const getNetworkInterfacePathNetworkInterfaceIdMax = 30;
+export const getNetworkInterfacePathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetNetworkInterfaceParams = zod.strictObject({
+    networkInterfaceId: zod
+        .string()
+        .min(getNetworkInterfacePathNetworkInterfaceIdMin)
+        .max(getNetworkInterfacePathNetworkInterfaceIdMax)
+        .regex(getNetworkInterfacePathNetworkInterfaceIdRegExp)
+        .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * 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
+ */
+export const updateNetworkInterfacePathNetworkInterfaceIdMin = 30;
+export const updateNetworkInterfacePathNetworkInterfaceIdMax = 30;
+export const updateNetworkInterfacePathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateNetworkInterfaceParams = zod.strictObject({
+    networkInterfaceId: zod
+        .string()
+        .min(updateNetworkInterfacePathNetworkInterfaceIdMin)
+        .max(updateNetworkInterfacePathNetworkInterfaceIdMax)
+        .regex(updateNetworkInterfacePathNetworkInterfaceIdRegExp)
+        .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const UpdateNetworkInterfaceBody = UpdateNetworkInterfaceRequestBody;
+/**
+ * The primary network interface cannot be deleted on its own, as it is released with the instance. A network interface still attached to an instance cannot be deleted either.
+ * @summary Delete a network interface
+ */
+export const deleteNetworkInterfacePathNetworkInterfaceIdMin = 30;
+export const deleteNetworkInterfacePathNetworkInterfaceIdMax = 30;
+export const deleteNetworkInterfacePathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteNetworkInterfaceParams = zod.strictObject({
+    networkInterfaceId: zod
+        .string()
+        .min(deleteNetworkInterfacePathNetworkInterfaceIdMin)
+        .max(deleteNetworkInterfacePathNetworkInterfaceIdMax)
+        .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.
+ *
+ * **The operating system has to be configured to use it**: DHCP hands out only the primary address. Changing the addresses of a network interface in use may briefly interrupt its traffic.
+ *
+ * A network interface holds at most its instance's instance type's `max_ipv4_per_network_interface` IPv4 addresses while attached, and 50 otherwise (409 `NETWORK_INTERFACE_ADDRESS_CEILING`). An address already in use in the subnet is refused with 409 `NETWORK_INTERFACE_ADDRESS_ALREADY_TAKEN`, a full subnet with 409 `NETWORK_INTERFACE_SUBNET_EXHAUSTED`.
+ * @summary Add a secondary IPv4 address
+ */
+export const createNetworkInterfaceAddressPathNetworkInterfaceIdMin = 30;
+export const createNetworkInterfaceAddressPathNetworkInterfaceIdMax = 30;
+export const createNetworkInterfaceAddressPathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const CreateNetworkInterfaceAddressParams = zod.strictObject({
+    networkInterfaceId: zod
+        .string()
+        .min(createNetworkInterfaceAddressPathNetworkInterfaceIdMin)
+        .max(createNetworkInterfaceAddressPathNetworkInterfaceIdMax)
+        .regex(createNetworkInterfaceAddressPathNetworkInterfaceIdRegExp)
+        .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const CreateNetworkInterfaceAddressBody = CreateNetworkInterfaceAddressRequestBody;
+/**
+ * Removes a secondary IPv4 address and answers 202 with the network interface `removing_address` until it is gone. The primary address goes only with the network interface (409 `NETWORK_INTERFACE_ADDRESS_PRIMARY`), and an address an elastic IP is associated with is refused until it is disassociated (409 `NETWORK_INTERFACE_ADDRESS_ASSOCIATED`).
+ * @summary Remove a secondary IPv4 address
+ */
+export const deleteNetworkInterfaceAddressPathNetworkInterfaceIdMin = 30;
+export const deleteNetworkInterfaceAddressPathNetworkInterfaceIdMax = 30;
+export const deleteNetworkInterfaceAddressPathNetworkInterfaceIdRegExp = new RegExp("^eni_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const deleteNetworkInterfaceAddressPathAddressIdMin = 37;
+export const deleteNetworkInterfaceAddressPathAddressIdMax = 37;
+export const deleteNetworkInterfaceAddressPathAddressIdRegExp = new RegExp("^eniaddress_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteNetworkInterfaceAddressParams = zod.strictObject({
+    networkInterfaceId: zod
+        .string()
+        .min(deleteNetworkInterfaceAddressPathNetworkInterfaceIdMin)
+        .max(deleteNetworkInterfaceAddressPathNetworkInterfaceIdMax)
+        .regex(deleteNetworkInterfaceAddressPathNetworkInterfaceIdRegExp)
+        .describe("The public eni resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    addressId: zod
+        .string()
+        .min(deleteNetworkInterfaceAddressPathAddressIdMin)
+        .max(deleteNetworkInterfaceAddressPathAddressIdMax)
+        .regex(deleteNetworkInterfaceAddressPathAddressIdRegExp)
+        .describe("Compute NetworkInterfaceAddress TypeID. UUID text is not accepted."),
+});
+/**
+ * Records every write operation in the project: who performed it, when, on what, and its outcome. Read operations are not recorded.
+ *
+ * **Operations performed by the platform are included, but the individual operator is not disclosed** and `actor_type` is `platform`. Suspension for non-payment and bans for abuse are examples: the time at which an instance was stopped by the platform is needed, whereas the operator is internal information.
+ *
+ * Fields such as passwords are replaced with a placeholder as the record is written and never appear in `payload`.
+ * @summary List the operation log of the project
+ */
+export const listOperationLogsQueryActionMax = 64;
+export const listOperationLogsQueryPageDefault = 1;
+export const listOperationLogsQueryPageMax = 2147483647;
+export const listOperationLogsQueryPageSizeDefault = 50;
+export const listOperationLogsQueryPageSizeMax = 200;
+export const ListOperationLogsQueryParams = zod.strictObject({
+    action: zod
+        .string()
+        .max(listOperationLogsQueryActionMax)
+        .optional()
+        .describe("Return a single kind of operation; the value matches the operation id of the endpoint"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listOperationLogsQueryPageMax)
+        .default(listOperationLogsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listOperationLogsQueryPageSizeMax)
+        .default(listOperationLogsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Returns one entry of the project's operation log. Like the listing, it never discloses the individual operator of an operation performed by the platform.
+ * @summary Retrieve an operation log entry
+ */
+export const getOperationLogPathOperationLogIdMin = 39;
+export const getOperationLogPathOperationLogIdMax = 39;
+export const getOperationLogPathOperationLogIdRegExp = new RegExp("^operationlog_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetOperationLogParams = zod.strictObject({
+    operationLogId: zod
+        .string()
+        .min(getOperationLogPathOperationLogIdMin)
+        .max(getOperationLogPathOperationLogIdMax)
+        .regex(getOperationLogPathOperationLogIdRegExp)
+        .describe("Compute OperationLog TypeID. UUID text is not accepted."),
+});
+/**
+ * Lists the private images of this project, newest first, in every status: including while a capture is in progress and after it failed. Private images of other projects are never listed.
+ *
+ * A private image is usable only by the project that captured it from one of its instances. Its storage is metered by the hour on a subscription of the project.
+ *
+ * An image can only be used in the region that holds it. An image whose `min_memory_mib` exceeds the memory of the selected instance type cannot boot; filter the options accordingly. Public images are in `/public-images`.
+ * @summary List private images
+ */
+export const listPrivateImagesQueryRegionIdMin = 33;
+export const listPrivateImagesQueryRegionIdMax = 33;
+export const listPrivateImagesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listPrivateImagesQueryPageDefault = 1;
+export const listPrivateImagesQueryPageMax = 2147483647;
+export const listPrivateImagesQueryPageSizeDefault = 50;
+export const listPrivateImagesQueryPageSizeMax = 200;
+export const ListPrivateImagesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listPrivateImagesQueryRegionIdMin)
+        .max(listPrivateImagesQueryRegionIdMax)
+        .regex(listPrivateImagesQueryRegionIdRegExp)
+        .optional()
+        .describe("Return only the images of this region"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listPrivateImagesQueryPageMax)
+        .default(listPrivateImagesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listPrivateImagesQueryPageSizeMax)
+        .default(listPrivateImagesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Creates a project image from the instance boot volume, excluding data volumes. Stop the instance first for file-system consistency. The instance cannot be released while its source volume is being captured. Compute project quotas are enforced independently of billing.
+ *
+ * It is metered on a subscription of its own and takes no billing choice. Each second the image is stored is reported under its region and its `billing_position`: its place among the project's stored private images in the region, counted from the oldest, which moves up whenever an older one is deleted. Billing prices each position, and a position it prices at zero costs nothing; that is how a number of images in each region are free. The image's size does not change what it costs. It is bought through a Billing Checkout Session: automatic checkout completes at once for metered pricing and the image is captured as soon as the order is accepted; with deferred checkout it stays `pending` until the customer completes checkout in Billing. The source and project quotas are checked before the Checkout Session is created, and a refused request creates nothing.
+ *
+ * The image is `pending` from the moment its Checkout Session is created until it is delivered or its checkout or order ends. While its purchase awaits checkout or payment its deletion is refused with `COMPUTE_PURCHASE_PENDING`; once the capture runs, deletion is the one operation it accepts.
+ * @summary Capture an instance as a private image
+ */
+export const CreatePrivateImageBody = CreatePrivateImageRequestBody;
+/**
+ * Returns a private image of this project; any other image, public images included, is reported as not found. Use this endpoint to poll capture progress. When `status` is `failed`, `failure` describes the outcome.
+ * @summary Retrieve a private image
+ */
+export const getPrivateImagePathPrivateImageIdMin = 32;
+export const getPrivateImagePathPrivateImageIdMax = 32;
+export const getPrivateImagePathPrivateImageIdRegExp = new RegExp("^image_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetPrivateImageParams = zod.strictObject({
+    privateImageId: zod
+        .string()
+        .min(getPrivateImagePathPrivateImageIdMin)
+        .max(getPrivateImagePathPrivateImageIdMax)
+        .regex(getPrivateImagePathPrivateImageIdRegExp)
+        .describe("Compute Image TypeID. UUID text is not accepted."),
+});
+/**
+ * Renames a private image of this project. Any other image, public images included, is reported as not found.
+ * @summary Update a private image
+ */
+export const updatePrivateImagePathPrivateImageIdMin = 32;
+export const updatePrivateImagePathPrivateImageIdMax = 32;
+export const updatePrivateImagePathPrivateImageIdRegExp = new RegExp("^image_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdatePrivateImageParams = zod.strictObject({
+    privateImageId: zod
+        .string()
+        .min(updatePrivateImagePathPrivateImageIdMin)
+        .max(updatePrivateImagePathPrivateImageIdMax)
+        .regex(updatePrivateImagePathPrivateImageIdRegExp)
+        .describe("Compute Image TypeID. UUID text is not accepted."),
+});
+export const UpdatePrivateImageBody = UpdatePrivateImageRequestBody;
+/**
+ * Deletes a private image of this project; any other image, public images included, is reported as not found.
+ *
+ * Deletion is rejected while instances created from the image still exist, as they need it in order to be rebuilt.
+ *
+ * An image whose capture has not finished can be deleted; the capture is aborted. This is the one operation accepted while its status is `pending`.
+ *
+ * Quota capacity and storage metering are released only after cleanup is confirmed.
+ *
+ * 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 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;
+export const deletePrivateImagePathPrivateImageIdMax = 32;
+export const deletePrivateImagePathPrivateImageIdRegExp = new RegExp("^image_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeletePrivateImageParams = zod.strictObject({
+    privateImageId: zod
+        .string()
+        .min(deletePrivateImagePathPrivateImageIdMin)
+        .max(deletePrivateImagePathPrivateImageIdMax)
+        .regex(deletePrivateImagePathPrivateImageIdRegExp)
+        .describe("Compute Image TypeID. UUID text is not accepted."),
+});
+export const DeletePrivateImageQueryParams = zod.strictObject({
+    cancellation_mode: zod
+        .enum(["immediate", "period_end"])
+        .optional()
+        .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.
+ *
+ * An image can only be used in the region that holds it. An image whose `min_memory_mib` exceeds the memory of the selected instance type cannot boot; filter the options accordingly.
+ *
+ * Images this project captured from its own instances are in `/private-images`.
+ * @summary List public images
+ */
+export const listPublicImagesQueryRegionIdMin = 33;
+export const listPublicImagesQueryRegionIdMax = 33;
+export const listPublicImagesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listPublicImagesQueryPageDefault = 1;
+export const listPublicImagesQueryPageMax = 2147483647;
+export const listPublicImagesQueryPageSizeDefault = 50;
+export const listPublicImagesQueryPageSizeMax = 200;
+export const ListPublicImagesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listPublicImagesQueryRegionIdMin)
+        .max(listPublicImagesQueryRegionIdMax)
+        .regex(listPublicImagesQueryRegionIdRegExp)
+        .optional()
+        .describe("Return only the images of this region"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listPublicImagesQueryPageMax)
+        .default(listPublicImagesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listPublicImagesQueryPageSizeMax)
+        .default(listPublicImagesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Returns a public image, on sale or withdrawn. A withdrawn image (`sale_status` is `off_sale`) is still returned because instances may keep running it; it cannot be chosen for a new instance and can only be rebuilt onto by an instance that already runs it. A private image id is reported as not found here; use `/private-images`.
+ * @summary Retrieve a public image
+ */
+export const getPublicImagePathPublicImageIdMin = 32;
+export const getPublicImagePathPublicImageIdMax = 32;
+export const getPublicImagePathPublicImageIdRegExp = new RegExp("^image_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetPublicImageParams = zod.strictObject({
+    publicImageId: zod
+        .string()
+        .min(getPublicImagePathPublicImageIdMin)
+        .max(getPublicImagePathPublicImageIdMax)
+        .regex(getPublicImagePathPublicImageIdRegExp)
+        .describe("Compute Image TypeID. UUID text is not accepted."),
+});
+/**
+ * Reads only the IAM project authorized by the scoped token; callers cannot select another project. Returns every resource's limit for the project in the region through shared pagination, the platform default included where no limit was set. A quota is per region, since each region has its own capacity; what the project holds in one region never counts against another. An unknown region is refused with 404. No usage is returned.
+ * @summary List project quotas in a region
+ */
+export const listQuotasPathRegionIdMin = 33;
+export const listQuotasPathRegionIdMax = 33;
+export const listQuotasPathRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const ListQuotasParams = zod.strictObject({
+    regionId: zod
+        .string()
+        .min(listQuotasPathRegionIdMin)
+        .max(listQuotasPathRegionIdMax)
+        .regex(listQuotasPathRegionIdRegExp)
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+});
+export const listQuotasQueryPageDefault = 1;
+export const listQuotasQueryPageMax = 2147483647;
+export const listQuotasQueryPageSizeDefault = 50;
+export const listQuotasQueryPageSizeMax = 200;
+export const ListQuotasQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listQuotasQueryPageMax)
+        .default(listQuotasQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listQuotasQueryPageSizeMax)
+        .default(listQuotasQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Reads only the IAM project authorized by the scoped token; callers cannot select another project. Returns the limit in force, the platform default when no limit was set. Unknown resource values are rejected; an unknown region is refused with 404.
+ * @summary Get a project quota in a region
+ */
+export const getQuotaPathRegionIdMin = 33;
+export const getQuotaPathRegionIdMax = 33;
+export const getQuotaPathRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetQuotaParams = zod.strictObject({
+    regionId: zod
+        .string()
+        .min(getQuotaPathRegionIdMin)
+        .max(getQuotaPathRegionIdMax)
+        .regex(getQuotaPathRegionIdRegExp)
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+    resource: zod
+        .enum([
+        "instances",
+        "vcpus",
+        "memory_mib",
+        "volumes",
+        "volume_gib",
+        "virtual_private_clouds",
+        "virtual_private_cloud_subnets",
+        "network_interfaces",
+        "elastic_ips",
+        "security_groups",
+        "security_group_rules",
+        "volume_snapshots",
+        "volume_backups",
+        "private_images",
+    ])
+        .describe("The resource or capacity constrained by a project quota in a region. Platform defaults: instances=5; vcpus=16; memory_mib=32768; volumes=20; volume_gib=500; virtual_private_clouds=3; virtual_private_cloud_subnets=20; network_interfaces=20; elastic_ips=3; security_groups=10; security_group_rules=100; volume_snapshots=20; volume_backups=20; private_images=20. memory_mib is measured in MiB and volume_gib in GiB. A zero limit permits no additional capacity; it is not unlimited."),
+});
+/**
+ * @summary List available regions
+ */
+export const listRegionsQueryPageDefault = 1;
+export const listRegionsQueryPageMax = 2147483647;
+export const listRegionsQueryPageSizeDefault = 50;
+export const listRegionsQueryPageSizeMax = 200;
+export const ListRegionsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listRegionsQueryPageMax)
+        .default(listRegionsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listRegionsQueryPageSizeMax)
+        .default(listRegionsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * The availability zones of a region are listed by `list-availability-zones` with `region_id`.
+ * @summary Retrieve a region
+ */
+export const getRegionPathRegionIdMin = 33;
+export const getRegionPathRegionIdMax = 33;
+export const getRegionPathRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetRegionParams = zod.strictObject({
+    regionId: zod
+        .string()
+        .min(getRegionPathRegionIdMin)
+        .max(getRegionPathRegionIdMax)
+        .regex(getRegionPathRegionIdRegExp)
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+});
+/**
+ * The rules of the security group, or with `-` those of every security group of the project.
+ * @summary List security group rules
+ */
+export const listSecurityGroupRulesPathSecurityGroupIdRegExp = new RegExp("^(?:-|sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25})$");
+export const ListSecurityGroupRulesParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .regex(listSecurityGroupRulesPathSecurityGroupIdRegExp)
+        .describe("A security group identifier, or `-` to read across every security group of the project (AIP-159)."),
+});
+export const listSecurityGroupRulesQueryPageDefault = 1;
+export const listSecurityGroupRulesQueryPageMax = 2147483647;
+export const listSecurityGroupRulesQueryPageSizeDefault = 50;
+export const listSecurityGroupRulesQueryPageSizeMax = 200;
+export const ListSecurityGroupRulesQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listSecurityGroupRulesQueryPageMax)
+        .default(listSecurityGroupRulesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listSecurityGroupRulesQueryPageSizeMax)
+        .default(listSecurityGroupRulesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Refused when the group already has a rule meaning the same thing; `0.0.0.0/0`, `::/0` and an omitted remote prefix all mean every address. Rules cannot be changed; replace one by creating the new rule and deleting the old one.
+ * @summary Create a security group rule
+ */
+export const createSecurityGroupRulePathSecurityGroupIdMin = 29;
+export const createSecurityGroupRulePathSecurityGroupIdMax = 29;
+export const createSecurityGroupRulePathSecurityGroupIdRegExp = new RegExp("^sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const CreateSecurityGroupRuleParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .min(createSecurityGroupRulePathSecurityGroupIdMin)
+        .max(createSecurityGroupRulePathSecurityGroupIdMax)
+        .regex(createSecurityGroupRulePathSecurityGroupIdRegExp)
+        .describe("Compute SecurityGroup TypeID. UUID text is not accepted."),
+});
+export const CreateSecurityGroupRuleBody = CreateSecurityGroupRuleRequestBody;
+/**
+ * @summary Get a security group rule
+ */
+export const getSecurityGroupRulePathSecurityGroupIdMin = 29;
+export const getSecurityGroupRulePathSecurityGroupIdMax = 29;
+export const getSecurityGroupRulePathSecurityGroupIdRegExp = new RegExp("^sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const getSecurityGroupRulePathSecurityGroupRuleIdMin = 33;
+export const getSecurityGroupRulePathSecurityGroupRuleIdMax = 33;
+export const getSecurityGroupRulePathSecurityGroupRuleIdRegExp = new RegExp("^sgrule_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetSecurityGroupRuleParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .min(getSecurityGroupRulePathSecurityGroupIdMin)
+        .max(getSecurityGroupRulePathSecurityGroupIdMax)
+        .regex(getSecurityGroupRulePathSecurityGroupIdRegExp)
+        .describe("Compute SecurityGroup TypeID. UUID text is not accepted."),
+    securityGroupRuleId: zod
+        .string()
+        .min(getSecurityGroupRulePathSecurityGroupRuleIdMin)
+        .max(getSecurityGroupRulePathSecurityGroupRuleIdMax)
+        .regex(getSecurityGroupRulePathSecurityGroupRuleIdRegExp)
+        .describe("Compute SecurityGroupRule TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary Delete a security group rule
+ */
+export const deleteSecurityGroupRulePathSecurityGroupIdMin = 29;
+export const deleteSecurityGroupRulePathSecurityGroupIdMax = 29;
+export const deleteSecurityGroupRulePathSecurityGroupIdRegExp = new RegExp("^sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const deleteSecurityGroupRulePathSecurityGroupRuleIdMin = 33;
+export const deleteSecurityGroupRulePathSecurityGroupRuleIdMax = 33;
+export const deleteSecurityGroupRulePathSecurityGroupRuleIdRegExp = new RegExp("^sgrule_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteSecurityGroupRuleParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .min(deleteSecurityGroupRulePathSecurityGroupIdMin)
+        .max(deleteSecurityGroupRulePathSecurityGroupIdMax)
+        .regex(deleteSecurityGroupRulePathSecurityGroupIdRegExp)
+        .describe("Compute SecurityGroup TypeID. UUID text is not accepted."),
+    securityGroupRuleId: zod
+        .string()
+        .min(deleteSecurityGroupRulePathSecurityGroupRuleIdMin)
+        .max(deleteSecurityGroupRulePathSecurityGroupRuleIdMax)
+        .regex(deleteSecurityGroupRulePathSecurityGroupRuleIdRegExp)
+        .describe("Compute SecurityGroupRule TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary List security groups
+ */
+export const listSecurityGroupsQueryRegionIdMin = 33;
+export const listSecurityGroupsQueryRegionIdMax = 33;
+export const listSecurityGroupsQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listSecurityGroupsQueryVirtualPrivateCloudIdMin = 30;
+export const listSecurityGroupsQueryVirtualPrivateCloudIdMax = 30;
+export const listSecurityGroupsQueryVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listSecurityGroupsQueryPageDefault = 1;
+export const listSecurityGroupsQueryPageMax = 2147483647;
+export const listSecurityGroupsQueryPageSizeDefault = 50;
+export const listSecurityGroupsQueryPageSizeMax = 200;
+export const ListSecurityGroupsQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listSecurityGroupsQueryRegionIdMin)
+        .max(listSecurityGroupsQueryRegionIdMax)
+        .regex(listSecurityGroupsQueryRegionIdRegExp)
+        .optional()
+        .describe("Only security groups in this region."),
+    virtual_private_cloud_id: zod
+        .string()
+        .min(listSecurityGroupsQueryVirtualPrivateCloudIdMin)
+        .max(listSecurityGroupsQueryVirtualPrivateCloudIdMax)
+        .regex(listSecurityGroupsQueryVirtualPrivateCloudIdRegExp)
+        .optional()
+        .describe("Only security groups of this virtual private cloud."),
+    page: zod
+        .int()
+        .min(1)
+        .max(listSecurityGroupsQueryPageMax)
+        .default(listSecurityGroupsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listSecurityGroupsQueryPageSizeMax)
+        .default(listSecurityGroupsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * A new security group admits all outbound traffic and denies inbound traffic, except ICMP fragmentation-needed (IPv4) and Packet Too Big (IPv6). Without those two, path MTU discovery fails, which shows as connections that establish and then stall on large packets. All of these are ordinary rules and can be deleted.
+ * @summary Create a security group
+ */
+export const CreateSecurityGroupBody = CreateSecurityGroupRequestBody;
+/**
+ * @summary Get a security group
+ */
+export const getSecurityGroupPathSecurityGroupIdMin = 29;
+export const getSecurityGroupPathSecurityGroupIdMax = 29;
+export const getSecurityGroupPathSecurityGroupIdRegExp = new RegExp("^sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetSecurityGroupParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .min(getSecurityGroupPathSecurityGroupIdMin)
+        .max(getSecurityGroupPathSecurityGroupIdMax)
+        .regex(getSecurityGroupPathSecurityGroupIdRegExp)
+        .describe("Compute SecurityGroup TypeID. UUID text is not accepted."),
+});
+/**
+ * Changes the name or description. Rules are resources of their own, created and deleted under `/security-group-rules`.
+ * @summary Update a security group
+ */
+export const updateSecurityGroupPathSecurityGroupIdMin = 29;
+export const updateSecurityGroupPathSecurityGroupIdMax = 29;
+export const updateSecurityGroupPathSecurityGroupIdRegExp = new RegExp("^sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateSecurityGroupParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .min(updateSecurityGroupPathSecurityGroupIdMin)
+        .max(updateSecurityGroupPathSecurityGroupIdMax)
+        .regex(updateSecurityGroupPathSecurityGroupIdRegExp)
+        .describe("Compute SecurityGroup TypeID. UUID text is not accepted."),
+});
+export const UpdateSecurityGroupBody = UpdateSecurityGroupRequestBody;
+/**
+ * Refused while a network interface uses the group. The default security group cannot be deleted; it goes with its virtual private cloud.
+ * @summary Delete a security group
+ */
+export const deleteSecurityGroupPathSecurityGroupIdMin = 29;
+export const deleteSecurityGroupPathSecurityGroupIdMax = 29;
+export const deleteSecurityGroupPathSecurityGroupIdRegExp = new RegExp("^sg_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteSecurityGroupParams = zod.strictObject({
+    securityGroupId: zod
+        .string()
+        .min(deleteSecurityGroupPathSecurityGroupIdMin)
+        .max(deleteSecurityGroupPathSecurityGroupIdMax)
+        .regex(deleteSecurityGroupPathSecurityGroupIdRegExp)
+        .describe("Compute SecurityGroup TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary List peerings
+ */
+export const listVirtualPrivateCloudPeeringsQueryPageDefault = 1;
+export const listVirtualPrivateCloudPeeringsQueryPageMax = 2147483647;
+export const listVirtualPrivateCloudPeeringsQueryPageSizeDefault = 50;
+export const listVirtualPrivateCloudPeeringsQueryPageSizeMax = 200;
+export const ListVirtualPrivateCloudPeeringsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudPeeringsQueryPageMax)
+        .default(listVirtualPrivateCloudPeeringsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudPeeringsQueryPageSizeMax)
+        .default(listVirtualPrivateCloudPeeringsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * 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.
+ * @summary Create peering
+ */
+export const CreateVirtualPrivateCloudPeeringBody = CreateVirtualPrivateCloudPeeringRequestBody;
+/**
+ * @summary Get peering
+ */
+export const getVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin = 37;
+export const getVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax = 37;
+export const getVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp = new RegExp("^vpcpeering_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVirtualPrivateCloudPeeringParams = zod.strictObject({
+    virtualPrivateCloudPeeringId: zod
+        .string()
+        .min(getVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin)
+        .max(getVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax)
+        .regex(getVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp)
+        .describe("Compute VirtualPrivateCloudPeering TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary Delete peering
+ */
+export const deleteVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin = 37;
+export const deleteVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax = 37;
+export const deleteVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp = new RegExp("^vpcpeering_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVirtualPrivateCloudPeeringParams = zod.strictObject({
+    virtualPrivateCloudPeeringId: zod
+        .string()
+        .min(deleteVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin)
+        .max(deleteVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax)
+        .regex(deleteVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp)
+        .describe("Compute VirtualPrivateCloudPeering TypeID. UUID text is not accepted."),
+});
+/**
+ * Starts the provisioning of the connectivity; the peering is `provisioning` until it is `active`. It does not change security groups or provide transitive routing. Only the accepter project may decide; the requester project is refused, because a peering would otherwise be accepted by the party who asked for it. The decision is made once: a peering whose `acceptance` is no longer `pending` refuses both methods.
+ * @summary Accept a peering
+ */
+export const acceptVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin = 37;
+export const acceptVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax = 37;
+export const acceptVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp = new RegExp("^vpcpeering_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const AcceptVirtualPrivateCloudPeeringParams = zod.strictObject({
+    virtualPrivateCloudPeeringId: zod
+        .string()
+        .min(acceptVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin)
+        .max(acceptVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax)
+        .regex(acceptVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp)
+        .describe("Compute VirtualPrivateCloudPeering TypeID. UUID text is not accepted."),
+});
+/**
+ * Ends the peering with its `acceptance` `rejected` and its `status` `deleted`; no connectivity is ever created. Only the accepter project may decide; the requester project is refused, because a peering would otherwise be accepted by the party who asked for it. The decision is made once: a peering whose `acceptance` is no longer `pending` refuses both methods.
+ * @summary Reject a peering
+ */
+export const rejectVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin = 37;
+export const rejectVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax = 37;
+export const rejectVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp = new RegExp("^vpcpeering_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RejectVirtualPrivateCloudPeeringParams = zod.strictObject({
+    virtualPrivateCloudPeeringId: zod
+        .string()
+        .min(rejectVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMin)
+        .max(rejectVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdMax)
+        .regex(rejectVirtualPrivateCloudPeeringPathVirtualPrivateCloudPeeringIdRegExp)
+        .describe("Compute VirtualPrivateCloudPeering TypeID. UUID text is not accepted."),
+});
+/**
+ * Static routes of the virtual private cloud, or with `-` those of every virtual private cloud of the project, including the routes peerings write, which show `type` peering.
+ * @summary List routes
+ */
+export const listVirtualPrivateCloudRoutesPathVirtualPrivateCloudIdRegExp = new RegExp("^(?:-|vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25})$");
+export const ListVirtualPrivateCloudRoutesParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .regex(listVirtualPrivateCloudRoutesPathVirtualPrivateCloudIdRegExp)
+        .describe("A virtual private cloud identifier, or `-` to read across every virtual private cloud of the project (AIP-159)."),
+});
+export const listVirtualPrivateCloudRoutesQueryPageDefault = 1;
+export const listVirtualPrivateCloudRoutesQueryPageMax = 2147483647;
+export const listVirtualPrivateCloudRoutesQueryPageSizeDefault = 50;
+export const listVirtualPrivateCloudRoutesQueryPageSizeMax = 200;
+export const ListVirtualPrivateCloudRoutesQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudRoutesQueryPageMax)
+        .default(listVirtualPrivateCloudRoutesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudRoutesQueryPageSizeMax)
+        .default(listVirtualPrivateCloudRoutesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Three forms that would sever connectivity are refused: a destination of `0.0.0.0/0`, which overrides the default route and takes every elastic IP offline immediately; a destination equal to the CIDR of a subnet, which overrides its directly connected route; and a next hop equal to the gateway of a subnet, which points back at the router itself. A destination overlapping a peering's route is refused with `VIRTUAL_PRIVATE_CLOUD_ROUTE_OVERLAPS_PEERING`.
+ * @summary Create a static route
+ */
+export const createVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMin = 30;
+export const createVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMax = 30;
+export const createVirtualPrivateCloudRoutePathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const CreateVirtualPrivateCloudRouteParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(createVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMin)
+        .max(createVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMax)
+        .regex(createVirtualPrivateCloudRoutePathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const CreateVirtualPrivateCloudRouteBody = CreateVirtualPrivateCloudRouteRequestBody;
+/**
+ * @summary Get a route
+ */
+export const getVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMin = 30;
+export const getVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMax = 30;
+export const getVirtualPrivateCloudRoutePathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const getVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMin = 35;
+export const getVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMax = 35;
+export const getVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdRegExp = new RegExp("^vpcroute_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVirtualPrivateCloudRouteParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(getVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMin)
+        .max(getVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMax)
+        .regex(getVirtualPrivateCloudRoutePathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    virtualPrivateCloudRouteId: zod
+        .string()
+        .min(getVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMin)
+        .max(getVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMax)
+        .regex(getVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdRegExp)
+        .describe("Compute VirtualPrivateCloudRoute TypeID. UUID text is not accepted."),
+});
+/**
+ * A route has no update; replace it by creating the new route and deleting the old one. A peering's route is refused with `VIRTUAL_PRIVATE_CLOUD_ROUTE_HELD_BY_PEERING` and goes away with its peering.
+ * @summary Delete a static route
+ */
+export const deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMin = 30;
+export const deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMax = 30;
+export const deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMin = 35;
+export const deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMax = 35;
+export const deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdRegExp = new RegExp("^vpcroute_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVirtualPrivateCloudRouteParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMin)
+        .max(deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudIdMax)
+        .regex(deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    virtualPrivateCloudRouteId: zod
+        .string()
+        .min(deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMin)
+        .max(deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdMax)
+        .regex(deleteVirtualPrivateCloudRoutePathVirtualPrivateCloudRouteIdRegExp)
+        .describe("Compute VirtualPrivateCloudRoute TypeID. UUID text is not accepted."),
+});
+/**
+ * The subnets of the virtual private cloud, or with `-` those of every virtual private cloud of the project. A subnet is dual-stack once IPv6 is enabled on its virtual private cloud, which gives every subnet a /64 of the cloud's /56.
+ * @summary List subnets
+ */
+export const listVirtualPrivateCloudSubnetsPathVirtualPrivateCloudIdRegExp = new RegExp("^(?:-|vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25})$");
+export const ListVirtualPrivateCloudSubnetsParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .regex(listVirtualPrivateCloudSubnetsPathVirtualPrivateCloudIdRegExp)
+        .describe("A virtual private cloud identifier, or `-` to read across every virtual private cloud of the project (AIP-159)."),
+});
+export const listVirtualPrivateCloudSubnetsQueryPageDefault = 1;
+export const listVirtualPrivateCloudSubnetsQueryPageMax = 2147483647;
+export const listVirtualPrivateCloudSubnetsQueryPageSizeDefault = 50;
+export const listVirtualPrivateCloudSubnetsQueryPageSizeMax = 200;
+export const ListVirtualPrivateCloudSubnetsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudSubnetsQueryPageMax)
+        .default(listVirtualPrivateCloudSubnetsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudSubnetsQueryPageSizeMax)
+        .default(listVirtualPrivateCloudSubnetsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * The IPv4 CIDR must fall inside the virtual private cloud's CIDR and must not overlap another subnet of it; to find a free one, read the virtual private cloud's `free-subnet-cidr`. In a virtual private cloud with IPv6 enabled the subnet also takes the lowest free /64 of the cloud's /56, refused with 409 `VIRTUAL_PRIVATE_CLOUD_SUBNET_IPV6_CIDR_EXHAUSTED` when none is left.
+ * @summary Create a subnet
+ */
+export const createVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin = 30;
+export const createVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax = 30;
+export const createVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const CreateVirtualPrivateCloudSubnetParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(createVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin)
+        .max(createVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax)
+        .regex(createVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const CreateVirtualPrivateCloudSubnetBody = CreateVirtualPrivateCloudSubnetRequestBody;
+/**
+ * @summary Get a subnet
+ */
+export const getVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin = 30;
+export const getVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax = 30;
+export const getVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const getVirtualPrivateCloudSubnetPathSubnetIdMin = 33;
+export const getVirtualPrivateCloudSubnetPathSubnetIdMax = 33;
+export const getVirtualPrivateCloudSubnetPathSubnetIdRegExp = new RegExp("^subnet_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVirtualPrivateCloudSubnetParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(getVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin)
+        .max(getVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax)
+        .regex(getVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    subnetId: zod
+        .string()
+        .min(getVirtualPrivateCloudSubnetPathSubnetIdMin)
+        .max(getVirtualPrivateCloudSubnetPathSubnetIdMax)
+        .regex(getVirtualPrivateCloudSubnetPathSubnetIdRegExp)
+        .describe("Compute Subnet TypeID. UUID text is not accepted."),
+});
+/**
+ * Only the name can change. The CIDR is fixed for the subnet's life, because addresses already handed out inside it would fall outside a changed range.
+ * @summary Update a subnet
+ */
+export const updateVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin = 30;
+export const updateVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax = 30;
+export const updateVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const updateVirtualPrivateCloudSubnetPathSubnetIdMin = 33;
+export const updateVirtualPrivateCloudSubnetPathSubnetIdMax = 33;
+export const updateVirtualPrivateCloudSubnetPathSubnetIdRegExp = new RegExp("^subnet_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateVirtualPrivateCloudSubnetParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(updateVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin)
+        .max(updateVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax)
+        .regex(updateVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    subnetId: zod
+        .string()
+        .min(updateVirtualPrivateCloudSubnetPathSubnetIdMin)
+        .max(updateVirtualPrivateCloudSubnetPathSubnetIdMax)
+        .regex(updateVirtualPrivateCloudSubnetPathSubnetIdRegExp)
+        .describe("Compute Subnet TypeID. UUID text is not accepted."),
+});
+export const UpdateVirtualPrivateCloudSubnetBody = UpdateVirtualPrivateCloudSubnetRequestBody;
+/**
+ * Refused while network interfaces remain in the subnet, or while a static route has a next hop inside its CIDR. Its /64 goes back to the virtual private cloud's /56.
+ * @summary Delete a subnet
+ */
+export const deleteVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin = 30;
+export const deleteVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax = 30;
+export const deleteVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const deleteVirtualPrivateCloudSubnetPathSubnetIdMin = 33;
+export const deleteVirtualPrivateCloudSubnetPathSubnetIdMax = 33;
+export const deleteVirtualPrivateCloudSubnetPathSubnetIdRegExp = new RegExp("^subnet_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVirtualPrivateCloudSubnetParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(deleteVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMin)
+        .max(deleteVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdMax)
+        .regex(deleteVirtualPrivateCloudSubnetPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+    subnetId: zod
+        .string()
+        .min(deleteVirtualPrivateCloudSubnetPathSubnetIdMin)
+        .max(deleteVirtualPrivateCloudSubnetPathSubnetIdMax)
+        .regex(deleteVirtualPrivateCloudSubnetPathSubnetIdRegExp)
+        .describe("Compute Subnet TypeID. UUID text is not accepted."),
+});
+/**
+ * @summary List virtual private clouds
+ */
+export const listVirtualPrivateCloudsQueryRegionIdMin = 33;
+export const listVirtualPrivateCloudsQueryRegionIdMax = 33;
+export const listVirtualPrivateCloudsQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVirtualPrivateCloudsQueryPageDefault = 1;
+export const listVirtualPrivateCloudsQueryPageMax = 2147483647;
+export const listVirtualPrivateCloudsQueryPageSizeDefault = 50;
+export const listVirtualPrivateCloudsQueryPageSizeMax = 200;
+export const ListVirtualPrivateCloudsQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listVirtualPrivateCloudsQueryRegionIdMin)
+        .max(listVirtualPrivateCloudsQueryRegionIdMax)
+        .regex(listVirtualPrivateCloudsQueryRegionIdRegExp)
+        .optional()
+        .describe("Returns every region when omitted"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudsQueryPageMax)
+        .default(listVirtualPrivateCloudsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVirtualPrivateCloudsQueryPageSizeMax)
+        .default(listVirtualPrivateCloudsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Creates a virtual private cloud definition and its default security group. The default security group denies all inbound traffic and permits all outbound traffic.
+ * @summary Create a virtual private cloud
+ */
+export const CreateVirtualPrivateCloudBody = CreateVirtualPrivateCloudRequestBody;
+/**
+ * @summary Retrieve a virtual private cloud
+ */
+export const getVirtualPrivateCloudPathVirtualPrivateCloudIdMin = 30;
+export const getVirtualPrivateCloudPathVirtualPrivateCloudIdMax = 30;
+export const getVirtualPrivateCloudPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVirtualPrivateCloudParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(getVirtualPrivateCloudPathVirtualPrivateCloudIdMin)
+        .max(getVirtualPrivateCloudPathVirtualPrivateCloudIdMax)
+        .regex(getVirtualPrivateCloudPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Only the name can change. The CIDR is fixed for the network's life, because every subnet and address inside it was allocated from it.
+ * @summary Update a virtual private cloud
+ */
+export const updateVirtualPrivateCloudPathVirtualPrivateCloudIdMin = 30;
+export const updateVirtualPrivateCloudPathVirtualPrivateCloudIdMax = 30;
+export const updateVirtualPrivateCloudPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateVirtualPrivateCloudParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(updateVirtualPrivateCloudPathVirtualPrivateCloudIdMin)
+        .max(updateVirtualPrivateCloudPathVirtualPrivateCloudIdMax)
+        .regex(updateVirtualPrivateCloudPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const UpdateVirtualPrivateCloudBody = UpdateVirtualPrivateCloudRequestBody;
+/**
+ * Deletion is rejected while instances or network interfaces remain in the network. Its subnets, routes, security groups and IPv6 configuration are removed with it.
+ * @summary Release a virtual private cloud
+ */
+export const deleteVirtualPrivateCloudPathVirtualPrivateCloudIdMin = 30;
+export const deleteVirtualPrivateCloudPathVirtualPrivateCloudIdMax = 30;
+export const deleteVirtualPrivateCloudPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVirtualPrivateCloudParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(deleteVirtualPrivateCloudPathVirtualPrivateCloudIdMin)
+        .max(deleteVirtualPrivateCloudPathVirtualPrivateCloudIdMax)
+        .regex(deleteVirtualPrivateCloudPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Gives the virtual private cloud a /56 that is routed to it, and every subnet of it a /64 of that /56; a subnet created afterwards takes its /64 at creation. It requires no elastic IP or NAT gateway: IPv6 is routed, not translated. A network interface created afterwards receives an address of its subnet's /64; addresses cannot be requested or released individually, and security groups apply to them as to IPv4. An interface created before IPv6 was enabled keeps only its IPv4 address.
+ *
+ * Enabling IPv6 that is already enabled answers with the virtual private cloud as it is.
+ * @summary Enable IPv6 on a virtual private cloud
+ */
+export const enableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMin = 30;
+export const enableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMax = 30;
+export const enableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const EnableVirtualPrivateCloudIpv6Params = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(enableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMin)
+        .max(enableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMax)
+        .regex(enableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * Removes the IPv6 of every subnet and gives the /56 back. Refused while a network interface remains in the virtual private cloud, since its IPv6 address would stop working with nothing reporting it.
+ * @summary Disable IPv6 on a virtual private cloud
+ */
+export const disableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMin = 30;
+export const disableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMax = 30;
+export const disableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DisableVirtualPrivateCloudIpv6Params = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(disableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMin)
+        .max(disableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdMax)
+        .regex(disableVirtualPrivateCloudIpv6PathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+/**
+ * The first CIDR of the given prefix length inside the virtual private cloud that no subnet overlaps. It is not reserved; creating the subnet checks it again.
+ * @summary Get a free subnet CIDR
+ */
+export const getVirtualPrivateCloudFreeSubnetCidrPathVirtualPrivateCloudIdMin = 30;
+export const getVirtualPrivateCloudFreeSubnetCidrPathVirtualPrivateCloudIdMax = 30;
+export const getVirtualPrivateCloudFreeSubnetCidrPathVirtualPrivateCloudIdRegExp = new RegExp("^vpc_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVirtualPrivateCloudFreeSubnetCidrParams = zod.strictObject({
+    virtualPrivateCloudId: zod
+        .string()
+        .min(getVirtualPrivateCloudFreeSubnetCidrPathVirtualPrivateCloudIdMin)
+        .max(getVirtualPrivateCloudFreeSubnetCidrPathVirtualPrivateCloudIdMax)
+        .regex(getVirtualPrivateCloudFreeSubnetCidrPathVirtualPrivateCloudIdRegExp)
+        .describe("The public vpc resource identifier. Only this fixed TypeID prefix is accepted; UUID text is not an alternative representation."),
+});
+export const getVirtualPrivateCloudFreeSubnetCidrQueryPrefixLengthDefault = 24;
+export const getVirtualPrivateCloudFreeSubnetCidrQueryPrefixLengthMin = 16;
+export const getVirtualPrivateCloudFreeSubnetCidrQueryPrefixLengthMax = 30;
+export const GetVirtualPrivateCloudFreeSubnetCidrQueryParams = zod.strictObject({
+    prefix_length: zod
+        .int()
+        .min(getVirtualPrivateCloudFreeSubnetCidrQueryPrefixLengthMin)
+        .max(getVirtualPrivateCloudFreeSubnetCidrQueryPrefixLengthMax)
+        .default(getVirtualPrivateCloudFreeSubnetCidrQueryPrefixLengthDefault),
+});
+/**
+ * @summary List volume backups
+ */
+export const listVolumeBackupsQueryVolumeIdMin = 30;
+export const listVolumeBackupsQueryVolumeIdMax = 30;
+export const listVolumeBackupsQueryVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVolumeBackupsQueryPageDefault = 1;
+export const listVolumeBackupsQueryPageMax = 2147483647;
+export const listVolumeBackupsQueryPageSizeDefault = 50;
+export const listVolumeBackupsQueryPageSizeMax = 200;
+export const ListVolumeBackupsQueryParams = zod.strictObject({
+    volume_id: zod
+        .string()
+        .min(listVolumeBackupsQueryVolumeIdMin)
+        .max(listVolumeBackupsQueryVolumeIdMax)
+        .regex(listVolumeBackupsQueryVolumeIdRegExp)
+        .optional()
+        .describe("Return only the backups of this volume"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listVolumeBackupsQueryPageMax)
+        .default(listVolumeBackupsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVolumeBackupsQueryPageSizeMax)
+        .default(listVolumeBackupsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Creates a backup of the volume. It remains restorable after the source volume is deleted and may be restored to another availability zone in the same region, by creating a volume with `volume_backup_id` (`create-volume`). A running instance may produce a file-system-inconsistent backup. Pending backups count toward Compute project quotas until cleanup is confirmed.
+ *
+ * It is metered by the hour on a subscription of its own and takes no billing choice. It is bought through a Billing Checkout Session: automatic checkout completes at once for metered pricing and the backup is taken as soon as the order is accepted; with deferred checkout it stays `pending` until the customer completes checkout in Billing. The source and project quotas are checked before the Checkout Session is created, and a refused request creates nothing.
+ *
+ * The backup 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 backup
+ */
+export const CreateVolumeBackupBody = CreateVolumeBackupRequestBody;
+/**
+ * Returns the stored state of the backup; it does not query the cloud. Use it to poll creation progress.
+ * @summary Retrieve a volume backup
+ */
+export const getVolumeBackupPathVolumeBackupIdMin = 36;
+export const getVolumeBackupPathVolumeBackupIdMax = 36;
+export const getVolumeBackupPathVolumeBackupIdRegExp = new RegExp("^volbackup_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVolumeBackupParams = zod.strictObject({
+    volumeBackupId: zod
+        .string()
+        .min(getVolumeBackupPathVolumeBackupIdMin)
+        .max(getVolumeBackupPathVolumeBackupIdMax)
+        .regex(getVolumeBackupPathVolumeBackupIdRegExp)
+        .describe("Compute VolumeBackup TypeID. UUID text is not accepted."),
+});
+/**
+ * Changes the name only. A backup's source volume and capacity cannot be changed.
+ * @summary Update a volume backup
+ */
+export const updateVolumeBackupPathVolumeBackupIdMin = 36;
+export const updateVolumeBackupPathVolumeBackupIdMax = 36;
+export const updateVolumeBackupPathVolumeBackupIdRegExp = new RegExp("^volbackup_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateVolumeBackupParams = zod.strictObject({
+    volumeBackupId: zod
+        .string()
+        .min(updateVolumeBackupPathVolumeBackupIdMin)
+        .max(updateVolumeBackupPathVolumeBackupIdMax)
+        .regex(updateVolumeBackupPathVolumeBackupIdRegExp)
+        .describe("Compute VolumeBackup TypeID. UUID text is not accepted."),
+});
+export const UpdateVolumeBackupBody = UpdateVolumeBackupRequestBody;
+/**
+ * Independent of the source volume: deletion succeeds whether or not that volume still exists. Metering of the backup ends once it is deleted.
+ *
+ * Quota capacity and storage metering are released only after cleanup is confirmed.
+ *
+ * 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 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;
+export const deleteVolumeBackupPathVolumeBackupIdMax = 36;
+export const deleteVolumeBackupPathVolumeBackupIdRegExp = new RegExp("^volbackup_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVolumeBackupParams = zod.strictObject({
+    volumeBackupId: zod
+        .string()
+        .min(deleteVolumeBackupPathVolumeBackupIdMin)
+        .max(deleteVolumeBackupPathVolumeBackupIdMax)
+        .regex(deleteVolumeBackupPathVolumeBackupIdRegExp)
+        .describe("Compute VolumeBackup TypeID. UUID text is not accepted."),
+});
+export const DeleteVolumeBackupQueryParams = zod.strictObject({
+    cancellation_mode: zod
+        .enum(["immediate", "period_end"])
+        .optional()
+        .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
+ */
+export const listVolumeSnapshotsQueryVolumeIdMin = 30;
+export const listVolumeSnapshotsQueryVolumeIdMax = 30;
+export const listVolumeSnapshotsQueryVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVolumeSnapshotsQueryPageDefault = 1;
+export const listVolumeSnapshotsQueryPageMax = 2147483647;
+export const listVolumeSnapshotsQueryPageSizeDefault = 50;
+export const listVolumeSnapshotsQueryPageSizeMax = 200;
+export const ListVolumeSnapshotsQueryParams = zod.strictObject({
+    volume_id: zod
+        .string()
+        .min(listVolumeSnapshotsQueryVolumeIdMin)
+        .max(listVolumeSnapshotsQueryVolumeIdMax)
+        .regex(listVolumeSnapshotsQueryVolumeIdRegExp)
+        .optional()
+        .describe("Return only the snapshots of this volume"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listVolumeSnapshotsQueryPageMax)
+        .default(listVolumeSnapshotsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVolumeSnapshotsQueryPageSizeMax)
+        .default(listVolumeSnapshotsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Creates a snapshot of the volume. A running instance may produce a file-system-inconsistent snapshot; flush pending writes first. A boot volume cannot be reverted while attached. Pending snapshots count toward Compute project quotas until creation fails and cleanup is confirmed.
+ *
+ * It is metered by the hour on a subscription of its own and takes no billing choice. It is bought through a Billing Checkout Session: automatic checkout completes at once for metered pricing and the snapshot is taken as soon as the order is accepted; with deferred checkout it stays `pending` until the customer completes checkout in Billing. The source and project quotas are checked before the Checkout Session is created, and a refused request creates nothing.
+ *
+ * The snapshot 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 snapshot
+ */
+export const CreateVolumeSnapshotBody = CreateVolumeSnapshotRequestBody;
+/**
+ * @summary Retrieve a snapshot
+ */
+export const getVolumeSnapshotPathVolumeSnapshotIdMin = 38;
+export const getVolumeSnapshotPathVolumeSnapshotIdMax = 38;
+export const getVolumeSnapshotPathVolumeSnapshotIdRegExp = new RegExp("^volsnapshot_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVolumeSnapshotParams = zod.strictObject({
+    volumeSnapshotId: zod
+        .string()
+        .min(getVolumeSnapshotPathVolumeSnapshotIdMin)
+        .max(getVolumeSnapshotPathVolumeSnapshotIdMax)
+        .regex(getVolumeSnapshotPathVolumeSnapshotIdRegExp)
+        .describe("Compute VolumeSnapshot TypeID. UUID text is not accepted."),
+});
+/**
+ * Changes the name only. A snapshot's source volume and capacity cannot be changed.
+ * @summary Update a snapshot
+ */
+export const updateVolumeSnapshotPathVolumeSnapshotIdMin = 38;
+export const updateVolumeSnapshotPathVolumeSnapshotIdMax = 38;
+export const updateVolumeSnapshotPathVolumeSnapshotIdRegExp = new RegExp("^volsnapshot_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateVolumeSnapshotParams = zod.strictObject({
+    volumeSnapshotId: zod
+        .string()
+        .min(updateVolumeSnapshotPathVolumeSnapshotIdMin)
+        .max(updateVolumeSnapshotPathVolumeSnapshotIdMax)
+        .regex(updateVolumeSnapshotPathVolumeSnapshotIdRegExp)
+        .describe("Compute VolumeSnapshot TypeID. UUID text is not accepted."),
+});
+export const UpdateVolumeSnapshotBody = UpdateVolumeSnapshotRequestBody;
+/**
+ * Deletes this resource. Quota capacity and storage metering are released only after cleanup is confirmed.
+ *
+ * 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 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;
+export const deleteVolumeSnapshotPathVolumeSnapshotIdMax = 38;
+export const deleteVolumeSnapshotPathVolumeSnapshotIdRegExp = new RegExp("^volsnapshot_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVolumeSnapshotParams = zod.strictObject({
+    volumeSnapshotId: zod
+        .string()
+        .min(deleteVolumeSnapshotPathVolumeSnapshotIdMin)
+        .max(deleteVolumeSnapshotPathVolumeSnapshotIdMax)
+        .regex(deleteVolumeSnapshotPathVolumeSnapshotIdRegExp)
+        .describe("Compute VolumeSnapshot TypeID. UUID text is not accepted."),
+});
+export const DeleteVolumeSnapshotQueryParams = zod.strictObject({
+    cancellation_mode: zod
+        .enum(["immediate", "period_end"])
+        .optional()
+        .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.
+ * @summary List volume types on sale
+ */
+export const listVolumeTypesQueryRegionIdMin = 33;
+export const listVolumeTypesQueryRegionIdMax = 33;
+export const listVolumeTypesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVolumeTypesQueryAvailabilityZoneIdMin = 31;
+export const listVolumeTypesQueryAvailabilityZoneIdMax = 31;
+export const listVolumeTypesQueryAvailabilityZoneIdRegExp = new RegExp("^zone_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVolumeTypesQueryPageDefault = 1;
+export const listVolumeTypesQueryPageMax = 2147483647;
+export const listVolumeTypesQueryPageSizeDefault = 50;
+export const listVolumeTypesQueryPageSizeMax = 200;
+export const ListVolumeTypesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listVolumeTypesQueryRegionIdMin)
+        .max(listVolumeTypesQueryRegionIdMax)
+        .regex(listVolumeTypesQueryRegionIdRegExp)
+        .optional()
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+    availability_zone_id: zod
+        .string()
+        .min(listVolumeTypesQueryAvailabilityZoneIdMin)
+        .max(listVolumeTypesQueryAvailabilityZoneIdMax)
+        .regex(listVolumeTypesQueryAvailabilityZoneIdRegExp)
+        .optional()
+        .describe("Return only the types of this availability zone, sold out or not."),
+    page: zod
+        .int()
+        .min(1)
+        .max(listVolumeTypesQueryPageMax)
+        .default(listVolumeTypesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVolumeTypesQueryPageSizeMax)
+        .default(listVolumeTypesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * Retrieve capacity and performance constraints for an existing volume, including types withdrawn from sale.
+ * @summary Get a volume type
+ */
+export const getVolumeTypePathVolumeTypeIdMin = 34;
+export const getVolumeTypePathVolumeTypeIdMax = 34;
+export const getVolumeTypePathVolumeTypeIdRegExp = new RegExp("^voltype_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVolumeTypeParams = zod.strictObject({
+    volumeTypeId: zod
+        .string()
+        .min(getVolumeTypePathVolumeTypeIdMin)
+        .max(getVolumeTypePathVolumeTypeIdMax)
+        .regex(getVolumeTypePathVolumeTypeIdRegExp)
+        .describe("Compute VolumeType TypeID. UUID text is not accepted."),
+});
+/**
+ * When both `region_id` and `availability_zone_id` are supplied, only volumes attachable to an instance at that location are returned.
+ * @summary List volumes
+ */
+export const listVolumesQueryRegionIdMin = 33;
+export const listVolumesQueryRegionIdMax = 33;
+export const listVolumesQueryRegionIdRegExp = new RegExp("^region_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVolumesQueryAvailabilityZoneIdMin = 31;
+export const listVolumesQueryAvailabilityZoneIdMax = 31;
+export const listVolumesQueryAvailabilityZoneIdRegExp = new RegExp("^zone_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const listVolumesQueryPageDefault = 1;
+export const listVolumesQueryPageMax = 2147483647;
+export const listVolumesQueryPageSizeDefault = 50;
+export const listVolumesQueryPageSizeMax = 200;
+export const ListVolumesQueryParams = zod.strictObject({
+    region_id: zod
+        .string()
+        .min(listVolumesQueryRegionIdMin)
+        .max(listVolumesQueryRegionIdMax)
+        .regex(listVolumesQueryRegionIdRegExp)
+        .optional()
+        .describe("Compute Region TypeID. UUID text is not accepted."),
+    availability_zone_id: zod
+        .string()
+        .min(listVolumesQueryAvailabilityZoneIdMin)
+        .max(listVolumesQueryAvailabilityZoneIdMax)
+        .regex(listVolumesQueryAvailabilityZoneIdRegExp)
+        .optional()
+        .describe("Supplied together with `region_id` to filter attachable volumes"),
+    page: zod
+        .int()
+        .min(1)
+        .max(listVolumesQueryPageMax)
+        .default(listVolumesQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listVolumesQueryPageSizeMax)
+        .default(listVolumesQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * The volume is created in the availability zone of its volume type, and only an instance in the same zone can attach it.
+ *
+ * The type has to have room for it, checked before anything is ordered: refused with 409 `VOLUME_TYPE_SOLD_OUT` when the type takes no new volumes for now, `VOLUME_TYPE_CAPACITY_REACHED` when what is sold of it is used up, and `VOLUME_TYPE_NO_POOL_ROOM` when the storage of its zone cannot take the volume. Two orders placed at the same moment can both pass; the one that finds the type full when its order is accepted is not created and is refunded, ending `failed` with `provisioning_failed`.
+ *
+ * The volume is empty, or is restored from exactly one source: `volume_snapshot_id` or `volume_backup_id`. Giving both is refused with 422 `VOLUME_SOURCE_CONFLICT`. A restore is a purchase of a **new** volume; the source volume is unaffected and need not still exist.
+ *
+ * - **From a snapshot**, the volume type has to be of the snapshot's availability zone (422 `VOLUME_SNAPSHOT_OTHER_AVAILABILITY_ZONE`), because a snapshot lives in the same storage pool as its source and restores only into its own zone. `size_gib` is required and must be no smaller than the snapshot.
+ * - **From a volume backup**, the volume type may be of any zone of the backup's region, because a backup is an independent copy in different storage. `size_gib` matches the size of the backup when omitted, and when given it must not be smaller than the backup. The volume cannot be attached until it is `available`.
+ *
+ * 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, 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
+ */
+export const CreateVolumeBody = CreateVolumeRequestBody;
+/**
+ * Returns the stored state of the volume; it does not query the cloud.
+ * @summary Retrieve a volume
+ */
+export const getVolumePathVolumeIdMin = 30;
+export const getVolumePathVolumeIdMax = 30;
+export const getVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const GetVolumeParams = zod.strictObject({
+    volumeId: zod
+        .string()
+        .min(getVolumePathVolumeIdMin)
+        .max(getVolumePathVolumeIdMax)
+        .regex(getVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
+});
+/**
+ * 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;
+export const updateVolumePathVolumeIdMax = 30;
+export const updateVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const UpdateVolumeParams = zod.strictObject({
+    volumeId: zod
+        .string()
+        .min(updateVolumePathVolumeIdMin)
+        .max(updateVolumePathVolumeIdMax)
+        .regex(updateVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
+});
+export const UpdateVolumeBody = UpdateVolumeRequestBody;
+/**
+ * Deletion is rejected while the volume is attached, or while snapshots created from it still exist.
+ *
+ * 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 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;
+export const deleteVolumePathVolumeIdMax = 30;
+export const deleteVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const DeleteVolumeParams = zod.strictObject({
+    volumeId: zod
+        .string()
+        .min(deleteVolumePathVolumeIdMin)
+        .max(deleteVolumePathVolumeIdMax)
+        .regex(deleteVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
+});
+export const DeleteVolumeQueryParams = zod.strictObject({
+    cancellation_mode: zod
+        .enum(["immediate", "period_end"])
+        .optional()
+        .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.**
+ *
+ * Three restrictions apply: only the most recent snapshot of the volume can be reverted to; the volume must be detached from its instance first; and a volume resized since the snapshot was taken cannot be reverted. To return to an earlier point in time, or to keep the existing volume, create a new volume from the snapshot instead.
+ *
+ * The revert is a request of its own rather than a state of the volume: the response is the volume, which is `reverting` until the revert is complete.
+ * @summary Revert a volume to a snapshot
+ */
+export const revertVolumePathVolumeIdMin = 30;
+export const revertVolumePathVolumeIdMax = 30;
+export const revertVolumePathVolumeIdRegExp = new RegExp("^vol_[0-7][0123456789abcdefghjkmnpqrstvwxyz]{25}$");
+export const RevertVolumeParams = zod.strictObject({
+    volumeId: zod
+        .string()
+        .min(revertVolumePathVolumeIdMin)
+        .max(revertVolumePathVolumeIdMax)
+        .regex(revertVolumePathVolumeIdRegExp)
+        .describe("Compute Volume TypeID. UUID text is not accepted."),
+});
+export const RevertVolumeBody = RevertVolumeRequestBody;