@leaflow/sdk 0.0.0-dev.39.gc9098a0 → 0.0.0-dev.391.g0aed14e

package/dist/compute/v1/generated/models.d.ts

@@ -0,0 +1,2738 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Compute API
+ * Leaflow Compute user API for managing instances, disks, snapshots, backups, images, private networks, subnets, routes, security groups, network interfaces and floating IPs.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `scopedTokenAuth` security scheme.
+ *
+ * ## 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, a resource becomes `provisioning` and then reaches its usual status, such as `active` 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. Read the Checkout Session and the order in Billing for checkout and payment progress.
+ * - **Commercial terms.** Compute returns no amounts. Catalog items, such as instance types, disk types and public IP pools, and the region's own products carry `billing`: the Billing plan an order line for them is sold under, the dimensions the line carries, how its quantity is counted for each usage type, and the meters its metered price reads. Read their prices from Billing with `search-prices` and `search-rates`, quote a purchase or a change with Billing's `get-quote` using the same lines, and estimate metered usage with Billing's `estimate-usage`. A purchase chooses its terms with `billing`, which applies to all of its components.
+ * - **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.
+ * - **Operations.** Requests such as starting, stopping, attaching or deleting return HTTP 202 with the resource as it is when the request is accepted. While an operation runs, the resource's `operation` field names it; the field is null once the operation has finished, and the resource then shows 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 disk, 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.
+ * - **Billing relationships.** A purchased resource records its `checkout_session_id` and, once checkout completes, its `order_id`, `order_item_id` and `subscription_id`. The subscription is `pending` until the order is accepted, `provisioning` while the resource is created, and `active` once it is delivered. Bandwidth is a property of its floating IP, not a separate resource. Snapshots use a purchased per-region count quota, and backups are metered on the region's backup service; neither has an order or subscription of its own.
+ * - **Availability zones.** A disk and an instance must reside in the same availability zone to be attached. Instance types and disk types are each bound to one availability zone, so choosing a type determines the zone.
+ * - **IPv6 is not sold separately.** Once enabled on a private network, IPv6 addresses are assigned to the instances in that network automatically; they can be neither requested nor released individually.
+ * - **Floating IPs have a cooldown period.** A released address is neither available for re-allocation nor handed to another user for some time, so that DNS records and allow-lists still pointing at it do not break immediately.
+ * - **Passwords are returned once.** A password generated by the platform during creation or rebuild appears only in that response. Store it immediately.
+ * OpenAPI spec version: 1.0.0
+ */
+export type PeeringResourceStatus = (typeof PeeringResourceStatus)[keyof typeof PeeringResourceStatus];
+export declare const PeeringResourceStatus: {
+    readonly pending_acceptance: "pending_acceptance";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly deleted: "deleted";
+    readonly rejected: "rejected";
+    readonly error: "error";
+};
+/**
+ * `provision` runs after the peering is accepted, until it is `active`.
+ */
+export type PeeringOperationType = (typeof PeeringOperationType)[keyof typeof PeeringOperationType];
+export declare const PeeringOperationType: {
+    readonly provision: "provision";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this peering. It is not a separate resource; once it finishes, the peering's `operation` is null again and the peering shows the result.
+ */
+export interface PeeringOperation {
+    /** `provision` runs after the peering is accepted, until it is `active`. */
+    type: PeeringOperationType;
+    started_at: string;
+}
+export interface PeeringResource {
+    id: string;
+    name: string;
+    region_id: string;
+    requester_project_id: string;
+    accepter_project_id: string;
+    requester_network_id: string;
+    accepter_network_id: string;
+    status: PeeringResourceStatus;
+    created_at: string;
+    failure_code?: string;
+    /** The operation in progress on this peering, or null when none is. */
+    readonly operation: PeeringOperation | null;
+}
+/**
+ * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
+ */
+export interface OffsetPagination {
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+    /** @minimum 0 */
+    total_count?: number;
+}
+export interface PeeringListResponseBody {
+    items: PeeringResource[];
+    pagination: OffsetPagination;
+}
+export interface CreatePeeringRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    requester_network_id: string;
+    accepter_project_id: string;
+    accepter_network_id: string;
+}
+/**
+ * The dimension values the order line carries.
+ */
+export type BillingComponentDimensions = {
+    [key: string]: string;
+};
+/**
+ * `one`: one per item. `size_gib`: the size or capacity bought, in GiB. `bandwidth_mbps`: the bandwidth bought, in Mbps. `snapshots`: the number of snapshots the quota allows.
+ */
+export type BillingQuantity = (typeof BillingQuantity)[keyof typeof BillingQuantity];
+export declare const BillingQuantity: {
+    readonly one: "one";
+    readonly size_gib: "size_gib";
+    readonly bandwidth_mbps: "bandwidth_mbps";
+    readonly snapshots: "snapshots";
+};
+/**
+ * What the order line's quantity counts, for each usage type the item is sold under. A usage type that is absent is not sold for this item.
+ */
+export type BillingComponentQuantity = {
+    licensed?: BillingQuantity;
+    metered?: BillingQuantity;
+};
+/**
+ * What the meter's quantity measures while the item exists: `one` is one item, `size_gib` its size in GiB, `bandwidth_mbps` its bandwidth in Mbps, `stored_gib` the GiB it stores.
+ */
+export type BillingMeterQuantity = (typeof BillingMeterQuantity)[keyof typeof BillingMeterQuantity];
+export declare const BillingMeterQuantity: {
+    readonly one: "one";
+    readonly size_gib: "size_gib";
+    readonly bandwidth_mbps: "bandwidth_mbps";
+    readonly stored_gib: "stored_gib";
+};
+/**
+ * The dimension values the meter's usage carries, when they differ from the line's.
+ */
+export type BillingMeterDimensions = {
+    [key: string]: string;
+};
+export interface BillingMeter {
+    meter_lookup_key: string;
+    /** What the meter's quantity measures while the item exists: `one` is one item, `size_gib` its size in GiB, `bandwidth_mbps` its bandwidth in Mbps, `stored_gib` the GiB it stores. */
+    quantity: BillingMeterQuantity;
+    /** The dimension values the meter's usage carries, when they differ from the line's. */
+    dimensions?: BillingMeterDimensions;
+}
+/**
+ * How one order line of an item is sold in Billing. Give `plan_id` to Billing's `search-prices` for its prices, and `dimensions` to `search-rates` for the rates of a price that delegates to a rate card. Quote a purchase or a change with Billing's `get-quote` using these values, the quantity this describes and the chosen terms, and estimate metered usage with `estimate-usage` and `meters`.
+ */
+export interface BillingComponent {
+    /** The Billing plan the line is ordered under. */
+    plan_id: string;
+    /** The dimension values the order line carries. */
+    dimensions: BillingComponentDimensions;
+    /** What the order line's quantity counts, for each usage type the item is sold under. A usage type that is absent is not sold for this item. */
+    quantity: BillingComponentQuantity;
+    /** What the line's metered price reads. Empty when the line is never metered or its usage is not estimated in advance. */
+    meters: BillingMeter[];
+}
+/**
+ * `immediate` releases the resource now and refunds under the subscriptions' terms; `period_end` keeps it until `scheduled_at`.
+ */
+export type ResourceCancellationMode = (typeof ResourceCancellationMode)[keyof typeof ResourceCancellationMode];
+export declare const ResourceCancellationMode: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * `requested` and `scheduled` have not begun release; `releasing` is releasing the resource.
+ */
+export type ResourceCancellationStatus = (typeof ResourceCancellationStatus)[keyof typeof ResourceCancellationStatus];
+export declare const ResourceCancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+};
+/**
+ * The Billing cancellation of the subscriptions that pay for a resource. Read it in Billing with `get-cancellation` for its refund and progress.
+ */
+export interface ResourceCancellation {
+    id: string;
+    /** `immediate` releases the resource now and refunds under the subscriptions' terms; `period_end` keeps it until `scheduled_at`. */
+    mode: ResourceCancellationMode;
+    /** `requested` and `scheduled` have not begun release; `releasing` is releasing the resource. */
+    status: ResourceCancellationStatus;
+    /**
+     * For `period_end`, when release begins; null otherwise.
+     * @nullable
+     */
+    scheduled_at: string | null;
+    subscription_ids: string[];
+}
+/**
+ * `pending` until the order is accepted: no virtual machine exists and addresses are null. `provisioning` while the instance is created, then `active`. `failed` means the instance was not created; `failure_reason` states why. `missing` means the virtual machine no longer exists in the cloud. The other values are the state last observed in the cloud; an operation in progress appears in `operation`, not here.
+ */
+export type InstanceResourceStatus = (typeof InstanceResourceStatus)[keyof typeof InstanceResourceStatus];
+export declare const InstanceResourceStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly stopped: "stopped";
+    readonly paused: "paused";
+    readonly suspended: "suspended";
+    readonly shelved: "shelved";
+    readonly shelved_offloaded: "shelved_offloaded";
+    readonly rescued: "rescued";
+    readonly deleted: "deleted";
+    readonly failed: "failed";
+    readonly error: "error";
+    readonly unknown: "unknown";
+    readonly missing: "missing";
+};
+export type InstanceRestrictionSource = (typeof InstanceRestrictionSource)[keyof typeof InstanceRestrictionSource];
+export declare const InstanceRestrictionSource: {
+    readonly billing: "billing";
+    readonly iam: "iam";
+    readonly operator: "operator";
+};
+/**
+ * An independent restriction on use. Removing one restriction never removes another source’s restriction, and never starts an instance its user stopped.
+ */
+export interface InstanceRestriction {
+    id: string;
+    source: InstanceRestrictionSource;
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    source_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    reason_code: string;
+    created_at: string;
+}
+/**
+ * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this instance is refunded.
+ * @nullable
+ */
+export type InstanceResourceFailureReason = (typeof InstanceResourceFailureReason)[keyof typeof InstanceResourceFailureReason] | null;
+export declare const InstanceResourceFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * `create` runs from acceptance of the order until the instance is `active` or `failed`. `suspend` and `resume` impose and lift a suspension by the platform or for non-payment. `delete` includes release through a Billing cancellation.
+ */
+export type InstanceOperationType = (typeof InstanceOperationType)[keyof typeof InstanceOperationType];
+export declare const InstanceOperationType: {
+    readonly create: "create";
+    readonly start: "start";
+    readonly stop: "stop";
+    readonly reboot: "reboot";
+    readonly rebuild: "rebuild";
+    readonly resize: "resize";
+    readonly reset_password: "reset_password";
+    readonly attach_disk: "attach_disk";
+    readonly detach_disk: "detach_disk";
+    readonly attach_port: "attach_port";
+    readonly detach_port: "detach_port";
+    readonly bind_floating_ip: "bind_floating_ip";
+    readonly unbind_floating_ip: "unbind_floating_ip";
+    readonly suspend: "suspend";
+    readonly resume: "resume";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this instance. It is not a separate resource; once it finishes, the instance's `operation` is null again and the instance shows the result.
+ */
+export interface InstanceOperation {
+    /** `create` runs from acceptance of the order until the instance is `active` or `failed`. `suspend` and `resume` impose and lift a suspension by the platform or for non-payment. `delete` includes release through a Billing cancellation. */
+    type: InstanceOperationType;
+    started_at: string;
+}
+export type ReleaseResourceType = (typeof ReleaseResourceType)[keyof typeof ReleaseResourceType];
+export declare const ReleaseResourceType: {
+    readonly instance: "instance";
+    readonly disk: "disk";
+    readonly image: "image";
+    readonly floating_ip: "floating_ip";
+    readonly backup_service: "backup_service";
+    readonly snapshot_quota: "snapshot_quota";
+    readonly backup_capacity_pack: "backup_capacity_pack";
+};
+/**
+ * A resource a release set releases.
+ */
+export interface ReleaseResource {
+    type: ReleaseResourceType;
+    /** The resource's ID; for `backup_service` and `snapshot_quota`, the ID of their region. */
+    id: string;
+    /** The resource's name. A floating IP is named by its address, a backup service or snapshot quota by its region, and a capacity pack by its capacity, such as 100 GiB. */
+    name: string;
+}
+/**
+ * One subscription of a release set and the resource it pays for.
+ */
+export interface ReleaseSetItem {
+    subscription_id: string;
+    resource: ReleaseResource;
+}
+/**
+ * @nullable
+ */
+export type InstanceResourceAccessState = (typeof InstanceResourceAccessState)[keyof typeof InstanceResourceAccessState] | null;
+export declare const InstanceResourceAccessState: {
+    readonly pending: "pending";
+    readonly enabled: "enabled";
+    readonly suspended: "suspended";
+    readonly reclaimed: "reclaimed";
+};
+/**
+ * Your own classification of this instance, as key-value pairs. Empty when never set
+ */
+export type InstanceResourceLabels = {
+    [key: string]: string;
+};
+export interface InstanceResource {
+    availability_zone_id: string;
+    created_at: string;
+    /** Hostname inside the instance; equals the instance id */
+    hostname: string;
+    id: string;
+    /**
+     * Non-empty when the instance was created from an image, public or private
+     * @nullable
+     */
+    image_id: string | null;
+    /** The instance type in effect, and the basis for billing */
+    instance_type_id: string;
+    /**
+     * IPv6 address of the primary network interface. Assigned automatically once IPv6 is enabled on the private network
+     * @nullable
+     */
+    ipv6_address: string | null;
+    /** Your own classification of this instance, as key-value pairs. Empty when never set */
+    labels: InstanceResourceLabels;
+    /**
+     * The account to log in as over SSH. The password set at creation belongs to this account
+     * @maxLength 32
+     */
+    login_username: string;
+    name: string;
+    /**
+     * A free-text note about this instance. Empty when never set
+     * @maxLength 4096
+     */
+    notes: string;
+    /**
+     * Private address of the instance
+     * @nullable
+     */
+    private_ip: string | null;
+    /** @nullable */
+    private_network_id: string | null;
+    /**
+     * Floating IPv4 addresses bound to the primary network interface; an empty array when none are bound
+     * @nullable
+     */
+    public_ips: string[] | null;
+    region_id: string;
+    /** `pending` until the order is accepted: no virtual machine exists and addresses are null. `provisioning` while the instance is created, then `active`. `failed` means the instance was not created; `failure_reason` states why. `missing` means the virtual machine no longer exists in the cloud. The other values are the state last observed in the cloud; an operation in progress appears in `operation`, not here. */
+    status: InstanceResourceStatus;
+    /** @nullable */
+    subnet_id: string | null;
+    updated_at: string;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+    restrictions: InstanceRestriction[];
+    /**
+     * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this instance is refunded.
+     * @nullable
+     */
+    failure_reason: InstanceResourceFailureReason;
+    /** The operation in progress on this instance, or null when none is. */
+    readonly operation: InstanceOperation | null;
+    /** @nullable */
+    order_id: string | null;
+    /**
+     * The Billing order item for this resource.
+     * @nullable
+     */
+    order_item_id: string | null;
+    /**
+     * The Billing Checkout Session that bought this resource; `order_id` and `order_item_id` stay null until its checkout completes. Null when the resource was not bought through one.
+     * @nullable
+     */
+    checkout_session_id: string | null;
+    /**
+     * The Billing subscription associated with this resource. It may still be pending; its
+     * presence does not imply delivery or metering. Null when no subscription is associated.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The subscriptions a cancellation through Billing has to cover to release this instance: its own and those of the disks deleted with it. Snapshots are cleaned up with their source disk without canceling the project's snapshot quota. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+    release_subscription_ids: string[];
+    /** The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+    release_set: ReleaseSetItem[];
+    /** @nullable */
+    access_state: InstanceResourceAccessState;
+    /**
+     * Non-empty when the instance was created from a disk you already had, instead of from an image
+     * @nullable
+     */
+    source_disk_id: string | null;
+}
+export interface DeleteInstanceResponseBody {
+    instance: InstanceResource;
+    /** The cancellation this request created or found open, when subscriptions pay for the resource; null when the resource was released directly. */
+    cancellation: ResourceCancellation | null;
+}
+/**
+ * `pending` until the order is accepted, with no storage allocated; `provisioning` while the disk is created; then `available`, or `in_use` once attached. `failed` means the disk was not created; `failure_reason` states why. `missing` means the disk no longer exists in the cloud.
+ */
+export type DiskResourceStatus = (typeof DiskResourceStatus)[keyof typeof DiskResourceStatus];
+export declare const DiskResourceStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly available: "available";
+    readonly in_use: "in_use";
+    readonly deleted: "deleted";
+    readonly failed: "failed";
+    readonly error: "error";
+    readonly missing: "missing";
+};
+/**
+ * @nullable
+ */
+export type DiskResourceAccessState = (typeof DiskResourceAccessState)[keyof typeof DiskResourceAccessState] | null;
+export declare const DiskResourceAccessState: {
+    readonly pending: "pending";
+    readonly enabled: "enabled";
+    readonly suspended: "suspended";
+    readonly reclaimed: "reclaimed";
+};
+/**
+ * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this disk is refunded.
+ * @nullable
+ */
+export type DiskResourceFailureReason = (typeof DiskResourceFailureReason)[keyof typeof DiskResourceFailureReason] | null;
+export declare const DiskResourceFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * `attach` and `detach` accompany the instance's `attach_disk` and `detach_disk`. `delete` includes release through a Billing cancellation and deletion with an instance.
+ */
+export type DiskOperationType = (typeof DiskOperationType)[keyof typeof DiskOperationType];
+export declare const DiskOperationType: {
+    readonly create: "create";
+    readonly resize: "resize";
+    readonly revert: "revert";
+    readonly attach: "attach";
+    readonly detach: "detach";
+    readonly suspend: "suspend";
+    readonly resume: "resume";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this disk. It is not a separate resource; once it finishes, the disk's `operation` is null again and the disk shows the result.
+ */
+export interface DiskOperation {
+    /** `attach` and `detach` accompany the instance's `attach_disk` and `detach_disk`. `delete` includes release through a Billing cancellation and deletion with an instance. */
+    type: DiskOperationType;
+    started_at: string;
+}
+export type DiskAttachmentRole = (typeof DiskAttachmentRole)[keyof typeof DiskAttachmentRole];
+export declare const DiskAttachmentRole: {
+    readonly boot: "boot";
+    readonly data: "data";
+};
+export type DiskAttachmentState = (typeof DiskAttachmentState)[keyof typeof DiskAttachmentState];
+export declare const DiskAttachmentState: {
+    readonly reserved: "reserved";
+    readonly attached: "attached";
+    readonly released: "released";
+    readonly unknown: "unknown";
+};
+export interface DiskAttachment {
+    id: string;
+    instance_id: string;
+    disk_id: string;
+    role: DiskAttachmentRole;
+    delete_with_instance: boolean;
+    state: DiskAttachmentState;
+    /** @nullable */
+    attached_at: string | null;
+    /** @nullable */
+    detached_at: string | null;
+    /** @nullable */
+    released_at: string | null;
+    /** @nullable */
+    device: string | null;
+}
+export interface DiskResource {
+    /** Availability zone the disk actually resides in. An instance must be in the same zone to attach it */
+    availability_zone_id: string;
+    created_at: string;
+    disk_type_id: string;
+    id: string;
+    name: string;
+    region_id: string;
+    size_gb: number;
+    /**
+     * IOPS this disk is allowed. Null when its type is not rate-limited.
+     *
+     * Computed from the disk's own capacity, so it grows when the disk is grown — but see the
+     * note on the resize endpoint: growing a disk that is attached is refused, precisely because
+     * the new figure would not take effect until it was attached again.
+     * @nullable
+     */
+    iops: number | null;
+    /**
+     * Throughput this disk is allowed, in bytes per second. Null when its type is not rate-limited
+     * @nullable
+     */
+    throughput_bytes_per_sec: number | null;
+    /** `pending` until the order is accepted, with no storage allocated; `provisioning` while the disk is created; then `available`, or `in_use` once attached. `failed` means the disk was not created; `failure_reason` states why. `missing` means the disk no longer exists in the cloud. */
+    status: DiskResourceStatus;
+    /** @nullable */
+    order_id: string | null;
+    /**
+     * The Billing order item for this resource.
+     * @nullable
+     */
+    order_item_id: string | null;
+    /**
+     * The Billing Checkout Session that bought this resource; `order_id` and `order_item_id` stay null until its checkout completes. Null when the resource was not bought through one.
+     * @nullable
+     */
+    checkout_session_id: string | null;
+    /**
+     * The Billing subscription associated with this resource. It may still be pending; its
+     * presence does not imply delivery or metering. Null when no subscription is associated.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The subscriptions a cancellation through Billing has to cover to release this disk: its own. Snapshots have no individual subscriptions. A system disk is released only with its instance, so for a system disk the list is that of the instance. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for any of them. */
+    release_subscription_ids: string[];
+    /** The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+    release_set: ReleaseSetItem[];
+    /** @nullable */
+    access_state: DiskResourceAccessState;
+    /**
+     * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this disk is refunded.
+     * @nullable
+     */
+    failure_reason: DiskResourceFailureReason;
+    /** The operation in progress on this disk, or null when none is. */
+    readonly operation: DiskOperation | null;
+    attachment?: DiskAttachment | null;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+}
+export interface DeleteDiskResponseBody {
+    disk: DiskResource;
+    /** The cancellation this request created or found open, when subscriptions pay for the resource; null when the resource was released directly. */
+    cancellation: ResourceCancellation | null;
+}
+/**
+ * `pending` until the order is accepted, with no address allocated; `provisioning` while the address is allocated; then `available`. `failed` means no address was allocated; `failure_reason` states why. `missing` means the address no longer exists in the cloud.
+ */
+export type FloatingIPResourceStatus = (typeof FloatingIPResourceStatus)[keyof typeof FloatingIPResourceStatus];
+export declare const FloatingIPResourceStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly available: "available";
+    readonly deleted: "deleted";
+    readonly failed: "failed";
+    readonly error: "error";
+    readonly unknown: "unknown";
+    readonly missing: "missing";
+};
+/**
+ * @nullable
+ */
+export type FloatingIPResourceAccessState = (typeof FloatingIPResourceAccessState)[keyof typeof FloatingIPResourceAccessState] | null;
+export declare const FloatingIPResourceAccessState: {
+    readonly pending: "pending";
+    readonly enabled: "enabled";
+    readonly suspended: "suspended";
+    readonly reclaimed: "reclaimed";
+};
+/**
+ * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this floating IP is refunded.
+ * @nullable
+ */
+export type FloatingIPResourceFailureReason = (typeof FloatingIPResourceFailureReason)[keyof typeof FloatingIPResourceFailureReason] | null;
+export declare const FloatingIPResourceFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+export type FloatingIPOperationType = (typeof FloatingIPOperationType)[keyof typeof FloatingIPOperationType];
+export declare const FloatingIPOperationType: {
+    readonly create: "create";
+    readonly bind: "bind";
+    readonly unbind: "unbind";
+    readonly set_bandwidth: "set_bandwidth";
+    readonly suspend: "suspend";
+    readonly resume: "resume";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this floating IP. It is not a separate resource; once it finishes, the floating IP's `operation` is null again and the floating IP shows the result.
+ */
+export interface FloatingIPOperation {
+    type: FloatingIPOperationType;
+    started_at: string;
+}
+export type IPv4BindingState = (typeof IPv4BindingState)[keyof typeof IPv4BindingState];
+export declare const IPv4BindingState: {
+    readonly bound: "bound";
+    readonly released: "released";
+    readonly unknown: "unknown";
+};
+export interface IPv4Binding {
+    id: string;
+    ipv4_allocation_id: string;
+    port_address_id: string;
+    address: string;
+    fixed_ip: string;
+    state: IPv4BindingState;
+    /** @nullable */
+    bound_at: string | null;
+    /** @nullable */
+    unbound_at: string | null;
+    /** @nullable */
+    released_at: string | null;
+}
+/**
+ * One purchased public IP resource, including its bandwidth configuration. Bandwidth has no
+ * separate Compute resource ID; one subscription pays for the address and its bandwidth.
+ * Changing bandwidth updates this same resource, not another allocation.
+ */
+export interface FloatingIPResource {
+    /**
+     * The allocated public address. Null until the address is allocated.
+     * @nullable
+     */
+    address: string | null;
+    /** @nullable */
+    bandwidth_mbps: number | null;
+    created_at: string;
+    id: string;
+    region_id: string;
+    /** `pending` until the order is accepted, with no address allocated; `provisioning` while the address is allocated; then `available`. `failed` means no address was allocated; `failure_reason` states why. `missing` means the address no longer exists in the cloud. */
+    status: FloatingIPResourceStatus;
+    /** @nullable */
+    order_id: string | null;
+    /**
+     * The Billing order item for this resource.
+     * @nullable
+     */
+    order_item_id: string | null;
+    /**
+     * The Billing Checkout Session that bought this resource; `order_id` and `order_item_id` stay null until its checkout completes. Null when the resource was not bought through one.
+     * @nullable
+     */
+    checkout_session_id: string | null;
+    /**
+     * The Billing subscription associated with this resource. It may still be pending; its
+     * presence does not imply delivery or metering. Null when no subscription is associated.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The subscription a cancellation through Billing has to cover to release this floating IP. A subscription that has ended is not listed, and the list is empty when no subscription pays for the floating IP. */
+    release_subscription_ids: string[];
+    /** The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+    release_set: ReleaseSetItem[];
+    /** @nullable */
+    access_state: FloatingIPResourceAccessState;
+    /**
+     * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this floating IP is refunded.
+     * @nullable
+     */
+    failure_reason: FloatingIPResourceFailureReason;
+    /** The operation in progress on this floating IP, or null when none is. */
+    readonly operation: FloatingIPOperation | null;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+    binding: IPv4Binding | null;
+}
+export interface ReleaseFloatingIPResponseBody {
+    floating_ip: FloatingIPResource;
+    /** The cancellation this request created or found open, when subscriptions pay for the resource; null when the resource was released directly. */
+    cancellation: ResourceCancellation | null;
+}
+/**
+ * Who can see and use an image. `public` — offered to every project by the platform. `private` — usable only by the project that owns it.
+ */
+export type ImageVisibility = (typeof ImageVisibility)[keyof typeof ImageVisibility];
+export declare const ImageVisibility: {
+    readonly public: "public";
+    readonly private: "private";
+};
+/**
+ * Only `available` images can install instances. A public image is always `available`; a private image is `pending` until its order is accepted, then goes through `provisioning` and `uploading` while it is captured. `failed` means the capture produced no image; `failure_reason` states why. `missing` means a private image no longer exists in the cloud.
+ */
+export type ImageResourceStatus = (typeof ImageResourceStatus)[keyof typeof ImageResourceStatus];
+export declare const ImageResourceStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly uploading: "uploading";
+    readonly available: "available";
+    readonly deleted: "deleted";
+    readonly failed: "failed";
+    readonly error: "error";
+    readonly missing: "missing";
+};
+/**
+ * @nullable
+ */
+export type ImageResourceAccessState = (typeof ImageResourceAccessState)[keyof typeof ImageResourceAccessState] | null;
+export declare const ImageResourceAccessState: {
+    readonly pending: "pending";
+    readonly enabled: "enabled";
+    readonly suspended: "suspended";
+    readonly reclaimed: "reclaimed";
+};
+/**
+ * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this image is refunded.
+ * @nullable
+ */
+export type ImageResourceFailureReason = (typeof ImageResourceFailureReason)[keyof typeof ImageResourceFailureReason] | null;
+export declare const ImageResourceFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * `create` is the capture of a private image.
+ */
+export type ImageOperationType = (typeof ImageOperationType)[keyof typeof ImageOperationType];
+export declare const ImageOperationType: {
+    readonly create: "create";
+    readonly suspend: "suspend";
+    readonly resume: "resume";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this image. It is not a separate resource; once it finishes, the image's `operation` is null again and the image shows the result.
+ */
+export interface ImageOperation {
+    /** `create` is the capture of a private image. */
+    type: ImageOperationType;
+    started_at: string;
+}
+/**
+ * An image that installs the system of an instance. Fields that describe a capture or its billing apply only to private images and are null, zero or empty for public ones.
+ */
+export interface ImageResource {
+    id: string;
+    region_id: string;
+    visibility: ImageVisibility;
+    name: string;
+    os_family: string;
+    os_version: string;
+    architecture: string;
+    /**
+     * The account this image lets you log in as. The password set at creation belongs to this account
+     * @maxLength 32
+     */
+    login_username: string;
+    /** The system disk of an instance created from this image cannot be smaller than this */
+    min_disk_gb: number;
+    /** The instance type of an instance created from this image must have at least this much memory */
+    min_ram_mb: number;
+    /** False means a new password can only be set by rebuilding an instance created from this image */
+    supports_password_reset: boolean;
+    /** Only `available` images can install instances. A public image is always `available`; a private image is `pending` until its order is accepted, then goes through `provisioning` and `uploading` while it is captured. `failed` means the capture produced no image; `failure_reason` states why. `missing` means a private image no longer exists in the cloud. */
+    status: ImageResourceStatus;
+    /**
+     * Details of why the capture failed; non-empty only when `status` is `failed`
+     * @nullable
+     */
+    failure: string | null;
+    /** Storage occupied by a private image, which is what it is billed for; 0 until its capture completes, and 0 for public images */
+    size_bytes: number;
+    /**
+     * The instance a private image was captured from. The image remains usable after that instance is released. Null for public images
+     * @nullable
+     */
+    source_instance_id: string | null;
+    created_at: string;
+    /** @nullable */
+    order_id: string | null;
+    /**
+     * The Billing order item for this resource.
+     * @nullable
+     */
+    order_item_id: string | null;
+    /**
+     * The Billing Checkout Session that bought this resource; `order_id` and `order_item_id` stay null until its checkout completes. Null when the resource was not bought through one.
+     * @nullable
+     */
+    checkout_session_id: string | null;
+    /**
+     * The Billing subscription associated with this resource. It may still be pending; its
+     * presence does not imply delivery or metering. Null when no subscription is associated.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The subscriptions a cancellation through Billing has to cover to release this private image: its own. Subscriptions that have ended are not listed, and the list is empty when no subscription pays for it, and for public images. */
+    release_subscription_ids: string[];
+    /** The subscriptions of `release_subscription_ids`, in the same order, each with the resource it pays for, so that each line of a cancellation can name what it releases. */
+    release_set: ReleaseSetItem[];
+    /** @nullable */
+    access_state: ImageResourceAccessState;
+    /**
+     * Why creation failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means creation failed after the order was accepted, and the charge for this image is refunded.
+     * @nullable
+     */
+    failure_reason: ImageResourceFailureReason;
+    /** The operation in progress on this image, or null when none is. */
+    readonly operation: ImageOperation | null;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+}
+export interface DeleteImageResponseBody {
+    image: ImageResource;
+    /** The cancellation this request created or found open, when subscriptions pay for the resource; null when the resource was released directly. */
+    cancellation: ResourceCancellation | null;
+}
+/**
+ * What a given `code` carries alongside the message. The keys depend on the code,
+ * and a client that does not recognise one ignores it.
+ */
+export type ErrorMeta = {
+    [key: string]: unknown;
+};
+export interface Error {
+    code?: string;
+    message: string;
+    /**
+     * What a given `code` carries alongside the message. The keys depend on the code,
+     * and a client that does not recognise one ignores it.
+     */
+    meta?: ErrorMeta;
+    status: number;
+}
+/**
+ * `provisioning` while the backup is taken, then `available`. `failed` means the backup was not created. `missing` means the backup no longer exists in the cloud.
+ */
+export type BackupResourceStatus = (typeof BackupResourceStatus)[keyof typeof BackupResourceStatus];
+export declare const BackupResourceStatus: {
+    readonly provisioning: "provisioning";
+    readonly available: "available";
+    readonly deleted: "deleted";
+    readonly failed: "failed";
+    readonly error: "error";
+    readonly missing: "missing";
+};
+/**
+ * `restore`: a disk is being restored from this backup.
+ */
+export type BackupOperationType = (typeof BackupOperationType)[keyof typeof BackupOperationType];
+export declare const BackupOperationType: {
+    readonly create: "create";
+    readonly restore: "restore";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this backup. It is not a separate resource; once it finishes, the backup's `operation` is null again and the backup shows the result.
+ */
+export interface BackupOperation {
+    /** `restore`: a disk is being restored from this backup. */
+    type: BackupOperationType;
+    started_at: string;
+}
+/**
+ * A copy of a disk, metered on the backup service of its region by `capacity_gib` for as long as it is retained. It has no order or subscription of its own.
+ */
+export interface BackupResource {
+    created_at: string;
+    id: string;
+    name: string;
+    region_id: string;
+    /** Capacity of the source disk when the backup was created. A restored disk cannot be smaller than this */
+    size_gb: number;
+    /** The capacity metered for this backup, in GiB: the size of the source disk when the backup was taken. Usage is this capacity multiplied by the time the backup is retained. */
+    capacity_gib: number;
+    /** The disk this backup was taken from. The backup remains usable after that disk is deleted */
+    source_disk_id: string;
+    /** `provisioning` while the backup is taken, then `available`. `failed` means the backup was not created. `missing` means the backup no longer exists in the cloud. */
+    status: BackupResourceStatus;
+    /** The operation in progress on this backup, or null when none is. */
+    readonly operation: BackupOperation | null;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+    /** Availability zone of the source disk. A restore may target another zone in the same region */
+    source_availability_zone_id: string;
+}
+export interface BackupListResponseBody {
+    /** @nullable */
+    items: BackupResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface CreateBackupRequestBody {
+    disk_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface RenameBackupRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+/**
+ * `licensed` pays for a period in advance; `metered` bills usage until canceled.
+ */
+export type BillingChoiceUsageType = (typeof BillingChoiceUsageType)[keyof typeof BillingChoiceUsageType];
+export declare const BillingChoiceUsageType: {
+    readonly licensed: "licensed";
+    readonly metered: "metered";
+};
+export type BillingPeriodUnit = (typeof BillingPeriodUnit)[keyof typeof BillingPeriodUnit];
+export declare const BillingPeriodUnit: {
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface BillingPeriod {
+    unit: BillingPeriodUnit;
+    /**
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    count: number;
+}
+/**
+ * Immediate ends service when cancellation takes effect, with refunds governed by the purchased terms. Period-end keeps service until the paid period ends.
+ */
+export type TerminationPolicy = (typeof TerminationPolicy)[keyof typeof TerminationPolicy];
+export declare const TerminationPolicy: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * The commercial terms for one newly purchased component. Licensed requires period and termination_policy; metered refuses both. Components in one instance order must use the same usage type and period, while their termination policies may differ.
+ */
+export interface BillingChoice {
+    /** `licensed` pays for a period in advance; `metered` bills usage until canceled. */
+    usage_type: BillingChoiceUsageType;
+    period?: BillingPeriod;
+    termination_policy?: TerminationPolicy;
+}
+/**
+ * automatic completes checkout with the purchase: the best applicable account discount is applied, and the
+ * order is created with its invoice issued and paid from eligible credit grants and available balance.
+ * Insufficient funds fail the purchase with HTTP 422 BILLING_INSUFFICIENT_FUNDS; no Billing order, charge or
+ * discount redemption is committed.
+ * deferred creates an open Billing Checkout Session and charges nothing, even for a zero total. The customer
+ * completes it through Billing, where a promotion code can be applied, and then pays the issued invoice; a
+ * session not completed by its deadline expires.
+ */
+export type CheckoutMode = (typeof CheckoutMode)[keyof typeof CheckoutMode];
+export declare const CheckoutMode: {
+    readonly automatic: "automatic";
+    readonly deferred: "deferred";
+};
+/**
+ * A decimal string, in the currency stated alongside it.
+ *
+ * **The currency is not part of this type.** It is carried by a `currency` field next to the
+ * amount, or by the account the amount belongs to. Reading an amount without that field is
+ * reading a number with no unit.
+ *
+ * It is a string rather than a JSON number because a JSON number is a float in most parsers,
+ * and a float loses precision on the first arithmetic. Nothing on this platform puts an amount
+ * through a float.
+ */
+export type Money = string;
+/**
+ * Shared checkout choices for a product purchase. The service may set them or forward its client's
+ * choices unchanged; it does not need to read them, and Billing validates them. Omitting this object or
+ * mode selects automatic checkout. Each purchase creates its own Checkout Session. Promotion codes are supplied
+ * only to Billing. A service may retain a failed creation record when Billing refuses a purchase; no
+ * infrastructure is created for that refusal.
+ */
+export interface CheckoutOptions {
+    mode?: CheckoutMode;
+    /**
+     * Expected invoice total after discounts and tax, before applying credit grants or balance.
+     * A different total fails with BILLING_AMOUNT_CHANGED without charging or reserving a discount.
+     * Accepted only in automatic mode; with deferred it is refused with HTTP 400. For deferred
+     * checkout, give the expected amount when completing it through Billing.
+     */
+    expected_amount?: Money & string;
+    /**
+     * Where the client goes after the customer finishes a deferred checkout. Any absolute URI with a
+     * scheme, including mobile and desktop application schemes. Billing stores it without checking the
+     * target; each client validates its own.
+     * @maxLength 2048
+     */
+    return_url?: string;
+}
+export interface RestoreBackupRequestBody {
+    /**
+     * May differ from the availability zone of the source disk, but must be in the same region. It has to be a data disk type on sale — restoring creates a new data disk, so a withdrawn type or a system disk type is rejected here as well
+     * @maxLength 64
+     */
+    disk_type_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    /**
+     * Matches the size of the backup when omitted. When given, it must not be smaller than the backup
+     * @minimum 0
+     */
+    size_gb?: number;
+    billing: BillingChoice;
+    checkout?: CheckoutOptions;
+}
+/**
+ * The intended purchase use of a disk type, not the current boot role or deletion policy of an individual disk.
+ */
+export type DiskTypePurpose = (typeof DiskTypePurpose)[keyof typeof DiskTypePurpose];
+export declare const DiskTypePurpose: {
+    readonly system: "system";
+    readonly data: "data";
+};
+export type DiskTypeResourceMedia = (typeof DiskTypeResourceMedia)[keyof typeof DiskTypeResourceMedia];
+export declare const DiskTypeResourceMedia: {
+    readonly ssd: "ssd";
+    readonly hdd: "hdd";
+    readonly nvme: "nvme";
+};
+export interface DiskTypeResource {
+    availability_zone_id: string;
+    id: string;
+    purpose: DiskTypePurpose;
+    /**
+     * IOPS a disk of `min_size_gb` gets. Null when this type is not rate-limited.
+     *
+     * Performance grows with capacity, so this and `iops_at_max_size` are the two ends of the
+     * range. The exact figure for the size actually bought appears on the disk itself once it
+     * exists.
+     * @nullable
+     */
+    iops_at_min_size: number | null;
+    /**
+     * IOPS a disk of `max_size_gb` gets. Null when this type is not rate-limited
+     * @nullable
+     */
+    iops_at_max_size: number | null;
+    max_size_gb: number;
+    media: DiskTypeResourceMedia;
+    min_size_gb: number;
+    name: string;
+    region_id: string;
+    step_gb: number;
+    /**
+     * Throughput a disk of `min_size_gb` gets, in **bytes per second**. Null when this type is
+     * not rate-limited.
+     *
+     * Bytes rather than MiB so the number needs no rounding on the way out; divide by 1048576
+     * for MiB/s at the point of display.
+     * @nullable
+     */
+    throughput_at_min_size: number | null;
+    /**
+     * Throughput a disk of `max_size_gb` gets, in bytes per second. Null when this type is not rate-limited
+     * @nullable
+     */
+    throughput_at_max_size: number | null;
+    billing: BillingComponent;
+}
+export interface DiskTypeListResponseBody {
+    /** @nullable */
+    items: DiskTypeResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface ImageListResponseBody {
+    items: ImageResource[];
+    pagination: OffsetPagination;
+}
+export interface InstanceTypeResource {
+    availability_zone_id: string;
+    id: string;
+    /**
+     * The most public bandwidth a machine of this type may be given, in Mbps. Asking for more
+     * when creating a machine, or raising a bound address past it, is refused.
+     *
+     * A ceiling on what can be bought, not a speed. How fast the machine's own interfaces run is
+     * `network_egress_kbps` / `network_ingress_kbps`.
+     */
+    max_bandwidth_mbps: number;
+    /**
+     * Outbound ceiling of **each** network interface, in kbps. Null when this type is not
+     * rate-limited.
+     *
+     * Per interface rather than per machine: a machine with two interfaces has this ceiling on
+     * each of them, not shared between them. `max_ports` says how many it may have.
+     * @nullable
+     */
+    network_egress_kbps: number | null;
+    /**
+     * Inbound ceiling of each network interface, in kbps. Null when this type is not rate-limited
+     * @nullable
+     */
+    network_ingress_kbps: number | null;
+    max_floating_ips: number;
+    max_ports: number;
+    name: string;
+    ram_mb: number;
+    region_id: string;
+    vcpus: number;
+    billing: BillingComponent;
+}
+export interface InstanceTypeListResponseBody {
+    items: InstanceTypeResource[];
+    pagination: OffsetPagination;
+}
+export interface RegionResource {
+    /** ISO 3166-1 alpha-2 country this region sits in. Two letters, uppercase. */
+    country_code: string;
+    /** Display name for this place, shown to tenants (Hong Kong). The stable handle is code. */
+    name: string;
+    /** The region's code, the way the outside world names this place (hk-1). Stable and human-written; addressing is by id. */
+    code: string;
+    id: string;
+    /** Private images stored in this region. */
+    private_image_billing: BillingComponent;
+    /** The region's backup service. Retained backup capacity beyond the active capacity packs is reported on it by the hour. */
+    backup_service_billing: BillingComponent;
+    /** Backup capacity packs in this region; null where none are sold. */
+    capacity_pack_billing: BillingComponent | null;
+    /** The snapshot quota in this region; null where it is not sold. */
+    snapshot_quota_billing: BillingComponent | null;
+}
+export interface RegionListResponseBody {
+    /** @nullable */
+    items: RegionResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface ZoneResource {
+    /** Display name for this zone, shown to tenants (Hong Kong A). The stable handle is code. */
+    name: string;
+    /** The zone's code within its region (hk-1-a). Stable and human-written; addressing is by id. */
+    code: string;
+    id: string;
+}
+export interface ZoneListResponseBody {
+    /** @nullable */
+    items: ZoneResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface DiskListResponseBody {
+    /** @nullable */
+    items: DiskResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface CreateDiskRequestBody {
+    /**
+     * A data disk type currently on sale, one whose `purpose` is `data`. A withdrawn one is rejected even though its identifier still resolves
+     * @maxLength 64
+     */
+    disk_type_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    /** @minimum 1 */
+    size_gb: number;
+    /** Restore from this snapshot. When given, the capacity need only be no smaller than the snapshot */
+    snapshot_id?: string;
+    billing: BillingChoice;
+    checkout?: CheckoutOptions;
+}
+export interface RenameDiskRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface ResizeDiskRequestBody {
+    /**
+     * Must be larger than the current capacity
+     * @minimum 1
+     */
+    size_gb: number;
+    checkout?: CheckoutOptions;
+    /** The `proration_date` of Billing's quote for this change, so that the order is priced from the same instant. Only for automatic checkout; deferred checkout is priced when the customer completes it. Defaults to the time of the request; it must be a whole second, not in the future and at most 10 minutes old, otherwise the request is refused with `BILLING_CHANGE_INVALID`. */
+    proration_date?: string;
+}
+export interface RevertDiskRequestBody {
+    /** Must be the most recent snapshot of the disk */
+    snapshot_id: string;
+}
+export interface FloatingIPListResponseBody {
+    /** @nullable */
+    items: FloatingIPResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface AllocateFloatingIPRequestBody {
+    /**
+     * The address to allocate. Allocated by the platform when omitted
+     * @maxLength 64
+     */
+    address?: string;
+    /**
+     * The bandwidth ceiling of this address, in Mbit/s, applied to both directions.
+     *
+     * Required, and there is no "unlimited": an address with no ceiling runs at line rate and is
+     * charged nothing for the traffic, while the address itself bills normally — so the invoice
+     * looks correct and nothing anywhere reports it.
+     *
+     * It is part of this floating IP purchase and is billed under the pool's `billing`, with the
+     * purchase's billing choice. Changing it later updates the
+     * same floating IP through its bandwidth endpoint, not an independent bandwidth resource.
+     * @minimum 1
+     * @maximum 1000
+     */
+    bandwidth_mbps: number;
+    private_network_id: string;
+    ipv4_pool_id: string;
+    billing: BillingChoice;
+    checkout?: CheckoutOptions;
+}
+/**
+ * Change bandwidth on the floating IP identified by the path. This is a configuration change
+ * of that purchase, not an independent bandwidth purchase. Checkout is handled by Billing.
+ */
+export interface SetFloatingIPBandwidthRequestBody {
+    /**
+     * Applied to both directions
+     * @minimum 1
+     */
+    bandwidth_mbps: number;
+    checkout?: CheckoutOptions;
+    /** The `proration_date` of Billing's quote for this change, so that the order is priced from the same instant. Only for automatic checkout; deferred checkout is priced when the customer completes it. Defaults to the time of the request; it must be a whole second, not in the future and at most 10 minutes old, otherwise the request is refused with `BILLING_CHANGE_INVALID`. */
+    proration_date?: string;
+}
+export interface BindFloatingIPRequestBody {
+    port_address_id: string;
+}
+export interface InstanceListResponseBody {
+    items: InstanceResource[];
+    pagination: OffsetPagination;
+}
+/**
+ * The compute capacity purchased for each instance in this order.
+ */
+export interface NewCompute {
+    /**
+     * An instance type currently on sale.
+     * @maxLength 64
+     */
+    instance_type_id: string;
+    billing: BillingChoice;
+}
+export type NewBootDiskType = (typeof NewBootDiskType)[keyof typeof NewBootDiskType];
+export declare const NewBootDiskType: {
+    readonly image: "image";
+};
+/**
+ * A system disk created from an image and purchased in the instance order. Its commercial terms are explicit and its release policy does not override them.
+ */
+export interface NewBootDisk {
+    type: NewBootDiskType;
+    /**
+     * A public image on sale, or an available private image of this project.
+     * @maxLength 64
+     */
+    image_id: string;
+    /** A system disk type on sale in the availability zone of the instance, one whose `purpose` is `system` */
+    disk_type_id: string;
+    /** @minimum 1 */
+    size_gb: number;
+    delete_with_instance?: boolean;
+    billing: BillingChoice;
+}
+export type ExistingBootDiskType = (typeof ExistingBootDiskType)[keyof typeof ExistingBootDiskType];
+export declare const ExistingBootDiskType: {
+    readonly disk: "disk";
+};
+export interface ExistingBootDisk {
+    type: ExistingBootDiskType;
+    /** A prepared boot disk owned by this project, available and unattached in the same availability zone as the instance type. Only one instance may be created when used. */
+    disk_id: string;
+    /**
+     * The existing account used to log in to this disk's operating system.
+     * @minLength 1
+     * @maxLength 32
+     */
+    login_username: string;
+}
+/**
+ * Create a boot disk from an image, or use a prepared disk already held by this project. Using an existing disk does not buy it again and always keeps it when the instance is released.
+ */
+export type BootDisk = NewBootDisk | ExistingBootDisk;
+/**
+ * One floating IP purchased with this bandwidth configuration in the instance's order. Mutually exclusive with floating_ip_id.
+ */
+export interface NewFloatingIP {
+    /**
+     * @minimum 1
+     * @maximum 1000
+     */
+    bandwidth_mbps: number;
+    ipv4_pool_id: string;
+    billing: BillingChoice;
+}
+export interface LaunchInstanceRequestBody {
+    /**
+     * Bind a floating IP you already hold, instead of allocating a new one. It must be idle and in
+     * the same region.
+     *
+     * Mutually exclusive with `bandwidth_mbps`: an address you already hold has its own bandwidth
+     * ceiling, set when it was allocated, and changing it is a separate operation.
+     *
+     * Like `bandwidth_mbps`, this happens **inside the creation**: if binding fails, no instance is
+     * created. Binding afterwards is still possible from the instance page, but then it is two
+     * operations and a failure in between leaves an instance you cannot reach.
+     *
+     * Only one instance can be created when it is used — one address binds to one interface.
+     */
+    floating_ip_id?: string;
+    /**
+     * Number of instances to create; 1 when omitted. Names are numbered automatically for several
+     * @minimum 1
+     * @maximum 20
+     */
+    count?: number;
+    /** Have the platform generate a random password, returned only in this response */
+    generate_password?: boolean;
+    compute: NewCompute;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    /**
+     * The password to set, on the login account and on root. Only the SSH public keys of the project are used when omitted
+     * @maxLength 128
+     */
+    password?: string;
+    /** Use an existing network interface, which may already have a floating IP bound. Exactly one of this and `subnet_id`; only one instance can be created when it is used */
+    port_id?: string;
+    /**
+     * Required when a primary network interface is created, at least one; the default security group is not applied automatically. Ignored together with `port_id`, as the security groups of that interface were fixed when it was created
+     * @minItems 1
+     * @nullable
+     */
+    security_group_ids?: string[] | null;
+    /** Create the primary network interface in this subnet. Exactly one of this and `port_id` */
+    subnet_id?: string;
+    checkout?: CheckoutOptions;
+    boot_disk: BootDisk;
+    floating_ip?: NewFloatingIP;
+}
+/**
+ * The complete set of labels. Whatever is absent here is removed; send an empty object to clear them all. A key may not contain a colon, whitespace or control characters
+ */
+export type SetInstanceLabelsRequestBodyLabels = {
+    [key: string]: string;
+};
+export interface SetInstanceLabelsRequestBody {
+    /** The complete set of labels. Whatever is absent here is removed; send an empty object to clear them all. A key may not contain a colon, whitespace or control characters */
+    labels: SetInstanceLabelsRequestBodyLabels;
+}
+export interface SetInstanceNotesRequestBody {
+    /**
+     * The complete note. Send an empty string to clear it
+     * @maxLength 4096
+     */
+    notes: string;
+}
+export interface RenameInstanceRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface RebootInstanceRequestBody {
+    /** A forced reboot does not wait for the operating system to shut down and unwritten data is lost; use it when the system is unresponsive. False when omitted */
+    force?: boolean;
+}
+export interface RunCommandRequestBody {
+    /**
+     * Run by the login shell, so pipes, redirection and `&&` work. It cannot read standard input
+     * @minLength 1
+     * @maxLength 65536
+     */
+    command: string;
+    /**
+     * Kill the command after this long. 60 when omitted
+     * @minimum 1
+     * @maximum 300
+     */
+    timeout_seconds?: number;
+}
+export interface CommandResultResponseBody {
+    /**
+     * What the command exited with, 0 being success. Any other value is the command's own verdict and still arrives as a 200. Null when it was killed rather than exiting on its own, which includes the timeout — null is the absence of a verdict, not a successful one
+     * @nullable
+     */
+    exit_code: number | null;
+    stderr: string;
+    stdout: string;
+    /** True when the command was still running at the timeout and was killed */
+    timed_out: boolean;
+    /** True when either stream hit the 1 MiB cap and the rest was discarded */
+    truncated: boolean;
+}
+export interface ConsoleResponseBody {
+    /** Connection address of the remote console; single-use and expires within minutes */
+    console_url: string;
+}
+export interface ConsoleOutputResponseBody {
+    /** Raw text of the console output, in the same line order as inside the instance */
+    output: string;
+}
+export interface ResetPasswordRequestBody {
+    /** Have the platform generate a random password, returned only in this response */
+    generate_password?: boolean;
+    /**
+     * New root password. Exactly one of this and `generate_password`
+     * @maxLength 128
+     */
+    password?: string;
+}
+export interface ResetPasswordResponseBody {
+    /** The password generated by the platform, returned only in this response. Empty when the password was supplied in the request */
+    password: string;
+}
+export interface RebuildInstanceRequestBody {
+    generate_password?: boolean;
+    /**
+     * A public image, which must be on sale unless it is the one this instance already runs, or an available private image of this project
+     * @maxLength 64
+     */
+    image_id: string;
+    /** @maxLength 128 */
+    password?: string;
+}
+export interface RebuildInstanceResponseBody {
+    instance: InstanceResource;
+    /** Returned only in this response; store it immediately */
+    password: string;
+}
+export interface ResizeInstanceRequestBody {
+    /**
+     * Must be in the same region and availability zone as the current instance type
+     * @maxLength 64
+     */
+    instance_type_id: string;
+    checkout?: CheckoutOptions;
+    /** The `proration_date` of Billing's quote for this change, so that the order is priced from the same instant. Only for automatic checkout; deferred checkout is priced when the customer completes it. Defaults to the time of the request; it must be a whole second, not in the future and at most 10 minutes old, otherwise the request is refused with `BILLING_CHANGE_INVALID`. */
+    proration_date?: string;
+}
+export interface AttachDiskRequestBody {
+    disk_id: string;
+}
+export interface AttachFloatingIPRequestBody {
+    floating_ip_id: string;
+}
+/**
+ * `missing` means the interface no longer exists in the cloud.
+ */
+export type PortResourceStatus = (typeof PortResourceStatus)[keyof typeof PortResourceStatus];
+export declare const PortResourceStatus: {
+    readonly pending: "pending";
+    readonly available: "available";
+    readonly error: "error";
+    readonly unknown: "unknown";
+    readonly missing: "missing";
+};
+export type PortAddressState = (typeof PortAddressState)[keyof typeof PortAddressState];
+export declare const PortAddressState: {
+    readonly reserved: "reserved";
+    readonly assigned: "assigned";
+    readonly released: "released";
+    readonly unknown: "unknown";
+};
+export interface PortAddress {
+    id: string;
+    subnet_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    address: string;
+    is_primary: boolean;
+    state: PortAddressState;
+    /** @nullable */
+    assigned_at: string | null;
+    /** @nullable */
+    released_at: string | null;
+}
+export type PortAttachmentRole = (typeof PortAttachmentRole)[keyof typeof PortAttachmentRole];
+export declare const PortAttachmentRole: {
+    readonly primary: "primary";
+    readonly additional: "additional";
+};
+export type PortAttachmentState = (typeof PortAttachmentState)[keyof typeof PortAttachmentState];
+export declare const PortAttachmentState: {
+    readonly reserved: "reserved";
+    readonly attached: "attached";
+    readonly released: "released";
+    readonly unknown: "unknown";
+};
+export interface PortAttachment {
+    id: string;
+    instance_id: string;
+    port_id: string;
+    role: PortAttachmentRole;
+    delete_with_instance: boolean;
+    state: PortAttachmentState;
+    /** @nullable */
+    attached_at: string | null;
+    /** @nullable */
+    detached_at: string | null;
+    /** @nullable */
+    released_at: string | null;
+}
+export type PortOperationType = (typeof PortOperationType)[keyof typeof PortOperationType];
+export declare const PortOperationType: {
+    readonly create: "create";
+    readonly attach: "attach";
+    readonly detach: "detach";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this network interface. It is not a separate resource; once it finishes, the network interface's `operation` is null again and the network interface shows the result.
+ */
+export interface PortOperation {
+    type: PortOperationType;
+    started_at: string;
+}
+export interface PortResource {
+    id: string;
+    /** @nullable */
+    mac: string | null;
+    name: string;
+    private_network_id: string;
+    /**
+     * Floating IPv4 addresses bound to this network interface; an empty array when none are bound
+     * @nullable
+     */
+    public_ips: string[] | null;
+    addresses?: PortAddress[];
+    attachment?: PortAttachment | null;
+    /** `missing` means the interface no longer exists in the cloud. */
+    status: PortResourceStatus;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+    /** The operation in progress on this network interface, or null when none is. */
+    readonly operation: PortOperation | null;
+}
+export interface PortListResponseBody {
+    /** @nullable */
+    items: PortResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface AttachPortRequestBody {
+    port_id: string;
+}
+/**
+ * Path and query parameters of the request. Fields such as passwords are redacted
+ */
+export type OperationLogResourcePayload = {
+    [key: string]: unknown;
+};
+export interface OperationLogResource {
+    /** Name of the operation; matches the operation id of the endpoint */
+    action: string;
+    /**
+     * The user who initiated the operation. Empty when the platform performed it
+     * @nullable
+     */
+    actor: string | null;
+    /**
+     * The name this user went by at the time of the operation, recorded alongside the operation itself. It is not refreshed afterwards: the record states who acted then, and a name read today is a statement about a different moment.
+     *
+     * Null on entries recorded before this field existed, and on entries performed by the platform. An empty string means the account had no name recorded.
+     * @nullable
+     */
+    actor_name: string | null;
+    /** True when the operation was performed by the platform */
+    by_platform: boolean;
+    created_at: string;
+    /**
+     * Brief reason for the failure
+     * @nullable
+     */
+    failure: string | null;
+    id: string;
+    /** Path and query parameters of the request. Fields such as passwords are redacted */
+    payload: OperationLogResourcePayload;
+    /** @nullable */
+    region_id: string | null;
+    /** Empty for create operations: the id of the new resource is in the response, not in the request path */
+    subject_id: string;
+    subject_type: string;
+    succeeded: boolean;
+}
+export interface OperationLogListResponseBody {
+    items: OperationLogResource[];
+    pagination: OffsetPagination;
+}
+export interface CreatePortRequestBody {
+    /** @maxLength 128 */
+    name?: string;
+    /**
+     * At least one, and all must belong to the same private network
+     * @minItems 1
+     * @nullable
+     */
+    security_group_ids: string[] | null;
+    subnet_id: string;
+    /**
+     * The private address to assign. Allocated automatically when omitted
+     * @maxLength 64
+     */
+    address?: string;
+}
+export interface CreateImageRequestBody {
+    /** Captured from the system disk of this instance; data disks are not included */
+    instance_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    billing: BillingChoice;
+    checkout?: CheckoutOptions;
+}
+export interface RenameImageRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface PrivateNetworkResource {
+    cidr: string;
+    created_at: string;
+    id: string;
+    name: string;
+    region_id: string;
+    updated_at: string;
+}
+export interface PrivateNetworkListResponseBody {
+    /** @nullable */
+    items: PrivateNetworkResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface CreatePrivateNetworkRequestBody {
+    /**
+     * Must be an RFC 1918 private CIDR with a prefix length between /8 and /24, for example `10.0.0.0/16`
+     * @minLength 1
+     * @maxLength 32
+     */
+    cidr: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    region_id: string;
+}
+export interface RenamePrivateNetworkRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+/**
+ * `active` means IPv6 is fully available
+ */
+export type IPv6ResponseBodyStatus = (typeof IPv6ResponseBodyStatus)[keyof typeof IPv6ResponseBodyStatus];
+export declare const IPv6ResponseBodyStatus: {
+    readonly pending: "pending";
+    readonly active: "active";
+    readonly draining: "draining";
+};
+export interface IPv6ResponseBody {
+    /** The allocated /64 prefix; empty while IPv6 is disabled */
+    cidr: string;
+    enabled: boolean;
+    /** `active` means IPv6 is fully available */
+    status: IPv6ResponseBodyStatus;
+}
+export interface RouteResource {
+    /** System-owned peering route. Delete the peering to remove this route. */
+    peering_id?: string;
+    created_at: string;
+    description: string;
+    destination: string;
+    id: string;
+    /** Present for custom routes; peering routes expose peering_id instead. */
+    nexthop?: string;
+}
+export interface RouteListResponseBody {
+    /** @nullable */
+    items: RouteResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface CreateRouteRequestBody {
+    /** @maxLength 255 */
+    description?: string;
+    /**
+     * Destination CIDR. It cannot be `0.0.0.0/0`, nor the CIDR of a subnet of this network
+     * @minLength 1
+     * @maxLength 32
+     */
+    destination: string;
+    /**
+     * Private address of an instance; must fall inside a subnet of this private network
+     * @minLength 1
+     * @maxLength 64
+     */
+    nexthop: string;
+}
+export type SubnetResourceIpVersion = (typeof SubnetResourceIpVersion)[keyof typeof SubnetResourceIpVersion];
+export declare const SubnetResourceIpVersion: {
+    readonly NUMBER_4: 4;
+    readonly NUMBER_6: 6;
+};
+export interface SubnetResource {
+    cidr: string;
+    /** @nullable */
+    gateway_ip: string | null;
+    id: string;
+    ip_version: SubnetResourceIpVersion;
+    name: string;
+    private_network_id: string;
+}
+export interface SubnetListResponseBody {
+    /** @nullable */
+    items: SubnetResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface CreateSubnetRequestBody {
+    /**
+     * Must fall inside the CIDR of the private network and must not overlap an existing subnet
+     * @minLength 1
+     * @maxLength 32
+     */
+    cidr: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface NextFreeCidrResponseBody {
+    /** Empty when the private network has no free CIDR left for that prefix length */
+    cidr: string;
+}
+export interface SecurityGroupResource {
+    created_at: string;
+    description: string;
+    id: string;
+    /** The default security group is released with its private network and cannot be deleted individually */
+    is_default: boolean;
+    name: string;
+    private_network_id: string;
+}
+export interface SecurityGroupListResponseBody {
+    /** @nullable */
+    items: SecurityGroupResource[] | null;
+    pagination: OffsetPagination;
+}
+export interface CreateSecurityGroupRequestBody {
+    /** @maxLength 500 */
+    description?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    private_network_id: string;
+}
+export type SecurityRuleResourceDirection = (typeof SecurityRuleResourceDirection)[keyof typeof SecurityRuleResourceDirection];
+export declare const SecurityRuleResourceDirection: {
+    readonly ingress: "ingress";
+    readonly egress: "egress";
+};
+export type SecurityRuleResourceEthertype = (typeof SecurityRuleResourceEthertype)[keyof typeof SecurityRuleResourceEthertype];
+export declare const SecurityRuleResourceEthertype: {
+    readonly IPv4: "IPv4";
+    readonly IPv6: "IPv6";
+};
+export interface SecurityRuleResource {
+    created_at: string;
+    description: string;
+    direction: SecurityRuleResourceDirection;
+    ethertype: SecurityRuleResourceEthertype;
+    id: string;
+    /**
+     * Denotes the ICMP code rather than a port when the protocol is ICMP
+     * @nullable
+     */
+    port_range_max: number | null;
+    /**
+     * Denotes the ICMP type rather than a port when the protocol is ICMP
+     * @nullable
+     */
+    port_range_min: number | null;
+    /** @nullable */
+    protocol: string | null;
+    /** @nullable */
+    remote_ip_prefix: string | null;
+}
+export interface SecurityRuleListResponseBody {
+    /** @nullable */
+    items: SecurityRuleResource[] | null;
+    pagination: OffsetPagination;
+}
+export type CreateSecurityRuleRequestBodyDirection = (typeof CreateSecurityRuleRequestBodyDirection)[keyof typeof CreateSecurityRuleRequestBodyDirection];
+export declare const CreateSecurityRuleRequestBodyDirection: {
+    readonly ingress: "ingress";
+    readonly egress: "egress";
+};
+export type CreateSecurityRuleRequestBodyEthertype = (typeof CreateSecurityRuleRequestBodyEthertype)[keyof typeof CreateSecurityRuleRequestBodyEthertype];
+export declare const CreateSecurityRuleRequestBodyEthertype: {
+    readonly IPv4: "IPv4";
+    readonly IPv6: "IPv6";
+};
+export interface CreateSecurityRuleRequestBody {
+    /** @maxLength 255 */
+    description?: string;
+    direction: CreateSecurityRuleRequestBodyDirection;
+    ethertype: CreateSecurityRuleRequestBodyEthertype;
+    /**
+     * Denotes the ICMP code (0–255) rather than a port when the protocol is ICMP
+     * @nullable
+     */
+    port_range_max?: number | null;
+    /**
+     * Denotes the ICMP type (0–255) rather than a port when the protocol is ICMP
+     * @nullable
+     */
+    port_range_min?: number | null;
+    /**
+     * For example `tcp`, `udp`, `icmp` or `ipv6-icmp`. All protocols when omitted
+     * @maxLength 16
+     */
+    protocol?: string;
+    /**
+     * Equivalent to `0.0.0.0/0` or `::/0` when omitted
+     * @maxLength 64
+     */
+    remote_ip_prefix?: string;
+}
+/**
+ * inactive has no purchase; pending is a first purchase whose order has not been accepted;
+ * provisioning is a first purchase being activated; active permits creation within available
+ * capacity; suspended refuses new creation; failed means the first purchase failed, as
+ * failure_reason states. A pending change keeps the current status and limit until it is applied.
+ */
+export type SnapshotQuotaStatus = (typeof SnapshotQuotaStatus)[keyof typeof SnapshotQuotaStatus];
+export declare const SnapshotQuotaStatus: {
+    readonly inactive: "inactive";
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly failed: "failed";
+};
+/**
+ * Why the first purchase failed; null unless status is failed. A failed change leaves the current
+ * limit in force and clears pending_limit; its Checkout Session or order shows the outcome.
+ * @nullable
+ */
+export type SnapshotQuotaFailureReason = (typeof SnapshotQuotaFailureReason)[keyof typeof SnapshotQuotaFailureReason] | null;
+export declare const SnapshotQuotaFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * Snapshot count capacity for the authenticated project and one region, projected from its
+ * effective quota purchase and Compute's actual holdings. This is not a Billing Allowance:
+ * creation occupies capacity and confirmed deletion releases it rather than consuming a grant.
+ * Pending purchases never increase effective capacity before commercial acceptance and activation.
+ */
+export interface SnapshotQuota {
+    region_id: string;
+    /**
+     * inactive has no purchase; pending is a first purchase whose order has not been accepted;
+     * provisioning is a first purchase being activated; active permits creation within available
+     * capacity; suspended refuses new creation; failed means the first purchase failed, as
+     * failure_reason states. A pending change keeps the current status and limit until it is applied.
+     */
+    status: SnapshotQuotaStatus;
+    /**
+     * Effective maximum concurrent snapshot count. Zero until the first purchase is activated.
+     * @minimum 0
+     */
+    limit: number;
+    /**
+     * Held and reserved snapshot slots, including pending creation and unconfirmed cleanup.
+     * @minimum 0
+     */
+    used: number;
+    /**
+     * max(limit - used, 0), or zero while creation is not permitted.
+     * @minimum 0
+     */
+    available: number;
+    /**
+     * The order establishing the currently associated quota purchase, including an initial pending purchase once its checkout completes.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * The quota purchase's Billing subscription, not an individual snapshot subscription.
+     * May still be pending on an initial purchase; an existing subscription remains associated
+     * until a replacement quota is activated. Null when no purchase has been recorded.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The billing choice of the associated quota purchase, as given when it was bought. A change of an existing purchase has to give the same choice. Null when no purchase has been recorded. */
+    billing: BillingChoice | null;
+    /** The subscription a cancellation through Billing has to cover to release this snapshot quota. A subscription that has ended is not listed, and the list is empty when no subscription pays for the quota. */
+    release_subscription_ids: string[];
+    /**
+     * Target count awaiting checkout or activation; null when no purchase is pending.
+     * @minimum 1
+     * @nullable
+     */
+    pending_limit: number | null;
+    /**
+     * Checkout Session of the pending initial purchase or change; null when none is pending.
+     * @nullable
+     */
+    pending_checkout_session_id: string | null;
+    /**
+     * Order for the pending initial purchase or change once its checkout completes; null otherwise.
+     * @nullable
+     */
+    pending_order_id: string | null;
+    /**
+     * Why the first purchase failed; null unless status is failed. A failed change leaves the current
+     * limit in force and clears pending_limit; its Checkout Session or order shows the outcome.
+     * @nullable
+     */
+    failure_reason: SnapshotQuotaFailureReason;
+}
+export interface SetSnapshotQuotaRequestBody {
+    /**
+     * Desired total concurrent snapshot count for this project and region, not additional slots.
+     * @minimum 1
+     */
+    limit: number;
+    billing: BillingChoice;
+    checkout?: CheckoutOptions;
+    /** The `proration_date` of Billing's quote for this change, so that the order is priced from the same instant. Only for automatic checkout; deferred checkout is priced when the customer completes it. Defaults to the time of the request; it must be a whole second, not in the future and at most 10 minutes old, otherwise the request is refused with `BILLING_CHANGE_INVALID`. */
+    proration_date?: string;
+}
+export interface SetSnapshotQuotaResponseBody {
+    snapshot_quota: SnapshotQuota;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * `pending` once a quota slot is reserved, `provisioning` while the snapshot is taken, then `available`. `failed` means the snapshot was not created; its slot is released once no snapshot data remains. `missing` means the snapshot no longer exists in the cloud.
+ */
+export type SnapshotResourceStatus = (typeof SnapshotResourceStatus)[keyof typeof SnapshotResourceStatus];
+export declare const SnapshotResourceStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly available: "available";
+    readonly deleted: "deleted";
+    readonly failed: "failed";
+    readonly error: "error";
+    readonly missing: "missing";
+};
+/**
+ * `restore`: a disk is being reverted to this snapshot or created from it.
+ */
+export type SnapshotOperationType = (typeof SnapshotOperationType)[keyof typeof SnapshotOperationType];
+export declare const SnapshotOperationType: {
+    readonly create: "create";
+    readonly restore: "restore";
+    readonly delete: "delete";
+};
+/**
+ * An operation still running on this snapshot. It is not a separate resource; once it finishes, the snapshot's `operation` is null again and the snapshot shows the result.
+ */
+export interface SnapshotOperation {
+    /** `restore`: a disk is being reverted to this snapshot or created from it. */
+    type: SnapshotOperationType;
+    started_at: string;
+}
+/**
+ * A snapshot, created within this project's purchased regional snapshot quota. It has no order, price or Billing subscription of its own.
+ */
+export interface SnapshotResource {
+    /** A disk restored from this snapshot must reside in this availability zone */
+    availability_zone_id: string;
+    created_at: string;
+    disk_id: string;
+    id: string;
+    name: string;
+    region_id: string;
+    /** Capacity of the source disk when the snapshot was created. A disk restored from it cannot be smaller */
+    size_gb: number;
+    /** `pending` once a quota slot is reserved, `provisioning` while the snapshot is taken, then `available`. `failed` means the snapshot was not created; its slot is released once no snapshot data remains. `missing` means the snapshot no longer exists in the cloud. */
+    status: SnapshotResourceStatus;
+    /** The operation in progress on this snapshot, or null when none is. */
+    readonly operation: SnapshotOperation | null;
+    /** @minimum 1 */
+    generation: number;
+    /** @nullable */
+    observed_at: string | null;
+}
+export interface SnapshotListResponseBody {
+    /** @nullable */
+    items: SnapshotResource[] | null;
+    pagination: OffsetPagination;
+}
+/**
+ * Create one snapshot using existing project-and-region count quota. The region is taken from
+ * disk_id. Purchase or adjust quota separately; this request has no checkout or price selection.
+ */
+export interface CreateSnapshotRequestBody {
+    disk_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface RenameSecurityGroupRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+export interface RenameSnapshotRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+/**
+ * `inactive` has never been activated or its subscription has ended; `pending` awaits acceptance of its order; `provisioning` is being activated; `active` accepts new backups; `suspended` refuses new backups and keeps existing ones; `failed` means the activation failed, as `failure_reason` states.
+ */
+export type BackupServiceStatus = (typeof BackupServiceStatus)[keyof typeof BackupServiceStatus];
+export declare const BackupServiceStatus: {
+    readonly inactive: "inactive";
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly failed: "failed";
+};
+/**
+ * Why the purchase failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means it failed after the order was accepted, and its charge is refunded.
+ * @nullable
+ */
+export type BackupServiceFailureReason = (typeof BackupServiceFailureReason)[keyof typeof BackupServiceFailureReason] | null;
+export declare const BackupServiceFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * The backup service of a project in one region. Retained backup capacity beyond what active capacity packs cover is metered on it.
+ */
+export interface BackupService {
+    region_id: string;
+    /** `inactive` has never been activated or its subscription has ended; `pending` awaits acceptance of its order; `provisioning` is being activated; `active` accepts new backups; `suspended` refuses new backups and keeps existing ones; `failed` means the activation failed, as `failure_reason` states. */
+    status: BackupServiceStatus;
+    /**
+     * Why the purchase failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means it failed after the order was accepted, and its charge is refunded.
+     * @nullable
+     */
+    failure_reason: BackupServiceFailureReason;
+    /**
+     * The Checkout Session of the activation; null before an activation is requested.
+     * @nullable
+     */
+    checkout_session_id: string | null;
+    /**
+     * The order that activated the service; null until the activation's checkout completes.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * The Billing subscription that backup usage is billed under; null until the activation's checkout completes.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The subscription a cancellation through Billing has to cover to release this backup service. A subscription that has ended is not listed, and the list is empty when no subscription pays for the service. */
+    release_subscription_ids: string[];
+    /**
+     * The total `capacity_gib` of the backups retained in this region.
+     * @minimum 0
+     */
+    retained_capacity_gib: number;
+    /**
+     * The total `capacity_gib` of the active capacity packs in this region; this much retained capacity is covered each hour.
+     * @minimum 0
+     */
+    pack_capacity_gib: number;
+}
+export interface CreateBackupServiceRequestBody {
+    checkout?: CheckoutOptions;
+}
+export interface CreateBackupServiceResponseBody {
+    backup_service: BackupService;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * `pending` awaits acceptance of its order; `provisioning` is being applied; `active` covers backup capacity; `ended` no longer does because its subscription has ended; `failed` means the purchase failed, as `failure_reason` states.
+ */
+export type BackupCapacityPackStatus = (typeof BackupCapacityPackStatus)[keyof typeof BackupCapacityPackStatus];
+export declare const BackupCapacityPackStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly ended: "ended";
+    readonly failed: "failed";
+};
+/**
+ * Why the purchase failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means it failed after the order was accepted, and its charge is refunded.
+ * @nullable
+ */
+export type BackupCapacityPackFailureReason = (typeof BackupCapacityPackFailureReason)[keyof typeof BackupCapacityPackFailureReason] | null;
+export declare const BackupCapacityPackFailureReason: {
+    readonly checkout_expired: "checkout_expired";
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * Backup capacity for one region, sold by Compute and bought for a term through its own Billing subscription. Compute applies its coverage to backup usage; it is not a Billing allowance or credit.
+ */
+export interface BackupCapacityPack {
+    id: string;
+    region_id: string;
+    /** @minimum 1 */
+    capacity_gib: number;
+    /** `pending` awaits acceptance of its order; `provisioning` is being applied; `active` covers backup capacity; `ended` no longer does because its subscription has ended; `failed` means the purchase failed, as `failure_reason` states. */
+    status: BackupCapacityPackStatus;
+    /**
+     * Why the purchase failed; null unless `status` is `failed`. `checkout_expired` means checkout was not completed before its Checkout Session expired. `provisioning_failed` means it failed after the order was accepted, and its charge is refunded.
+     * @nullable
+     */
+    failure_reason: BackupCapacityPackFailureReason;
+    /**
+     * The Billing Checkout Session that bought the pack. Null when the pack was not bought through one.
+     * @nullable
+     */
+    checkout_session_id: string | null;
+    /**
+     * Null until the pack's checkout completes.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * The pack's Billing subscription, through which it is renewed or canceled.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The subscription a cancellation through Billing has to cover to release this capacity pack. A subscription that has ended is not listed, and the list is empty when no subscription pays for the pack. */
+    release_subscription_ids: string[];
+    created_at: string;
+}
+export interface BackupCapacityPackListResponseBody {
+    items: BackupCapacityPack[];
+    pagination: OffsetPagination;
+}
+export interface CreateBackupCapacityPackRequestBody {
+    /** @minimum 1 */
+    capacity_gib: number;
+    billing: BillingChoice;
+    checkout?: CheckoutOptions;
+}
+export interface CreateBackupCapacityPackResponseBody {
+    backup_capacity_pack: BackupCapacityPack;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * The new disk, `pending` until its order is accepted, and its Checkout Session. Also returned for a disk restored
+ * from a backup.
+ */
+export interface CreateDiskResponseBody {
+    disk: DiskResource;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * The new private image, `pending` until its order is accepted, and its Checkout Session.
+ */
+export interface CreateImageResponseBody {
+    image: ImageResource;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * The new floating IP, `pending` until its order is accepted, and its Checkout Session. `address` is null until
+ * the address is allocated.
+ */
+export interface AllocateFloatingIPResponseBody {
+    floating_ip: FloatingIPResource;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * The disk, still at its current size, and the Checkout Session for the resize.
+ */
+export interface ResizeDiskResponseBody {
+    disk: DiskResource;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * The instance, still on its current type, and the Checkout Session for the resize. The instance keeps its ID, and
+ * its current subscription remains in force until the resize is applied.
+ */
+export interface ResizeInstanceResponseBody {
+    instance: InstanceResource;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+/**
+ * The floating IP, still at its current bandwidth, and the Checkout Session for the change.
+ */
+export interface SetFloatingIPBandwidthResponseBody {
+    floating_ip: FloatingIPResource;
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+}
+export interface PowerRequest {
+    /** @minimum 1 */
+    expected_generation?: number;
+}
+export interface DiskAttachmentList {
+    items: DiskAttachment[];
+    pagination: OffsetPagination;
+}
+export interface PortAttachmentList {
+    items: PortAttachment[];
+    pagination: OffsetPagination;
+}
+/**
+ * The new instances, `pending` until their order is accepted, and the Checkout Session they share.
+ */
+export interface LaunchInstanceResponseBody {
+    /**
+     * One instance per requested instance, in request order. Their IDs stay the same through checkout and
+     * creation.
+     * @minItems 1
+     * @maxItems 20
+     */
+    instances: InstanceResource[];
+    /** The Billing Checkout Session of this purchase. With deferred checkout, the customer completes it in Billing. */
+    checkout_session_id: string;
+    /**
+     * The order created when checkout completes, at once for automatic checkout; null until then.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * Generated login password, returned only by this response. Null when no password was generated.
+     * @nullable
+     */
+    password: string | null;
+}
+export interface IPv4PoolResource {
+    id: string;
+    region_id: string;
+    name: string;
+    /** A floating IP from this pool is one order line, its quantity the bandwidth in Mbps. Metered, it reads the address and, under the region alone, the bandwidth. */
+    billing: BillingComponent;
+}
+export interface IPv4PoolListResponseBody {
+    items: IPv4PoolResource[];
+    pagination: OffsetPagination;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+/**
+ * The request conflicts with the current state of a resource or offering it involves. `COMPUTE_RESOURCE_BUSY`
+ * means a resource has an operation in progress: `meta.resource_type`, such as `instance` or `floating_ip`, and
+ * `meta.resource_id` name it, and `meta.operation` is the type of that operation, as in its `operation` field.
+ * Retry once it has finished. Other codes, such as `BILLING_OPTION_UNAVAILABLE`, are described where they
+ * apply.
+ */
+export type ConflictResponse = Error;
+export type ListBackupsParams = {
+    /**
+     * Return only the backups of this disk
+     */
+    disk_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListDiskTypesParams = {
+    region_id?: string;
+    /**
+     * Filter by intended purchase use. Omit to include both system and data disk types.
+     */
+    purpose?: DiskTypePurpose;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListImagesParams = {
+    /**
+     * Return only the images of this region
+     */
+    region_id?: string;
+    /**
+     * Return only public or only private images. Both are returned when omitted
+     */
+    visibility?: ImageVisibility;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListInstanceTypesParams = {
+    region_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListRegionsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListAvailabilityZonesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListDisksParams = {
+    region_id?: string;
+    /**
+     * Supplied together with `region_code` to filter attachable disks
+     */
+    availability_zone_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListFloatingIpsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListInstancesParams = {
+    /**
+     * A label to filter by, written as `key:value`
+     * @maxLength 128
+     */
+    label?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type GetInstanceConsoleOutputParams = {
+    /**
+     * Number of trailing lines to return; 0 returns the entire output
+     * @minimum 0
+     * @maximum 10000
+     */
+    lines?: number;
+};
+export type ListInstanceDisksParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListInstancePortsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListOperationLogsParams = {
+    /**
+     * Return a single kind of operation; the value matches the operation id of the endpoint
+     * @maxLength 64
+     */
+    action?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListPortsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListPrivateNetworksParams = {
+    /**
+     * Returns every region when omitted
+     */
+    region_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListRoutesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListSubnetsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type SuggestSubnetCidrParams = {
+    /**
+     * @minimum 16
+     * @maximum 30
+     */
+    prefix_length?: number;
+};
+export type ListSecurityGroupsParams = {
+    region_id?: string;
+    /**
+     * Return only the security groups of this private network
+     */
+    private_network_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListSecurityGroupRulesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListBackupCapacityPacksParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListSnapshotsParams = {
+    /**
+     * Return only the snapshots of this disk
+     */
+    disk_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListIpv4PoolsParams = {
+    region_id?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListPeeringsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};