@leaflow/sdk 0.107.0 → 0.109.0

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

@@ -0,0 +1,2857 @@
+/**
+ * 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 a PlacedOrder. They are readable at once and start as `pending`: 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 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 order in Billing for checkout and payment progress.
+ * - **Pricing.** Catalog items, such as instance types, disk types and public IP pools, carry `pricing`: the prepaid and postpaid options Billing offers for them, in the currency of the project's current billing account, or null when the project has no billing account. They are list amounts before promotion codes, not a checkout guarantee. A purchase chooses one option with `billing`, which applies to all of its components. Every purchase and change has a quote operation beside it, at the same path followed by `/quote`, which returns what checkout would collect without ordering anything.
+ * - **Checkout.** Omit `checkout` for automatic checkout, which pays from eligible credit grants and balance when the order is placed; 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` and nothing is created until checkout is confirmed and paid through Billing. An order whose total is zero, such as a postpaid purchase with nothing due now, completes checkout at placement in either mode and proceeds to provisioning.
+ * - **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 order is placed until it is applied or its order is canceled, including while it awaits checkout. Renaming and replacing labels or notes are not operations and are accepted at any time.
+ * - **Billing relationships.** A purchased resource records 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;
+}
+/**
+ * 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;
+}
+export type BillingChoiceMode = (typeof BillingChoiceMode)[keyof typeof BillingChoiceMode];
+export declare const BillingChoiceMode: {
+    readonly prepaid: "prepaid";
+    readonly postpaid: "postpaid";
+};
+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. Prepaid requires period and termination_policy; postpaid refuses both. Components in one instance order must use the same mode and period, while their termination policies may differ.
+ */
+export interface BillingChoice {
+    mode: BillingChoiceMode;
+    period?: BillingPeriod;
+    termination_policy?: TerminationPolicy;
+}
+/**
+ * automatic confirms checkout with applicable account discounts and collects payment 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 a pending_checkout order for subsequent confirmation and payment through Billing.
+ * No new discount redemption or payment is made when the order is created. An order whose total is
+ * zero, with nothing to pay or discount, completes checkout at placement in either mode.
+ */
+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. Omitting this object or mode selects
+ * automatic checkout. Each purchase creates its own order. Promotion codes are supplied only to
+ * Billing quote and checkout operations. 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, confirm the amount through Billing.
+     */
+    expected_amount?: Money & 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;
+}
+/**
+ * `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`. `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 order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+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;
+}
+/**
+ * `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 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`. `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;
+}
+/**
+ * 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 type PricingOptionMode = (typeof PricingOptionMode)[keyof typeof PricingOptionMode];
+export declare const PricingOptionMode: {
+    readonly prepaid: "prepaid";
+    readonly postpaid: "postpaid";
+};
+/**
+ * What the amounts are for: one `item`, such as an instance or an address; one `gib` of size or capacity; one `mbps` of bandwidth; or one `snapshot` slot.
+ */
+export type PricingOptionQuantityUnit = (typeof PricingOptionQuantityUnit)[keyof typeof PricingOptionQuantityUnit];
+export declare const PricingOptionQuantityUnit: {
+    readonly item: "item";
+    readonly gib: "gib";
+    readonly mbps: "mbps";
+    readonly snapshot: "snapshot";
+};
+/**
+ * Postpaid only; null for prepaid. The time unit of `unit_amount`.
+ * @nullable
+ */
+export type PricingOptionUnit = (typeof PricingOptionUnit)[keyof typeof PricingOptionUnit] | null;
+export declare const PricingOptionUnit: {
+    readonly hour: "hour";
+};
+/**
+ * What canceling does under this option: `immediate` ends the service at once, with any refund following the option's terms; `period_end` ends it at the end of the paid period. Null means no explicit policy was recorded; it must not be interpreted as immediate.
+ * @nullable
+ */
+export type PricingOptionTerminationPolicy = (typeof PricingOptionTerminationPolicy)[keyof typeof PricingOptionTerminationPolicy] | null;
+export declare const PricingOptionTerminationPolicy: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * One way to buy an item. Choose it by giving its mode, period and explicit prepaid termination_policy as billing.
+ */
+export interface PricingOption {
+    mode: PricingOptionMode;
+    /** The term of a prepaid option; null for postpaid. */
+    period: BillingPeriod | null;
+    /** What the amounts are for: one `item`, such as an instance or an address; one `gib` of size or capacity; one `mbps` of bandwidth; or one `snapshot` slot. */
+    quantity_unit: PricingOptionQuantityUnit;
+    /**
+     * Prepaid only; null for postpaid. The amount for one period, per quantity unit.
+     * @nullable
+     */
+    amount: string | null;
+    /**
+     * Prepaid only; null for postpaid. `amount` spread over the months of the period.
+     * @nullable
+     */
+    monthly_amount: string | null;
+    /**
+     * Prepaid only. How much lower `monthly_amount` is than that of the shortest prepaid period of the same item, as a decimal percentage. Null for that shortest period and for postpaid.
+     * @nullable
+     */
+    saving_percent: string | null;
+    /**
+     * Postpaid only; null for prepaid. The amount for one `unit` of time, per quantity unit.
+     * @nullable
+     */
+    unit_amount: string | null;
+    /**
+     * Postpaid only; null for prepaid. The time unit of `unit_amount`.
+     * @nullable
+     */
+    unit: PricingOptionUnit;
+    /**
+     * What canceling does under this option: `immediate` ends the service at once, with any refund following the option's terms; `period_end` ends it at the end of the paid period. Null means no explicit policy was recorded; it must not be interpreted as immediate.
+     * @nullable
+     */
+    termination_policy: PricingOptionTerminationPolicy;
+}
+/**
+ * How a catalog item can be bought, calculated by Billing in the currency of the project's current billing account. These are list amounts before promotion codes, not a checkout guarantee; quote a purchase for its exact total.
+ */
+export interface Pricing {
+    currency: string;
+    /** One entry per way the item can be bought. Empty when it cannot be bought in this currency. */
+    options: PricingOption[];
+}
+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;
+    /** How a disk of this type can be bought, per GiB. Null when the project has no billing account. */
+    readonly pricing: Pricing | null;
+}
+export interface DiskTypeListResponseBody {
+    /** @nullable */
+    items: DiskTypeResource[] | null;
+    pagination: OffsetPagination;
+}
+/**
+ * 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`. `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 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 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`. `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 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;
+    /** How an instance of this type can be bought, per instance. Null when the project has no billing account. */
+    readonly pricing: Pricing | null;
+}
+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;
+    /** How private image storage in this region is billed, per GiB. Null when the project has no billing account. */
+    readonly private_image_pricing: Pricing | 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 this change's quote, so that the order is priced from the same instant. 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;
+}
+/**
+ * `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`. `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 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 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`. `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 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 as the pool's `bandwidth_pricing` shows,
+     * 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 this change's quote, so that the order is priced from the same instant. 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;
+}
+/**
+ * Your own classification of this instance, as key-value pairs. Empty when never set
+ */
+export type InstanceResourceLabels = {
+    [key: string]: 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";
+};
+/**
+ * Why creation failed; null unless `status` is `failed`. `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 order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * @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";
+};
+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;
+}
+/**
+ * `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 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`. `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 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 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 this change's quote, so that the order is priced from the same instant. 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;
+}
+/**
+ * The fields of `CreateImageRequestBody` that decide the price
+ */
+export interface CreateImageQuoteRequestBody {
+    /** The instance whose system disk would be captured */
+    instance_id: string;
+    billing: BillingChoice;
+}
+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 order shows the outcome.
+ * @nullable
+ */
+export type SnapshotQuotaFailureReason = (typeof SnapshotQuotaFailureReason)[keyof typeof SnapshotQuotaFailureReason] | null;
+export declare const SnapshotQuotaFailureReason: {
+    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.
+     * @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;
+    /**
+     * Order for the pending initial purchase or change; null when none is pending.
+     * @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 order shows the outcome.
+     * @nullable
+     */
+    failure_reason: SnapshotQuotaFailureReason;
+    /** How snapshot quota in this region can be bought, per snapshot slot. Null when the project has no billing account. */
+    readonly pricing: Pricing | null;
+}
+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 this change's quote, so that the order is priced from the same instant. 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;
+}
+/**
+ * Identifies the purchase. Read the order for purchase progress and its invoice for amounts and payment status.
+ */
+export interface PlacedOrder {
+    /**
+     * The invoice for this purchase, which may still be a draft awaiting checkout. Null when no invoice has been created. Its presence or absence does not establish whether delivery may begin.
+     * @nullable
+     */
+    invoice_id: string | null;
+    /** The order, including for purchases without an immediate charge. Payment alone does not imply that the service has completed delivery. */
+    order_id: string;
+}
+export interface SetSnapshotQuotaResponseBody {
+    snapshot_quota: SnapshotQuota;
+    order: PlacedOrder;
+}
+/**
+ * `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`. `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 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`. `provisioning_failed` means it failed after the order was accepted, and its charge is refunded.
+     * @nullable
+     */
+    failure_reason: BackupServiceFailureReason;
+    /**
+     * The order that activated the service; null before an activation is requested.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * The Billing subscription that backup usage is billed under; null before an activation is requested.
+     * @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
+     */
+    prepaid_capacity_gib: number;
+    /** The postpaid usage price of backups in this region. Null when the project has no billing account. */
+    readonly pricing: Pricing | null;
+    /** The prepaid options of capacity packs in this region, per GiB. Null when the project has no billing account. */
+    readonly capacity_pack_pricing: Pricing | null;
+}
+export interface CreateBackupServiceRequestBody {
+    checkout?: CheckoutOptions;
+}
+export interface CreateBackupServiceResponseBody {
+    backup_service: BackupService;
+    order: PlacedOrder;
+}
+/**
+ * `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`. `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 order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+    readonly provisioning_failed: "provisioning_failed";
+};
+/**
+ * Prepaid 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`. `provisioning_failed` means it failed after the order was accepted, and its charge is refunded.
+     * @nullable
+     */
+    failure_reason: BackupCapacityPackFailureReason;
+    order_id: string;
+    /**
+     * 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;
+    order: PlacedOrder;
+}
+/**
+ * The request of `launch-instance`, without `checkout`.
+ */
+export interface LaunchInstanceQuoteRequestBody {
+    /**
+     * 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;
+    boot_disk: BootDisk;
+    floating_ip?: NewFloatingIP;
+}
+/**
+ * The request of `create-disk`, without `checkout`.
+ */
+export interface CreateDiskQuoteRequestBody {
+    /**
+     * 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;
+}
+/**
+ * The request of `restore-backup`, without `checkout`.
+ */
+export interface RestoreBackupQuoteRequestBody {
+    /**
+     * 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;
+}
+/**
+ * The request of `allocate-floating-ip`, without `checkout`.
+ */
+export interface AllocateFloatingIPQuoteRequestBody {
+    /**
+     * 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 as the pool's `bandwidth_pricing` shows,
+     * 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;
+}
+/**
+ * The request of `set-snapshot-quota`, without `checkout` and `proration_date`.
+ */
+export interface SetSnapshotQuotaQuoteRequestBody {
+    /**
+     * Desired total concurrent snapshot count for this project and region, not additional slots.
+     * @minimum 1
+     */
+    limit: number;
+    billing: BillingChoice;
+}
+/**
+ * The request of `create-backup-capacity-pack`, without `checkout`.
+ */
+export interface CreateBackupCapacityPackQuoteRequestBody {
+    /** @minimum 1 */
+    capacity_gib: number;
+    billing: BillingChoice;
+}
+/**
+ * The request of `resize-instance`, without `checkout` and `proration_date`.
+ */
+export interface ResizeInstanceQuoteRequestBody {
+    /**
+     * Must be in the same region and availability zone as the current instance type
+     * @maxLength 64
+     */
+    instance_type_id: string;
+}
+/**
+ * The request of `resize-disk`, without `checkout` and `proration_date`.
+ */
+export interface ResizeDiskQuoteRequestBody {
+    /**
+     * Must be larger than the current capacity
+     * @minimum 1
+     */
+    size_gb: number;
+}
+/**
+ * The request of `set-floating-ip-bandwidth`, without `checkout` and `proration_date`.
+ */
+export interface SetFloatingIPBandwidthQuoteRequestBody {
+    /**
+     * Applied to both directions
+     * @minimum 1
+     */
+    bandwidth_mbps: number;
+}
+/**
+ * One calculated purchase line. Fixed purchase amounts are rounded as checkout rounds them.
+ * A line without an immediate charge has zero checkout amounts. unit_amount remains null when
+ * no single unit price applies; an unrequested usage estimate remains null.
+ */
+export interface QuoteItem {
+    plan_name: string;
+    /**
+     * Unit price before discounts, with tax included only where the price includes it. Null when
+     * no single unit price applies, such as tiered or multiple-rate pricing or an immediate change.
+     */
+    unit_amount: Money | null;
+    /** The quantity priced. */
+    quantity: string;
+    /**
+     * Before discounts, including any setup charges. Contains tax only where the price includes it.
+     * Zero for an item with no immediate charge.
+     */
+    amount: Money;
+    /** Total reduction on this line, including any committed recurring discount. */
+    discount_amount: Money;
+    /** Tax on the discounted amount, including any tax already contained in that amount. */
+    tax_amount: Money;
+    /** The part of tax_amount already contained in amount minus discount_amount. */
+    tax_included_amount: Money;
+    /** amount minus discount_amount plus tax_amount minus tax_included_amount. */
+    total: Money;
+    /**
+     * Projected charge for this line's future usage over the period stated by the quoting operation,
+     * at current rates, before discounts and tax and not rounded. Not part of amount or total and
+     * not collected at checkout. Null when no usage estimate is requested for this line.
+     */
+    estimated_usage_amount: Money | null;
+    currency: string;
+}
+/**
+ * A price preview for the purchase described by a service, calculated by Billing. Nothing is saved,
+ * charged or reserved, and no discount redemption is consumed. Account discounts and tax are
+ * evaluated as for automatic checkout. Promotion codes are evaluated through Billing quote operations.
+ * All amounts use currency. This preview does not lock prices or guarantee discount availability.
+ * Success includes complete checkout amounts and every requested usage estimate. If any item or
+ * requested usage estimate cannot be calculated, the operation returns its existing structured
+ * error response; it never returns a partial quote with HTTP 200.
+ */
+export interface Quote {
+    /** One line for each item the purchase would order, in the order it would order them. */
+    items: QuoteItem[];
+    /**
+     * Sum of line amounts before discounts, less tax already included in the discounted line
+     * amounts, as on an invoice.
+     */
+    subtotal: Money;
+    /** Sum of line discounts. */
+    discount_amount: Money;
+    /** Sum of tax on the discounted line amounts. */
+    tax_amount: Money;
+    /**
+     * subtotal minus discount_amount plus tax_amount: what checkout collects, before applying
+     * credit grants or balance. Equals the sum of line totals and excludes estimated_usage_amount.
+     */
+    total: Money;
+    /**
+     * Sum of the lines' estimated_usage_amount. A projection, not part of total and not collected at
+     * checkout. Null when no usage estimate is requested.
+     */
+    estimated_usage_amount: Money | null;
+    currency: string;
+    /**
+     * Changes only; null otherwise. The instant the change is priced from. Pass it with the change so the
+     * order is priced from the same instant.
+     * @nullable
+     */
+    proration_date: string | null;
+    /**
+     * Changes that lower the price only; null otherwise. What the change would return to the original
+     * payment sources, including the tax paid on it. total is zero for such a change.
+     */
+    refundable_amount: Money | null;
+}
+/**
+ * The new disk, `pending` until its order is accepted, and the order. Also returned for a disk restored
+ * from a backup.
+ */
+export interface CreateDiskResponseBody {
+    disk: DiskResource;
+    order: PlacedOrder;
+}
+/**
+ * The new private image, `pending` until its order is accepted, and the order.
+ */
+export interface CreateImageResponseBody {
+    image: ImageResource;
+    order: PlacedOrder;
+}
+/**
+ * The new floating IP, `pending` until its order is accepted, and the order. `address` is null until
+ * the address is allocated.
+ */
+export interface AllocateFloatingIPResponseBody {
+    floating_ip: FloatingIPResource;
+    order: PlacedOrder;
+}
+/**
+ * The disk, still at its current size, and the order for the resize.
+ */
+export interface ResizeDiskResponseBody {
+    disk: DiskResource;
+    order: PlacedOrder;
+}
+/**
+ * The instance, still on its current type, and the order 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;
+    order: PlacedOrder;
+}
+/**
+ * The floating IP, still at its current bandwidth, and the order for the change.
+ */
+export interface SetFloatingIPBandwidthResponseBody {
+    floating_ip: FloatingIPResource;
+    order: PlacedOrder;
+}
+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 order 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[];
+    order: PlacedOrder;
+    /**
+     * 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;
+    /** How an address from this pool can be bought, per address. Null when the project has no billing account. */
+    readonly pricing: Pricing | null;
+    /** How the bandwidth of an address from this pool is billed, per Mbit/s. It is bought in the same purchase as the address, with the same billing choice. Null when the project has no billing account. */
+    readonly bandwidth_pricing: Pricing | null;
+}
+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;
+};