@leaflow/sdk 0.107.0 → 0.108.0

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

@@ -0,0 +1,2804 @@
+/**
+ * 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
+ */
+import type { AllocateFloatingIPQuoteRequestBody } from "./models/allocateFloatingIPQuoteRequestBody.js";
+import type { AllocateFloatingIPRequestBody } from "./models/allocateFloatingIPRequestBody.js";
+import type { AllocateFloatingIPResponseBody } from "./models/allocateFloatingIPResponseBody.js";
+import type { AttachDiskRequestBody } from "./models/attachDiskRequestBody.js";
+import type { AttachFloatingIPRequestBody } from "./models/attachFloatingIPRequestBody.js";
+import type { AttachPortRequestBody } from "./models/attachPortRequestBody.js";
+import type { BackupCapacityPackListResponseBody } from "./models/backupCapacityPackListResponseBody.js";
+import type { BackupListResponseBody } from "./models/backupListResponseBody.js";
+import type { BackupResource } from "./models/backupResource.js";
+import type { BackupService } from "./models/backupService.js";
+import type { BindFloatingIPRequestBody } from "./models/bindFloatingIPRequestBody.js";
+import type { CommandResultResponseBody } from "./models/commandResultResponseBody.js";
+import type { ConflictResponse } from "./models/conflictResponse.js";
+import type { ConsoleOutputResponseBody } from "./models/consoleOutputResponseBody.js";
+import type { ConsoleResponseBody } from "./models/consoleResponseBody.js";
+import type { CreateBackupCapacityPackQuoteRequestBody } from "./models/createBackupCapacityPackQuoteRequestBody.js";
+import type { CreateBackupCapacityPackRequestBody } from "./models/createBackupCapacityPackRequestBody.js";
+import type { CreateBackupCapacityPackResponseBody } from "./models/createBackupCapacityPackResponseBody.js";
+import type { CreateBackupRequestBody } from "./models/createBackupRequestBody.js";
+import type { CreateBackupServiceRequestBody } from "./models/createBackupServiceRequestBody.js";
+import type { CreateBackupServiceResponseBody } from "./models/createBackupServiceResponseBody.js";
+import type { CreateDiskQuoteRequestBody } from "./models/createDiskQuoteRequestBody.js";
+import type { CreateDiskRequestBody } from "./models/createDiskRequestBody.js";
+import type { CreateDiskResponseBody } from "./models/createDiskResponseBody.js";
+import type { CreateImageQuoteRequestBody } from "./models/createImageQuoteRequestBody.js";
+import type { CreateImageRequestBody } from "./models/createImageRequestBody.js";
+import type { CreateImageResponseBody } from "./models/createImageResponseBody.js";
+import type { CreatePeeringRequestBody } from "./models/createPeeringRequestBody.js";
+import type { CreatePortRequestBody } from "./models/createPortRequestBody.js";
+import type { CreatePrivateNetworkRequestBody } from "./models/createPrivateNetworkRequestBody.js";
+import type { CreateRouteRequestBody } from "./models/createRouteRequestBody.js";
+import type { CreateSecurityGroupRequestBody } from "./models/createSecurityGroupRequestBody.js";
+import type { CreateSecurityRuleRequestBody } from "./models/createSecurityRuleRequestBody.js";
+import type { CreateSnapshotRequestBody } from "./models/createSnapshotRequestBody.js";
+import type { CreateSubnetRequestBody } from "./models/createSubnetRequestBody.js";
+import type { DiskAttachmentList } from "./models/diskAttachmentList.js";
+import type { DiskListResponseBody } from "./models/diskListResponseBody.js";
+import type { DiskResource } from "./models/diskResource.js";
+import type { DiskTypeListResponseBody } from "./models/diskTypeListResponseBody.js";
+import type { DiskTypeResource } from "./models/diskTypeResource.js";
+import type { Error } from "./models/error.js";
+import type { FloatingIPListResponseBody } from "./models/floatingIPListResponseBody.js";
+import type { FloatingIPResource } from "./models/floatingIPResource.js";
+import type { GetInstanceConsoleOutputParams } from "./models/getInstanceConsoleOutputParams.js";
+import type { IPv4PoolListResponseBody } from "./models/iPv4PoolListResponseBody.js";
+import type { IPv6ResponseBody } from "./models/iPv6ResponseBody.js";
+import type { ImageListResponseBody } from "./models/imageListResponseBody.js";
+import type { ImageResource } from "./models/imageResource.js";
+import type { InstanceListResponseBody } from "./models/instanceListResponseBody.js";
+import type { InstanceResource } from "./models/instanceResource.js";
+import type { InstanceTypeListResponseBody } from "./models/instanceTypeListResponseBody.js";
+import type { LaunchInstanceQuoteRequestBody } from "./models/launchInstanceQuoteRequestBody.js";
+import type { LaunchInstanceRequestBody } from "./models/launchInstanceRequestBody.js";
+import type { LaunchInstanceResponseBody } from "./models/launchInstanceResponseBody.js";
+import type { ListAvailabilityZonesParams } from "./models/listAvailabilityZonesParams.js";
+import type { ListBackupCapacityPacksParams } from "./models/listBackupCapacityPacksParams.js";
+import type { ListBackupsParams } from "./models/listBackupsParams.js";
+import type { ListDiskTypesParams } from "./models/listDiskTypesParams.js";
+import type { ListDisksParams } from "./models/listDisksParams.js";
+import type { ListFloatingIpsParams } from "./models/listFloatingIpsParams.js";
+import type { ListImagesParams } from "./models/listImagesParams.js";
+import type { ListInstanceDisksParams } from "./models/listInstanceDisksParams.js";
+import type { ListInstancePortsParams } from "./models/listInstancePortsParams.js";
+import type { ListInstanceTypesParams } from "./models/listInstanceTypesParams.js";
+import type { ListInstancesParams } from "./models/listInstancesParams.js";
+import type { ListIpv4PoolsParams } from "./models/listIpv4PoolsParams.js";
+import type { ListOperationLogsParams } from "./models/listOperationLogsParams.js";
+import type { ListPeeringsParams } from "./models/listPeeringsParams.js";
+import type { ListPortsParams } from "./models/listPortsParams.js";
+import type { ListPrivateNetworksParams } from "./models/listPrivateNetworksParams.js";
+import type { ListRegionsParams } from "./models/listRegionsParams.js";
+import type { ListRoutesParams } from "./models/listRoutesParams.js";
+import type { ListSecurityGroupRulesParams } from "./models/listSecurityGroupRulesParams.js";
+import type { ListSecurityGroupsParams } from "./models/listSecurityGroupsParams.js";
+import type { ListSnapshotsParams } from "./models/listSnapshotsParams.js";
+import type { ListSubnetsParams } from "./models/listSubnetsParams.js";
+import type { NextFreeCidrResponseBody } from "./models/nextFreeCidrResponseBody.js";
+import type { OperationLogListResponseBody } from "./models/operationLogListResponseBody.js";
+import type { PeeringListResponseBody } from "./models/peeringListResponseBody.js";
+import type { PeeringResource } from "./models/peeringResource.js";
+import type { PortAttachmentList } from "./models/portAttachmentList.js";
+import type { PortListResponseBody } from "./models/portListResponseBody.js";
+import type { PortResource } from "./models/portResource.js";
+import type { PowerRequest } from "./models/powerRequest.js";
+import type { PrivateNetworkListResponseBody } from "./models/privateNetworkListResponseBody.js";
+import type { PrivateNetworkResource } from "./models/privateNetworkResource.js";
+import type { Quote } from "./models/quote.js";
+import type { RebootInstanceRequestBody } from "./models/rebootInstanceRequestBody.js";
+import type { RebuildInstanceRequestBody } from "./models/rebuildInstanceRequestBody.js";
+import type { RebuildInstanceResponseBody } from "./models/rebuildInstanceResponseBody.js";
+import type { RegionListResponseBody } from "./models/regionListResponseBody.js";
+import type { RenameBackupRequestBody } from "./models/renameBackupRequestBody.js";
+import type { RenameDiskRequestBody } from "./models/renameDiskRequestBody.js";
+import type { RenameImageRequestBody } from "./models/renameImageRequestBody.js";
+import type { RenameInstanceRequestBody } from "./models/renameInstanceRequestBody.js";
+import type { RenamePrivateNetworkRequestBody } from "./models/renamePrivateNetworkRequestBody.js";
+import type { RenameSecurityGroupRequestBody } from "./models/renameSecurityGroupRequestBody.js";
+import type { RenameSnapshotRequestBody } from "./models/renameSnapshotRequestBody.js";
+import type { ResetPasswordRequestBody } from "./models/resetPasswordRequestBody.js";
+import type { ResetPasswordResponseBody } from "./models/resetPasswordResponseBody.js";
+import type { ResizeDiskQuoteRequestBody } from "./models/resizeDiskQuoteRequestBody.js";
+import type { ResizeDiskRequestBody } from "./models/resizeDiskRequestBody.js";
+import type { ResizeDiskResponseBody } from "./models/resizeDiskResponseBody.js";
+import type { ResizeInstanceQuoteRequestBody } from "./models/resizeInstanceQuoteRequestBody.js";
+import type { ResizeInstanceRequestBody } from "./models/resizeInstanceRequestBody.js";
+import type { ResizeInstanceResponseBody } from "./models/resizeInstanceResponseBody.js";
+import type { RestoreBackupQuoteRequestBody } from "./models/restoreBackupQuoteRequestBody.js";
+import type { RestoreBackupRequestBody } from "./models/restoreBackupRequestBody.js";
+import type { RevertDiskRequestBody } from "./models/revertDiskRequestBody.js";
+import type { RouteListResponseBody } from "./models/routeListResponseBody.js";
+import type { RouteResource } from "./models/routeResource.js";
+import type { RunCommandRequestBody } from "./models/runCommandRequestBody.js";
+import type { SecurityGroupListResponseBody } from "./models/securityGroupListResponseBody.js";
+import type { SecurityGroupResource } from "./models/securityGroupResource.js";
+import type { SecurityRuleListResponseBody } from "./models/securityRuleListResponseBody.js";
+import type { SecurityRuleResource } from "./models/securityRuleResource.js";
+import type { SetFloatingIPBandwidthQuoteRequestBody } from "./models/setFloatingIPBandwidthQuoteRequestBody.js";
+import type { SetFloatingIPBandwidthRequestBody } from "./models/setFloatingIPBandwidthRequestBody.js";
+import type { SetFloatingIPBandwidthResponseBody } from "./models/setFloatingIPBandwidthResponseBody.js";
+import type { SetInstanceLabelsRequestBody } from "./models/setInstanceLabelsRequestBody.js";
+import type { SetInstanceNotesRequestBody } from "./models/setInstanceNotesRequestBody.js";
+import type { SetSnapshotQuotaQuoteRequestBody } from "./models/setSnapshotQuotaQuoteRequestBody.js";
+import type { SetSnapshotQuotaRequestBody } from "./models/setSnapshotQuotaRequestBody.js";
+import type { SetSnapshotQuotaResponseBody } from "./models/setSnapshotQuotaResponseBody.js";
+import type { SnapshotListResponseBody } from "./models/snapshotListResponseBody.js";
+import type { SnapshotQuota } from "./models/snapshotQuota.js";
+import type { SnapshotResource } from "./models/snapshotResource.js";
+import type { SubnetListResponseBody } from "./models/subnetListResponseBody.js";
+import type { SubnetResource } from "./models/subnetResource.js";
+import type { SuggestSubnetCidrParams } from "./models/suggestSubnetCidrParams.js";
+import type { ZoneListResponseBody } from "./models/zoneListResponseBody.js";
+export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
+export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
+export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
+export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
+export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type listBackupsResponse200 = {
+    data: BackupListResponseBody;
+    status: 200;
+};
+export type listBackupsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listBackupsResponseSuccess = listBackupsResponse200 & {
+    headers: Headers;
+};
+export type listBackupsResponseError = listBackupsResponseDefault & {
+    headers: Headers;
+};
+export type listBackupsResponse = listBackupsResponseSuccess | listBackupsResponseError;
+export declare const getListBackupsUrl: (params?: ListBackupsParams) => string;
+/**
+ * @summary List backups
+ */
+export declare const listBackups: (params?: ListBackupsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listBackupsResponse>;
+export type createBackupResponse202 = {
+    data: BackupResource;
+    status: 202;
+};
+export type createBackupResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createBackupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type createBackupResponseSuccess = createBackupResponse202 & {
+    headers: Headers;
+};
+export type createBackupResponseError = (createBackupResponse409 | createBackupResponseDefault) & {
+    headers: Headers;
+};
+export type createBackupResponse = createBackupResponseSuccess | createBackupResponseError;
+export declare const getCreateBackupUrl: () => string;
+/**
+ * A backup is a complete copy of a disk held in separate storage: **it remains restorable after the source disk is deleted, and can be restored to another availability zone in the same region.** A snapshot offers neither capability, as it resides in the same storage as the source disk and prevents that disk from being deleted while it exists.
+ *
+ * Disks attached to a running instance, including system disks, can be backed up.
+ *
+ * No order is placed. The backup is metered on the backup service of the disk's region by its `capacity_gib` for as long as it is retained, until it is deleted; see `get-backup-service`. Refused with 409 `BACKUP_SERVICE_NOT_ACTIVE` and `meta.region_id` when that service is not active.
+ *
+ * Returns the backup while it is taken; the duration depends on the amount of data. Read the backup until it is `available` or `failed`.
+ * @summary Create a backup
+ */
+export declare const createBackup: (createBackupRequestBody: CreateBackupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBackupResponse>;
+export type getBackupResponse200 = {
+    data: BackupResource;
+    status: 200;
+};
+export type getBackupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getBackupResponseSuccess = getBackupResponse200 & {
+    headers: Headers;
+};
+export type getBackupResponseError = getBackupResponseDefault & {
+    headers: Headers;
+};
+export type getBackupResponse = getBackupResponseSuccess | getBackupResponseError;
+export declare const getGetBackupUrl: (backupId: string) => string;
+/**
+ * Returns the stored state of the backup; it does not query the cloud. Use it to poll creation progress.
+ * @summary Retrieve a backup
+ */
+export declare const getBackup: (backupId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getBackupResponse>;
+export type renameBackupResponse200 = {
+    data: BackupResource;
+    status: 200;
+};
+export type renameBackupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renameBackupResponseSuccess = renameBackupResponse200 & {
+    headers: Headers;
+};
+export type renameBackupResponseError = renameBackupResponseDefault & {
+    headers: Headers;
+};
+export type renameBackupResponse = renameBackupResponseSuccess | renameBackupResponseError;
+export declare const getRenameBackupUrl: (backupId: string) => string;
+/**
+ * @summary Rename a backup
+ */
+export declare const renameBackup: (backupId: string, renameBackupRequestBody: RenameBackupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renameBackupResponse>;
+export type deleteBackupResponse202 = {
+    data: BackupResource;
+    status: 202;
+};
+export type deleteBackupResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deleteBackupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deleteBackupResponseSuccess = deleteBackupResponse202 & {
+    headers: Headers;
+};
+export type deleteBackupResponseError = (deleteBackupResponse409 | deleteBackupResponseDefault) & {
+    headers: Headers;
+};
+export type deleteBackupResponse = deleteBackupResponseSuccess | deleteBackupResponseError;
+export declare const getDeleteBackupUrl: (backupId: string) => string;
+/**
+ * Independent of the source disk: deletion succeeds whether or not that disk still exists. Metering of the backup ends once it is deleted.
+ * @summary Delete a backup
+ */
+export declare const deleteBackup: (backupId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteBackupResponse>;
+export type restoreBackupResponse202 = {
+    data: CreateDiskResponseBody;
+    status: 202;
+};
+export type restoreBackupResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type restoreBackupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type restoreBackupResponseSuccess = restoreBackupResponse202 & {
+    headers: Headers;
+};
+export type restoreBackupResponseError = (restoreBackupResponse409 | restoreBackupResponseDefault) & {
+    headers: Headers;
+};
+export type restoreBackupResponse = restoreBackupResponseSuccess | restoreBackupResponseError;
+export declare const getRestoreBackupUrl: (backupId: string) => string;
+/**
+ * Restores onto a **newly created** disk. The source disk is unaffected and need not still exist.
+ *
+ * The target disk type may belong to another availability zone of the same region, and its capacity must not be smaller than the backup. Returns the new disk as `pending` with its order; it cannot be attached until it is `available`.
+ * @summary Restore from a backup
+ */
+export declare const restoreBackup: (backupId: string, restoreBackupRequestBody: RestoreBackupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<restoreBackupResponse>;
+export type createBackupRestoreQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createBackupRestoreQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createBackupRestoreQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createBackupRestoreQuoteResponseSuccess = createBackupRestoreQuoteResponse200 & {
+    headers: Headers;
+};
+export type createBackupRestoreQuoteResponseError = (createBackupRestoreQuoteResponse409 | createBackupRestoreQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createBackupRestoreQuoteResponse = createBackupRestoreQuoteResponseSuccess | createBackupRestoreQuoteResponseError;
+export declare const getCreateBackupRestoreQuoteUrl: (backupId: string) => string;
+/**
+ * Prices what `restore-backup` would order for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote restoring from a backup
+ */
+export declare const createBackupRestoreQuote: (backupId: string, restoreBackupQuoteRequestBody: RestoreBackupQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBackupRestoreQuoteResponse>;
+export type listDiskTypesResponse200 = {
+    data: DiskTypeListResponseBody;
+    status: 200;
+};
+export type listDiskTypesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listDiskTypesResponseSuccess = listDiskTypesResponse200 & {
+    headers: Headers;
+};
+export type listDiskTypesResponseError = listDiskTypesResponseDefault & {
+    headers: Headers;
+};
+export type listDiskTypesResponse = listDiskTypesResponseSuccess | listDiskTypesResponseError;
+export declare const getListDiskTypesUrl: (params?: ListDiskTypesParams) => string;
+/**
+ * Only disk types currently on sale are listed, both system disk types and data disk types; `purpose` narrows the list to one of the two. A withdrawn one disappears from here and can no longer be bought, while the disks already on it keep working and can still be resized.
+ * @summary List disk types on sale
+ */
+export declare const listDiskTypes: (params?: ListDiskTypesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listDiskTypesResponse>;
+export type getDiskTypeResponse200 = {
+    data: DiskTypeResource;
+    status: 200;
+};
+export type getDiskTypeResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getDiskTypeResponseSuccess = getDiskTypeResponse200 & {
+    headers: Headers;
+};
+export type getDiskTypeResponseError = getDiskTypeResponseDefault & {
+    headers: Headers;
+};
+export type getDiskTypeResponse = getDiskTypeResponseSuccess | getDiskTypeResponseError;
+export declare const getGetDiskTypeUrl: (diskTypeId: string) => string;
+/**
+ * Retrieve capacity and performance constraints for an existing disk, including system disk types and types withdrawn from sale.
+ * @summary Get a disk type
+ */
+export declare const getDiskType: (diskTypeId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getDiskTypeResponse>;
+export type listImagesResponse200 = {
+    data: ImageListResponseBody;
+    status: 200;
+};
+export type listImagesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listImagesResponseSuccess = listImagesResponse200 & {
+    headers: Headers;
+};
+export type listImagesResponseError = listImagesResponseDefault & {
+    headers: Headers;
+};
+export type listImagesResponse = listImagesResponseSuccess | listImagesResponseError;
+export declare const getListImagesUrl: (params?: ListImagesParams) => string;
+/**
+ * Lists the public images on sale together with the private images of this project. `visibility` narrows the list to one of the two.
+ *
+ * A public image is offered to every project. Only public images currently on sale are listed: one the platform withdraws disappears from here and can no longer install new instances, while the instances already running it keep running and can still be rebuilt onto it.
+ *
+ * A private image belongs to this project, which captured it from one of its instances, and is listed in every status, including while its capture is in progress and after the capture failed.
+ *
+ * An image can only be used in the region that holds it. An image whose `min_ram_mb` exceeds the memory of the selected instance type cannot boot; filter the options accordingly.
+ * @summary List images
+ */
+export declare const listImages: (params?: ListImagesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listImagesResponse>;
+export type createImageResponse202 = {
+    data: CreateImageResponseBody;
+    status: 202;
+};
+export type createImageResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createImageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type createImageResponseSuccess = createImageResponse202 & {
+    headers: Headers;
+};
+export type createImageResponseError = (createImageResponse409 | createImageResponseDefault) & {
+    headers: Headers;
+};
+export type createImageResponse = createImageResponseSuccess | createImageResponseError;
+export declare const getCreateImageUrl: () => string;
+/**
+ * Creates a private image of this project from the system disk of the instance; data disks are not included. The resulting image can create instances and rebuild them, and remains usable after the source instance is released.
+ *
+ * **The image reflects the moment the capture started. Later changes to the instance are not included.** The image is returned as `pending` with its order, and the capture starts only once the order is accepted.
+ *
+ * The capture then has two phases, reported by the status of the image:
+ *
+ * - `provisioning` — the system disk is being read, usually for tens of seconds. The instance remains usable during this phase, although stopping it first is recommended for consistency.
+ * - `uploading` — no longer tied to the system disk. **The instance may be started at this point; there is no need to wait for the capture to finish.** The duration of this phase is proportional to the size of the system disk, roughly 3 minutes for 20 GB.
+ *
+ * The file system of a running instance may be captured mid-write, in which case the image is equivalent to the disk contents after a power loss. Where consistency matters, stop the instance before starting the capture and start it again once the status becomes `uploading`.
+ *
+ * The instance can be started, stopped and used normally during the capture, but cannot be released.
+ *
+ * The image is billed for the storage it occupies, as the region's `private_image_pricing` shows. Obtain a quote with `create-image-quote` first.
+ * @summary Capture an instance as a private image
+ */
+export declare const createImage: (createImageRequestBody: CreateImageRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createImageResponse>;
+export type createImageQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createImageQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createImageQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createImageQuoteResponseSuccess = createImageQuoteResponse200 & {
+    headers: Headers;
+};
+export type createImageQuoteResponseError = (createImageQuoteResponse409 | createImageQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createImageQuoteResponse = createImageQuoteResponseSuccess | createImageQuoteResponseError;
+export declare const getCreateImageQuoteUrl: () => string;
+/**
+ * Prices the capture `create-image` would order for the same instance, without ordering anything; nothing is reserved or recorded. The quantity priced is the size of the system disk, which is the most the image can occupy, with the option chosen in `billing`. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. Prices may change, so quote again before final confirmation.
+ * @summary Quote capturing an instance as a private image
+ */
+export declare const createImageQuote: (createImageQuoteRequestBody: CreateImageQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createImageQuoteResponse>;
+export type getImageResponse200 = {
+    data: ImageResource;
+    status: 200;
+};
+export type getImageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getImageResponseSuccess = getImageResponse200 & {
+    headers: Headers;
+};
+export type getImageResponseError = getImageResponseDefault & {
+    headers: Headers;
+};
+export type getImageResponse = getImageResponseSuccess | getImageResponseError;
+export declare const getGetImageUrl: (imageId: string) => string;
+/**
+ * Returns a public image, or a private image of this project; any other image is reported as not found. Use this endpoint to poll capture progress. When `status` is `failed`, `failure_reason` states why.
+ * @summary Retrieve an image
+ */
+export declare const getImage: (imageId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getImageResponse>;
+export type renameImageResponse200 = {
+    data: ImageResource;
+    status: 200;
+};
+export type renameImageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renameImageResponseSuccess = renameImageResponse200 & {
+    headers: Headers;
+};
+export type renameImageResponseError = renameImageResponseDefault & {
+    headers: Headers;
+};
+export type renameImageResponse = renameImageResponseSuccess | renameImageResponseError;
+export declare const getRenameImageUrl: (imageId: string) => string;
+/**
+ * Only a private image of this project can be renamed; any other image is reported as not found.
+ * @summary Rename a private image
+ */
+export declare const renameImage: (imageId: string, renameImageRequestBody: RenameImageRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renameImageResponse>;
+export type deleteImageResponse202 = {
+    data: ImageResource;
+    status: 202;
+};
+export type deleteImageResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deleteImageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deleteImageResponseSuccess = deleteImageResponse202 & {
+    headers: Headers;
+};
+export type deleteImageResponseError = (deleteImageResponse409 | deleteImageResponseDefault) & {
+    headers: Headers;
+};
+export type deleteImageResponse = deleteImageResponseSuccess | deleteImageResponseError;
+export declare const getDeleteImageUrl: (imageId: string) => string;
+/**
+ * Only a private image of this project can be deleted; any other image is reported as not found.
+ *
+ * Deletion is rejected while instances created from the image still exist, as they need it in order to be rebuilt.
+ *
+ * An image whose capture has not finished can be deleted; the capture is aborted. This is the one operation accepted while the `create` operation is in progress.
+ *
+ * Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the image, including a pay-as-you-go subscription. `meta.resource_id` names the image. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
+ * @summary Delete a private image
+ */
+export declare const deleteImage: (imageId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteImageResponse>;
+export type listInstanceTypesResponse200 = {
+    data: InstanceTypeListResponseBody;
+    status: 200;
+};
+export type listInstanceTypesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInstanceTypesResponseSuccess = listInstanceTypesResponse200 & {
+    headers: Headers;
+};
+export type listInstanceTypesResponseError = listInstanceTypesResponseDefault & {
+    headers: Headers;
+};
+export type listInstanceTypesResponse = listInstanceTypesResponseSuccess | listInstanceTypesResponseError;
+export declare const getListInstanceTypesUrl: (params?: ListInstanceTypesParams) => string;
+/**
+ * Only instance types currently on sale are listed. A withdrawn one disappears from here and can no longer be ordered, while the instances already running it keep running.
+ * @summary List instance types on sale
+ */
+export declare const listInstanceTypes: (params?: ListInstanceTypesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInstanceTypesResponse>;
+export type listRegionsResponse200 = {
+    data: RegionListResponseBody;
+    status: 200;
+};
+export type listRegionsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listRegionsResponseSuccess = listRegionsResponse200 & {
+    headers: Headers;
+};
+export type listRegionsResponseError = listRegionsResponseDefault & {
+    headers: Headers;
+};
+export type listRegionsResponse = listRegionsResponseSuccess | listRegionsResponseError;
+export declare const getListRegionsUrl: (params?: ListRegionsParams) => string;
+/**
+ * @summary List available regions
+ */
+export declare const listRegions: (params?: ListRegionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listRegionsResponse>;
+export type listAvailabilityZonesResponse200 = {
+    data: ZoneListResponseBody;
+    status: 200;
+};
+export type listAvailabilityZonesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listAvailabilityZonesResponseSuccess = listAvailabilityZonesResponse200 & {
+    headers: Headers;
+};
+export type listAvailabilityZonesResponseError = listAvailabilityZonesResponseDefault & {
+    headers: Headers;
+};
+export type listAvailabilityZonesResponse = listAvailabilityZonesResponseSuccess | listAvailabilityZonesResponseError;
+export declare const getListAvailabilityZonesUrl: (regionId: string, params?: ListAvailabilityZonesParams) => string;
+/**
+ * A disk and an instance must reside in the same availability zone to be attached. Confirm the zone before creating either.
+ * @summary List the availability zones of a region
+ */
+export declare const listAvailabilityZones: (regionId: string, params?: ListAvailabilityZonesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listAvailabilityZonesResponse>;
+export type listDisksResponse200 = {
+    data: DiskListResponseBody;
+    status: 200;
+};
+export type listDisksResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listDisksResponseSuccess = listDisksResponse200 & {
+    headers: Headers;
+};
+export type listDisksResponseError = listDisksResponseDefault & {
+    headers: Headers;
+};
+export type listDisksResponse = listDisksResponseSuccess | listDisksResponseError;
+export declare const getListDisksUrl: (params?: ListDisksParams) => string;
+/**
+ * When both `region_code` and `availability_zone` are supplied, only disks attachable to an instance at that location are returned.
+ * @summary List disks
+ */
+export declare const listDisks: (params?: ListDisksParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listDisksResponse>;
+export type createDiskResponse202 = {
+    data: CreateDiskResponseBody;
+    status: 202;
+};
+export type createDiskResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type createDiskResponseSuccess = createDiskResponse202 & {
+    headers: Headers;
+};
+export type createDiskResponseError = (createDiskResponse409 | createDiskResponseDefault) & {
+    headers: Headers;
+};
+export type createDiskResponse = createDiskResponseSuccess | createDiskResponseError;
+export declare const getCreateDiskUrl: () => string;
+/**
+ * The disk is created in the availability zone of the selected disk type, and an instance must reside in the same zone to attach it. Choosing the disk type therefore determines the zone.
+ *
+ * A disk type that is off sale is rejected with `DISK_TYPE_OFF_SALE`, even though its identifier still resolves. Types that are off sale do not appear in the disk type listing; disks already bought on one keep working and can still be resized.
+ * @summary Create a disk
+ */
+export declare const createDisk: (createDiskRequestBody: CreateDiskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createDiskResponse>;
+export type createDiskQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createDiskQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createDiskQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createDiskQuoteResponseSuccess = createDiskQuoteResponse200 & {
+    headers: Headers;
+};
+export type createDiskQuoteResponseError = (createDiskQuoteResponse409 | createDiskQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createDiskQuoteResponse = createDiskQuoteResponseSuccess | createDiskQuoteResponseError;
+export declare const getCreateDiskQuoteUrl: () => string;
+/**
+ * Prices what `create-disk` would order for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote creating a disk
+ */
+export declare const createDiskQuote: (createDiskQuoteRequestBody: CreateDiskQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createDiskQuoteResponse>;
+export type getDiskResponse200 = {
+    data: DiskResource;
+    status: 200;
+};
+export type getDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getDiskResponseSuccess = getDiskResponse200 & {
+    headers: Headers;
+};
+export type getDiskResponseError = getDiskResponseDefault & {
+    headers: Headers;
+};
+export type getDiskResponse = getDiskResponseSuccess | getDiskResponseError;
+export declare const getGetDiskUrl: (diskId: string) => string;
+/**
+ * Returns the stored state of the disk; it does not query the cloud.
+ * @summary Retrieve a disk
+ */
+export declare const getDisk: (diskId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getDiskResponse>;
+export type renameDiskResponse200 = {
+    data: DiskResource;
+    status: 200;
+};
+export type renameDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renameDiskResponseSuccess = renameDiskResponse200 & {
+    headers: Headers;
+};
+export type renameDiskResponseError = renameDiskResponseDefault & {
+    headers: Headers;
+};
+export type renameDiskResponse = renameDiskResponseSuccess | renameDiskResponseError;
+export declare const getRenameDiskUrl: (diskId: string) => string;
+/**
+ * Changes the name only. Use the resize endpoint for capacity; type and availability zone are immutable.
+ * @summary Rename a disk
+ */
+export declare const renameDisk: (diskId: string, renameDiskRequestBody: RenameDiskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renameDiskResponse>;
+export type deleteDiskResponse202 = {
+    data: DiskResource;
+    status: 202;
+};
+export type deleteDiskResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deleteDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deleteDiskResponseSuccess = deleteDiskResponse202 & {
+    headers: Headers;
+};
+export type deleteDiskResponseError = (deleteDiskResponse409 | deleteDiskResponseDefault) & {
+    headers: Headers;
+};
+export type deleteDiskResponse = deleteDiskResponseSuccess | deleteDiskResponseError;
+export declare const getDeleteDiskUrl: (diskId: string) => string;
+/**
+ * Deletion is rejected while the disk is attached, or while snapshots created from it still exist.
+ *
+ * Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the disk, including a pay-as-you-go subscription. `meta.resource_id` names the disk. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
+ * @summary Delete a disk
+ */
+export declare const deleteDisk: (diskId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteDiskResponse>;
+export type resizeDiskResponse202 = {
+    data: ResizeDiskResponseBody;
+    status: 202;
+};
+export type resizeDiskResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type resizeDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type resizeDiskResponseSuccess = resizeDiskResponse202 & {
+    headers: Headers;
+};
+export type resizeDiskResponseError = (resizeDiskResponse409 | resizeDiskResponseDefault) & {
+    headers: Headers;
+};
+export type resizeDiskResponse = resizeDiskResponseSuccess | resizeDiskResponseError;
+export declare const getResizeDiskUrl: (diskId: string) => string;
+/**
+ * Capacity can only be increased; shrinking is not supported. Returns the disk with the order for the resize, which keeps the disk's billing mode and period. The disk shows the `resize` operation until the resize is applied or its order is canceled, including while the order awaits checkout, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The disk keeps its current size until the resize is applied; once `size_gb` shows the new size, extend the file system inside the instance. If the order is not accepted or the resize fails, the disk keeps its size and the order shows the outcome.
+ *
+ * **An attached data disk whose performance scales with its size must be detached before it is resized.** The performance of an attached disk does not change until the disk is detached and attached again, so such a request is refused with `DISK_RESIZE_NEEDS_DETACH` rather than providing the new capacity at the performance of the previous size. Detach the disk, resize it, and attach it again.
+ *
+ * The request is refused only when the new size has a different performance level. A disk whose type has no QoS level, or whose performance has already reached the maximum of its type, can be resized while attached.
+ *
+ * **A system disk can be resized while attached**, because a system disk cannot be detached. System disk types use a performance level that does not scale with size, so resizing a system disk does not change its performance.
+ * @summary Resize a disk
+ */
+export declare const resizeDisk: (diskId: string, resizeDiskRequestBody: ResizeDiskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<resizeDiskResponse>;
+export type createDiskResizeQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createDiskResizeQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createDiskResizeQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createDiskResizeQuoteResponseSuccess = createDiskResizeQuoteResponse200 & {
+    headers: Headers;
+};
+export type createDiskResizeQuoteResponseError = (createDiskResizeQuoteResponse409 | createDiskResizeQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createDiskResizeQuoteResponse = createDiskResizeQuoteResponseSuccess | createDiskResizeQuoteResponseError;
+export declare const getCreateDiskResizeQuoteUrl: (diskId: string) => string;
+/**
+ * Prices the change `resize-disk` would order, as of now, without ordering or changing anything. A change that raises the price has the charge for the rest of the paid period as `total`; one that lowers it has a zero `total` and the refund as `refundable_amount`. Give the returned `proration_date` with the change, and for automatic checkout `total` as `checkout.expected_amount`. A request the change would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote resizing a disk
+ */
+export declare const createDiskResizeQuote: (diskId: string, resizeDiskQuoteRequestBody: ResizeDiskQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createDiskResizeQuoteResponse>;
+export type revertDiskResponse202 = {
+    data: DiskResource;
+    status: 202;
+};
+export type revertDiskResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type revertDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type revertDiskResponseSuccess = revertDiskResponse202 & {
+    headers: Headers;
+};
+export type revertDiskResponseError = (revertDiskResponse409 | revertDiskResponseDefault) & {
+    headers: Headers;
+};
+export type revertDiskResponse = revertDiskResponseSuccess | revertDiskResponseError;
+export declare const getRevertDiskUrl: (diskId: string) => string;
+/**
+ * Restores the contents of the disk to the moment the snapshot was taken. **All data written after that moment is lost and cannot be recovered.**
+ *
+ * Three restrictions apply: only the most recent snapshot of the disk can be reverted to; the disk must be detached from its instance first; and a disk resized since the snapshot was taken cannot be reverted. To return to an earlier point in time, or to keep the existing disk, create a new disk from the snapshot instead.
+ *
+ * The disk shows the `revert` operation until the revert is complete.
+ * @summary Revert to a snapshot
+ */
+export declare const revertDisk: (diskId: string, revertDiskRequestBody: RevertDiskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<revertDiskResponse>;
+export type listFloatingIpsResponse200 = {
+    data: FloatingIPListResponseBody;
+    status: 200;
+};
+export type listFloatingIpsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listFloatingIpsResponseSuccess = listFloatingIpsResponse200 & {
+    headers: Headers;
+};
+export type listFloatingIpsResponseError = listFloatingIpsResponseDefault & {
+    headers: Headers;
+};
+export type listFloatingIpsResponse = listFloatingIpsResponseSuccess | listFloatingIpsResponseError;
+export declare const getListFloatingIpsUrl: (params?: ListFloatingIpsParams) => string;
+/**
+ * @summary List floating IPs
+ */
+export declare const listFloatingIps: (params?: ListFloatingIpsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listFloatingIpsResponse>;
+export type allocateFloatingIpResponse202 = {
+    data: AllocateFloatingIPResponseBody;
+    status: 202;
+};
+export type allocateFloatingIpResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type allocateFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type allocateFloatingIpResponseSuccess = allocateFloatingIpResponse202 & {
+    headers: Headers;
+};
+export type allocateFloatingIpResponseError = (allocateFloatingIpResponse409 | allocateFloatingIpResponseDefault) & {
+    headers: Headers;
+};
+export type allocateFloatingIpResponse = allocateFloatingIpResponseSuccess | allocateFloatingIpResponseError;
+export declare const getAllocateFloatingIpUrl: () => string;
+/**
+ * If the private network is not yet connected to the internet, connectivity is established as part of this call.
+ *
+ * Returns the floating IP as `pending` with its order; `address` is null until the address is allocated after the order is accepted. A requested `address` is not held while pending; if it is no longer available then, the floating IP ends `failed` with `provisioning_failed` and its charge is refunded.
+ *
+ * IPv6 is not requested through this endpoint. IPv6 addresses are assigned to instances by the private network; enable IPv6 on that network instead.
+ *
+ * Refused with `PRIVATE_NETWORK_UNAVAILABLE`, before any order is created, when the private network's `status` is not `available`. `meta.private_network_id` names it.
+ * @summary Allocate a floating IP
+ */
+export declare const allocateFloatingIp: (allocateFloatingIPRequestBody: AllocateFloatingIPRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<allocateFloatingIpResponse>;
+export type createFloatingIpQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createFloatingIpQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createFloatingIpQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createFloatingIpQuoteResponseSuccess = createFloatingIpQuoteResponse200 & {
+    headers: Headers;
+};
+export type createFloatingIpQuoteResponseError = (createFloatingIpQuoteResponse409 | createFloatingIpQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createFloatingIpQuoteResponse = createFloatingIpQuoteResponseSuccess | createFloatingIpQuoteResponseError;
+export declare const getCreateFloatingIpQuoteUrl: () => string;
+/**
+ * Prices what `allocate-floating-ip` would order for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote allocating a floating IP
+ */
+export declare const createFloatingIpQuote: (allocateFloatingIPQuoteRequestBody: AllocateFloatingIPQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createFloatingIpQuoteResponse>;
+export type getFloatingIpResponse200 = {
+    data: FloatingIPResource;
+    status: 200;
+};
+export type getFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getFloatingIpResponseSuccess = getFloatingIpResponse200 & {
+    headers: Headers;
+};
+export type getFloatingIpResponseError = getFloatingIpResponseDefault & {
+    headers: Headers;
+};
+export type getFloatingIpResponse = getFloatingIpResponseSuccess | getFloatingIpResponseError;
+export declare const getGetFloatingIpUrl: (floatingIpId: string) => string;
+/**
+ * @summary Retrieve a floating IP
+ */
+export declare const getFloatingIp: (floatingIpId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getFloatingIpResponse>;
+export type releaseFloatingIpResponse202 = {
+    data: FloatingIPResource;
+    status: 202;
+};
+export type releaseFloatingIpResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type releaseFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type releaseFloatingIpResponseSuccess = releaseFloatingIpResponse202 & {
+    headers: Headers;
+};
+export type releaseFloatingIpResponseError = (releaseFloatingIpResponse409 | releaseFloatingIpResponseDefault) & {
+    headers: Headers;
+};
+export type releaseFloatingIpResponse = releaseFloatingIpResponseSuccess | releaseFloatingIpResponseError;
+export declare const getReleaseFloatingIpUrl: (floatingIpId: string) => string;
+/**
+ * Releases the floating IP after unbinding it. The floating IP shows the `delete` operation until it is released.
+ *
+ * Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the address, including a pay-as-you-go subscription. `meta.resource_id` names the floating IP. It is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
+ * @summary Release a floating IP
+ */
+export declare const releaseFloatingIp: (floatingIpId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<releaseFloatingIpResponse>;
+export type setFloatingIpBandwidthResponse202 = {
+    data: SetFloatingIPBandwidthResponseBody;
+    status: 202;
+};
+export type setFloatingIpBandwidthResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type setFloatingIpBandwidthResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type setFloatingIpBandwidthResponseSuccess = setFloatingIpBandwidthResponse202 & {
+    headers: Headers;
+};
+export type setFloatingIpBandwidthResponseError = (setFloatingIpBandwidthResponse409 | setFloatingIpBandwidthResponseDefault) & {
+    headers: Headers;
+};
+export type setFloatingIpBandwidthResponse = setFloatingIpBandwidthResponseSuccess | setFloatingIpBandwidthResponseError;
+export declare const getSetFloatingIpBandwidthUrl: (floatingIpId: string) => string;
+/**
+ * Changes the bandwidth of this floating IP through an order that keeps its billing mode and period; no separate bandwidth resource is created. The limit applies to inbound and outbound traffic alike. The floating IP shows the `set_bandwidth` operation until the change is applied or its order is canceled, including while the order awaits checkout, so other operations and a second change are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The current limit stays in effect until the change is applied. If the order is not accepted or the change fails, `bandwidth_mbps` keeps its value and the order shows the outcome.
+ *
+ * While the address is bound to an instance, the limit must not exceed the `max_bandwidth_mbps` of that instance's type; a higher limit is refused with `INSTANCE_BANDWIDTH_CEILING`. The limit of an address that is not bound is checked when the address is bound to an instance.
+ * @summary Set the bandwidth limit
+ */
+export declare const setFloatingIpBandwidth: (floatingIpId: string, setFloatingIPBandwidthRequestBody: SetFloatingIPBandwidthRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setFloatingIpBandwidthResponse>;
+export type createFloatingIpBandwidthQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createFloatingIpBandwidthQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createFloatingIpBandwidthQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createFloatingIpBandwidthQuoteResponseSuccess = createFloatingIpBandwidthQuoteResponse200 & {
+    headers: Headers;
+};
+export type createFloatingIpBandwidthQuoteResponseError = (createFloatingIpBandwidthQuoteResponse409 | createFloatingIpBandwidthQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createFloatingIpBandwidthQuoteResponse = createFloatingIpBandwidthQuoteResponseSuccess | createFloatingIpBandwidthQuoteResponseError;
+export declare const getCreateFloatingIpBandwidthQuoteUrl: (floatingIpId: string) => string;
+/**
+ * Prices the change `set-floating-ip-bandwidth` would order, as of now, without ordering or changing anything. A change that raises the price has the charge for the rest of the paid period as `total`; one that lowers it has a zero `total` and the refund as `refundable_amount`. Give the returned `proration_date` with the change, and for automatic checkout `total` as `checkout.expected_amount`. A request the change would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote changing the bandwidth limit
+ */
+export declare const createFloatingIpBandwidthQuote: (floatingIpId: string, setFloatingIPBandwidthQuoteRequestBody: SetFloatingIPBandwidthQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createFloatingIpBandwidthQuoteResponse>;
+export type bindFloatingIpResponse202 = {
+    data: FloatingIPResource;
+    status: 202;
+};
+export type bindFloatingIpResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type bindFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type bindFloatingIpResponseSuccess = bindFloatingIpResponse202 & {
+    headers: Headers;
+};
+export type bindFloatingIpResponseError = (bindFloatingIpResponse409 | bindFloatingIpResponseDefault) & {
+    headers: Headers;
+};
+export type bindFloatingIpResponse = bindFloatingIpResponseSuccess | bindFloatingIpResponseError;
+export declare const getBindFloatingIpUrl: (floatingIpId: string) => string;
+/**
+ * The floating IP shows the `bind` operation until the binding is confirmed.
+ * @summary Bind a floating IP to a network interface
+ */
+export declare const bindFloatingIp: (floatingIpId: string, bindFloatingIPRequestBody: BindFloatingIPRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<bindFloatingIpResponse>;
+export type unbindFloatingIpResponse202 = {
+    data: FloatingIPResource;
+    status: 202;
+};
+export type unbindFloatingIpResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type unbindFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type unbindFloatingIpResponseSuccess = unbindFloatingIpResponse202 & {
+    headers: Headers;
+};
+export type unbindFloatingIpResponseError = (unbindFloatingIpResponse409 | unbindFloatingIpResponseDefault) & {
+    headers: Headers;
+};
+export type unbindFloatingIpResponse = unbindFloatingIpResponseSuccess | unbindFloatingIpResponseError;
+export declare const getUnbindFloatingIpUrl: (floatingIpId: string) => string;
+/**
+ * The address remains held by the project and simply no longer points at any network interface. The floating IP shows the `unbind` operation until the change is confirmed.
+ * @summary Unbind a floating IP
+ */
+export declare const unbindFloatingIp: (floatingIpId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<unbindFloatingIpResponse>;
+export type listInstancesResponse200 = {
+    data: InstanceListResponseBody;
+    status: 200;
+};
+export type listInstancesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInstancesResponseSuccess = listInstancesResponse200 & {
+    headers: Headers;
+};
+export type listInstancesResponseError = listInstancesResponseDefault & {
+    headers: Headers;
+};
+export type listInstancesResponse = listInstancesResponseSuccess | listInstancesResponseError;
+export declare const getListInstancesUrl: (params?: ListInstancesParams) => string;
+/**
+ * Every instance in the project, newest first, in their stored state.
+ * @summary List instances
+ */
+export declare const listInstances: (params?: ListInstancesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInstancesResponse>;
+export type launchInstanceResponse202 = {
+    data: LaunchInstanceResponseBody;
+    status: 202;
+};
+export type launchInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type launchInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type launchInstanceResponseSuccess = launchInstanceResponse202 & {
+    headers: Headers;
+};
+export type launchInstanceResponseError = (launchInstanceResponse409 | launchInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type launchInstanceResponse = launchInstanceResponseSuccess | launchInstanceResponseError;
+export declare const getLaunchInstanceUrl: () => string;
+/**
+ * Creates a Billing order, including for metered pricing, and returns one `pending` instance per requested instance with the order. `billing` applies to the instance, its system disk and its floating IP alike. A pending instance has no virtual machine, system disk or address, and is not metered.
+ *
+ * Creation starts once Billing accepts the order: the instance becomes `provisioning`, then `active`. With automatic checkout, insufficient funds refuse the request and nothing is created. With deferred checkout and an amount due, the instances stay `pending` until checkout is confirmed and paid through Billing; a canceled or expired order leaves them `failed` with `order_canceled` or `order_expired`. Do not submit another creation request after paying. After an uncertain response, look the order up before submitting again.
+ *
+ * Choose an image or existing disk through boot_disk, and exactly one of port_id or subnet_id. Existing ports, boot disks or floating IPs require count=1. They are not held while the instance is pending; if one is no longer usable when the order is accepted, the instance ends `failed` with `provisioning_failed`. Image boots require boot_disk; existing disks retain their own subscription. Instances, disks and public IPs keep their own subscription items on the same order.
+ *
+ * Instances of one request succeed or fail individually. Each instance, with its system disk, network interface and floating IP, is created or fails as a whole. Instances that were created are kept; each failed instance ends `failed` with `provisioning_failed`, its part of the order is refunded, and the order then ends `partially_completed`. Each instance is named after this request with a number appended.
+ *
+ * The network is checked before the order is created, and a request it refuses orders and charges nothing. It is refused with `PRIVATE_NETWORK_UNAVAILABLE` when the private network's `status` is not `available`, `SUBNET_UNAVAILABLE` or `SECURITY_GROUP_UNAVAILABLE` when the subnet or a security group is not ready, `SECURITY_GROUP_OTHER_PRIVATE_NETWORK` when a security group belongs to another private network, and `PORT_UNAVAILABLE` when the port's `status` is not `available`. `meta` names the resource.
+ * @summary Create instances
+ */
+export declare const launchInstance: (launchInstanceRequestBody: LaunchInstanceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<launchInstanceResponse>;
+export type createInstanceQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createInstanceQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createInstanceQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createInstanceQuoteResponseSuccess = createInstanceQuoteResponse200 & {
+    headers: Headers;
+};
+export type createInstanceQuoteResponseError = (createInstanceQuoteResponse409 | createInstanceQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createInstanceQuoteResponse = createInstanceQuoteResponseSuccess | createInstanceQuoteResponseError;
+export declare const getCreateInstanceQuoteUrl: () => string;
+/**
+ * Prices what `launch-instance` would order for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote creating instances
+ */
+export declare const createInstanceQuote: (launchInstanceQuoteRequestBody: LaunchInstanceQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createInstanceQuoteResponse>;
+export type getInstanceResponse200 = {
+    data: InstanceResource;
+    status: 200;
+};
+export type getInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getInstanceResponseSuccess = getInstanceResponse200 & {
+    headers: Headers;
+};
+export type getInstanceResponseError = getInstanceResponseDefault & {
+    headers: Headers;
+};
+export type getInstanceResponse = getInstanceResponseSuccess | getInstanceResponseError;
+export declare const getGetInstanceUrl: (instanceId: string) => string;
+/**
+ * Returns the stored state of the instance; it does not query the cloud. Use it to poll creation progress.
+ * @summary Retrieve an instance
+ */
+export declare const getInstance: (instanceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getInstanceResponse>;
+export type renameInstanceResponse200 = {
+    data: InstanceResource;
+    status: 200;
+};
+export type renameInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renameInstanceResponseSuccess = renameInstanceResponse200 & {
+    headers: Headers;
+};
+export type renameInstanceResponseError = renameInstanceResponseDefault & {
+    headers: Headers;
+};
+export type renameInstanceResponse = renameInstanceResponseSuccess | renameInstanceResponseError;
+export declare const getRenameInstanceUrl: (instanceId: string) => string;
+/**
+ * Changes the display name only. The hostname inside the instance is unchanged; it equals the instance id.
+ * @summary Rename an instance
+ */
+export declare const renameInstance: (instanceId: string, renameInstanceRequestBody: RenameInstanceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renameInstanceResponse>;
+export type deleteInstanceResponse202 = {
+    data: InstanceResource;
+    status: 202;
+};
+export type deleteInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deleteInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deleteInstanceResponseSuccess = deleteInstanceResponse202 & {
+    headers: Headers;
+};
+export type deleteInstanceResponseError = (deleteInstanceResponse409 | deleteInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type deleteInstanceResponse = deleteInstanceResponseSuccess | deleteInstanceResponseError;
+export declare const getDeleteInstanceUrl: (instanceId: string) => string;
+/**
+ * The system disk is deleted with the instance, and **snapshots created from the system disk are deleted with it**. Data disks are detached and kept, and their snapshots and backups are unaffected. The primary network interface is released with the instance.
+ *
+ * An instance being captured as a private image cannot be released. Wait for the capture to finish, or delete that image first.
+ *
+ * Refused with `COMPUTE_RESOURCE_SUBSCRIBED` while a subscription pays for the instance, or for a disk that is deleted with it, including a pay-as-you-go subscription. `meta.resource_id` names that resource. The instance is released by canceling the subscriptions listed in `meta.subscription_ids` through Billing, the same set as its `release_subscription_ids`.
+ * @summary Release an instance
+ */
+export declare const deleteInstance: (instanceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteInstanceResponse>;
+export type runInstanceCommandResponse200 = {
+    data: CommandResultResponseBody;
+    status: 200;
+};
+export type runInstanceCommandResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type runInstanceCommandResponseSuccess = runInstanceCommandResponse200 & {
+    headers: Headers;
+};
+export type runInstanceCommandResponseError = runInstanceCommandResponseDefault & {
+    headers: Headers;
+};
+export type runInstanceCommandResponse = runInstanceCommandResponseSuccess | runInstanceCommandResponseError;
+export declare const getRunInstanceCommandUrl: (instanceId: string) => string;
+/**
+ * Runs one command over SSH and returns what it wrote. **This is not a shell.** There is no terminal, no standard input and no way to answer a prompt: a command that waits for input produces nothing and is killed at the timeout. Chain steps with `&&`, or write a script and run that.
+ *
+ * **A command that fails is still a 200.** Its failure is its own result, not this endpoint's: read `exit_code` for what it exited with and `stderr` for what it said, and decide from those. A `grep` that matches nothing exits 1 and is a perfectly successful call.
+ *
+ * The status therefore answers a different question — did the command run at all. A non-2xx means it did not, and nothing about the instance was changed by this request: it was suspended, not running or had no floating IP; or it refused the platform key; or the connection could not be opened. Retrying is meaningful in those cases and is not for a non-zero `exit_code`.
+ *
+ * Three conditions must hold; the instance is unreachable otherwise:
+ *
+ * - it is `active`
+ * - a floating IP is bound to it, since this endpoint connects over the public internet
+ * - its security group permits inbound TCP 22
+ *
+ * Authentication uses the key the platform attaches to every instance at creation, so nothing has to be set up first. The instance must have applied that key at first boot, which images without a full cloud-init do not do.
+ *
+ * **Do not pass secrets in the command.** Read them from a file on the instance instead: neither the command nor its output is a confidential channel.
+ *
+ * Each stream is capped at 1 MiB. Beyond that the rest is discarded and `truncated` is true.
+ * @summary Run a command on an instance
+ */
+export declare const runInstanceCommand: (instanceId: string, runCommandRequestBody: RunCommandRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<runInstanceCommandResponse>;
+export type openInstanceConsoleResponse200 = {
+    data: ConsoleResponseBody;
+    status: 200;
+};
+export type openInstanceConsoleResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type openInstanceConsoleResponseSuccess = openInstanceConsoleResponse200 & {
+    headers: Headers;
+};
+export type openInstanceConsoleResponseError = openInstanceConsoleResponseDefault & {
+    headers: Headers;
+};
+export type openInstanceConsoleResponse = openInstanceConsoleResponseSuccess | openInstanceConsoleResponseError;
+export declare const getOpenInstanceConsoleUrl: (instanceId: string) => string;
+/**
+ * Operates the instance directly from a browser and does not require the instance to be reachable over the network, which makes it usable when a network misconfiguration prevents login.
+ *
+ * The returned address is single-use and expires within minutes. Request a new one before each use.
+ * @summary Open a remote console
+ */
+export declare const openInstanceConsole: (instanceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<openInstanceConsoleResponse>;
+export type getInstanceConsoleOutputResponse200 = {
+    data: ConsoleOutputResponseBody;
+    status: 200;
+};
+export type getInstanceConsoleOutputResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getInstanceConsoleOutputResponseSuccess = getInstanceConsoleOutputResponse200 & {
+    headers: Headers;
+};
+export type getInstanceConsoleOutputResponseError = getInstanceConsoleOutputResponseDefault & {
+    headers: Headers;
+};
+export type getInstanceConsoleOutputResponse = getInstanceConsoleOutputResponseSuccess | getInstanceConsoleOutputResponseError;
+export declare const getGetInstanceConsoleOutputUrl: (instanceId: string, params?: GetInstanceConsoleOutputParams) => string;
+/**
+ * The raw text produced by the instance during boot and by the kernel. Consult it first when login fails or the remote console shows no output: it reveals where boot stopped, whether the system disk was mounted, and whether initialisation reported errors.
+ *
+ * Instances in an error state, and instances suspended by the platform, can be read as well.
+ * @summary Read the console output
+ */
+export declare const getInstanceConsoleOutput: (instanceId: string, params?: GetInstanceConsoleOutputParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getInstanceConsoleOutputResponse>;
+export type setInstanceLabelsResponse200 = {
+    data: InstanceResource;
+    status: 200;
+};
+export type setInstanceLabelsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setInstanceLabelsResponseSuccess = setInstanceLabelsResponse200 & {
+    headers: Headers;
+};
+export type setInstanceLabelsResponseError = setInstanceLabelsResponseDefault & {
+    headers: Headers;
+};
+export type setInstanceLabelsResponse = setInstanceLabelsResponseSuccess | setInstanceLabelsResponseError;
+export declare const getSetInstanceLabelsUrl: (instanceId: string) => string;
+/**
+ * Records what this instance is for, as key-value pairs. Nothing on the platform reads them.
+ *
+ * **The whole set is replaced**: whatever is absent from the request is removed.
+ *
+ * Do not put credentials here. Labels are visible to platform operators.
+ * @summary Replace an instance's labels
+ */
+export declare const setInstanceLabels: (instanceId: string, setInstanceLabelsRequestBody: SetInstanceLabelsRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setInstanceLabelsResponse>;
+export type setInstanceNotesResponse200 = {
+    data: InstanceResource;
+    status: 200;
+};
+export type setInstanceNotesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setInstanceNotesResponseSuccess = setInstanceNotesResponse200 & {
+    headers: Headers;
+};
+export type setInstanceNotesResponseError = setInstanceNotesResponseDefault & {
+    headers: Headers;
+};
+export type setInstanceNotesResponse = setInstanceNotesResponseSuccess | setInstanceNotesResponseError;
+export declare const getSetInstanceNotesUrl: (instanceId: string) => string;
+/**
+ * A free-text note about this instance — what it runs, and what to be careful about before touching it.
+ *
+ * **The whole note is replaced**; send an empty string to clear it.
+ *
+ * Do not put credentials here. The note is visible to platform operators.
+ * @summary Replace an instance's note
+ */
+export declare const setInstanceNotes: (instanceId: string, setInstanceNotesRequestBody: SetInstanceNotesRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setInstanceNotesResponse>;
+export type resetInstancePasswordResponse200 = {
+    data: ResetPasswordResponseBody;
+    status: 200;
+};
+export type resetInstancePasswordResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type resetInstancePasswordResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type resetInstancePasswordResponseSuccess = resetInstancePasswordResponse200 & {
+    headers: Headers;
+};
+export type resetInstancePasswordResponseError = (resetInstancePasswordResponse409 | resetInstancePasswordResponseDefault) & {
+    headers: Headers;
+};
+export type resetInstancePasswordResponse = resetInstancePasswordResponseSuccess | resetInstancePasswordResponseError;
+export declare const getResetInstancePasswordUrl: (instanceId: string) => string;
+/**
+ * Changes the root password without a reboot. The instance must be running.
+ *
+ * **Not every image supports this.** Images whose `supports_password_reset` is false cannot, and a new password can then only be set by rebuilding the instance, which erases all data on the system disk.
+ *
+ * The request is also rejected when the image is marked as supported but the corresponding component has been removed or stopped inside the instance.
+ * @summary Reset the login password
+ */
+export declare const resetInstancePassword: (instanceId: string, resetPasswordRequestBody: ResetPasswordRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<resetInstancePasswordResponse>;
+export type rebootInstanceResponse202 = {
+    data: InstanceResource;
+    status: 202;
+};
+export type rebootInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type rebootInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type rebootInstanceResponseSuccess = rebootInstanceResponse202 & {
+    headers: Headers;
+};
+export type rebootInstanceResponseError = (rebootInstanceResponse409 | rebootInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type rebootInstanceResponse = rebootInstanceResponseSuccess | rebootInstanceResponseError;
+export declare const getRebootInstanceUrl: (instanceId: string) => string;
+/**
+ * A reboot defaults to soft, in which the operating system shuts down normally before starting again.
+ *
+ * A soft reboot has no effect once the system is unresponsive. Set `force` to reboot forcibly: a forced reboot does not wait for the operating system to shut down, so **unwritten data is lost**.
+ *
+ * A forced reboot is accepted while a soft reboot is in progress, which is the way out of a soft reboot the instance never carried out. Any other request for an operation, including a second soft reboot, is refused with `COMPUTE_RESOURCE_BUSY` while the reboot is in progress.
+ *
+ * An instance suspended by the platform must be unsuspended first.
+ *
+ * The instance shows the `reboot` operation until the reboot has finished.
+ * @summary Reboot an instance
+ */
+export declare const rebootInstance: (instanceId: string, rebootInstanceRequestBody: RebootInstanceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<rebootInstanceResponse>;
+export type rebuildInstanceResponse202 = {
+    data: RebuildInstanceResponseBody;
+    status: 202;
+};
+export type rebuildInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type rebuildInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type rebuildInstanceResponseSuccess = rebuildInstanceResponse202 & {
+    headers: Headers;
+};
+export type rebuildInstanceResponseError = (rebuildInstanceResponse409 | rebuildInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type rebuildInstanceResponse = rebuildInstanceResponseSuccess | rebuildInstanceResponseError;
+export declare const getRebuildInstanceUrl: (instanceId: string) => string;
+/**
+ * **All data on the system disk is erased and cannot be recovered.** Attached data disks are unaffected.
+ *
+ * The image this instance already runs is accepted even after the platform has withdrawn it, since rebuilding is the only way back into an instance broken from the inside. Any *other* withdrawn image is rejected with `IMAGE_RETIRED`, which is a change of image and therefore a new order.
+ *
+ * The instance shows the `rebuild` operation until the rebuild has finished.
+ * @summary Rebuild an instance
+ */
+export declare const rebuildInstance: (instanceId: string, rebuildInstanceRequestBody: RebuildInstanceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<rebuildInstanceResponse>;
+export type resizeInstanceResponse202 = {
+    data: ResizeInstanceResponseBody;
+    status: 202;
+};
+export type resizeInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type resizeInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type resizeInstanceResponseSuccess = resizeInstanceResponse202 & {
+    headers: Headers;
+};
+export type resizeInstanceResponseError = (resizeInstanceResponse409 | resizeInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type resizeInstanceResponse = resizeInstanceResponseSuccess | resizeInstanceResponseError;
+export declare const getResizeInstanceUrl: (instanceId: string) => string;
+/**
+ * Creates a Billing change order, including for metered pricing, and returns the instance with the order. The instance keeps its billing mode and period, priced with the target type's matching option; a target type without that option is refused with 409 `BILLING_OPTION_UNAVAILABLE`. Do not submit a new purchase after paying. After an uncertain response, look the order up before submitting again.
+ *
+ * The instance shows the `resize` operation until the resize is applied or its order is canceled, including while the order awaits checkout, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. It keeps its current type until the resize is applied; the new type takes effect, and is billed from then on, when `instance_type_id` shows it. If the order is not accepted or the resize fails, the instance keeps its current type and the order shows the outcome. A completed resize is final and cannot be reverted; to return to the previous type, submit another resize.
+ * @summary Resize an instance
+ */
+export declare const resizeInstance: (instanceId: string, resizeInstanceRequestBody: ResizeInstanceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<resizeInstanceResponse>;
+export type createInstanceResizeQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createInstanceResizeQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createInstanceResizeQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createInstanceResizeQuoteResponseSuccess = createInstanceResizeQuoteResponse200 & {
+    headers: Headers;
+};
+export type createInstanceResizeQuoteResponseError = (createInstanceResizeQuoteResponse409 | createInstanceResizeQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createInstanceResizeQuoteResponse = createInstanceResizeQuoteResponseSuccess | createInstanceResizeQuoteResponseError;
+export declare const getCreateInstanceResizeQuoteUrl: (instanceId: string) => string;
+/**
+ * Prices the change `resize-instance` would order, as of now, without ordering or changing anything. A change that raises the price has the charge for the rest of the paid period as `total`; one that lowers it has a zero `total` and the refund as `refundable_amount`. Give the returned `proration_date` with the change, and for automatic checkout `total` as `checkout.expected_amount`. A request the change would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote resizing an instance
+ */
+export declare const createInstanceResizeQuote: (instanceId: string, resizeInstanceQuoteRequestBody: ResizeInstanceQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createInstanceResizeQuoteResponse>;
+export type startInstanceResponse202 = {
+    data: InstanceResource;
+    status: 202;
+};
+export type startInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type startInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type startInstanceResponseSuccess = startInstanceResponse202 & {
+    headers: Headers;
+};
+export type startInstanceResponseError = (startInstanceResponse409 | startInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type startInstanceResponse = startInstanceResponseSuccess | startInstanceResponseError;
+export declare const getStartInstanceUrl: (instanceId: string) => string;
+/**
+ * Outstanding restrictions can prevent starting. The instance shows the `start` operation until it is running or the start has failed.
+ * @summary Start an instance
+ */
+export declare const startInstance: (instanceId: string, powerRequest: PowerRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<startInstanceResponse>;
+export type stopInstanceResponse202 = {
+    data: InstanceResource;
+    status: 202;
+};
+export type stopInstanceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type stopInstanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type stopInstanceResponseSuccess = stopInstanceResponse202 & {
+    headers: Headers;
+};
+export type stopInstanceResponseError = (stopInstanceResponse409 | stopInstanceResponseDefault) & {
+    headers: Headers;
+};
+export type stopInstanceResponse = stopInstanceResponseSuccess | stopInstanceResponseError;
+export declare const getStopInstanceUrl: (instanceId: string) => string;
+/**
+ * A stopped instance keeps its disks, network attachments and sellable quota. The instance shows the `stop` operation until it is stopped or the stop has failed.
+ * @summary Stop an instance
+ */
+export declare const stopInstance: (instanceId: string, powerRequest: PowerRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<stopInstanceResponse>;
+export type listInstanceDisksResponse200 = {
+    data: DiskAttachmentList;
+    status: 200;
+};
+export type listInstanceDisksResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInstanceDisksResponseSuccess = listInstanceDisksResponse200 & {
+    headers: Headers;
+};
+export type listInstanceDisksResponseError = listInstanceDisksResponseDefault & {
+    headers: Headers;
+};
+export type listInstanceDisksResponse = listInstanceDisksResponseSuccess | listInstanceDisksResponseError;
+export declare const getListInstanceDisksUrl: (instanceId: string, params?: ListInstanceDisksParams) => string;
+/**
+ * @summary List the disks attached to an instance
+ */
+export declare const listInstanceDisks: (instanceId: string, params?: ListInstanceDisksParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInstanceDisksResponse>;
+export type attachDiskResponse202 = {
+    data: DiskResource;
+    status: 202;
+};
+export type attachDiskResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type attachDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type attachDiskResponseSuccess = attachDiskResponse202 & {
+    headers: Headers;
+};
+export type attachDiskResponseError = (attachDiskResponse409 | attachDiskResponseDefault) & {
+    headers: Headers;
+};
+export type attachDiskResponse = attachDiskResponseSuccess | attachDiskResponseError;
+export declare const getAttachDiskUrl: (instanceId: string) => string;
+/**
+ * The disk must be in the same region and availability zone as the instance. Returns the disk; the instance shows the `attach_disk` operation and the disk the `attach` operation until the attachment is confirmed. Partition the disk and mount the file system inside the instance once it is attached.
+ * @summary Attach a disk
+ */
+export declare const attachDisk: (instanceId: string, attachDiskRequestBody: AttachDiskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<attachDiskResponse>;
+export type detachDiskResponse202 = {
+    data: DiskResource;
+    status: 202;
+};
+export type detachDiskResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type detachDiskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type detachDiskResponseSuccess = detachDiskResponse202 & {
+    headers: Headers;
+};
+export type detachDiskResponseError = (detachDiskResponse409 | detachDiskResponseDefault) & {
+    headers: Headers;
+};
+export type detachDiskResponse = detachDiskResponseSuccess | detachDiskResponseError;
+export declare const getDetachDiskUrl: (instanceId: string, diskId: string) => string;
+/**
+ * Unmount the device inside the instance before calling this endpoint. Forcibly detaching a file system that is being written to corrupts data.
+ *
+ * The disk the instance boots from cannot be detached, whether it is the system disk bought with the instance or a disk supplied as the existing boot_disk at launch. Such a request is refused with `INSTANCE_BOOT_DISK_LOCKED` and changes nothing; releasing the instance is what frees that disk.
+ *
+ * Returns the disk; the instance shows the `detach_disk` operation and the disk the `detach` operation until the disk is detached.
+ * @summary Detach a disk
+ */
+export declare const detachDisk: (instanceId: string, diskId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<detachDiskResponse>;
+export type attachInstanceFloatingIpResponse202 = {
+    data: FloatingIPResource;
+    status: 202;
+};
+export type attachInstanceFloatingIpResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type attachInstanceFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type attachInstanceFloatingIpResponseSuccess = attachInstanceFloatingIpResponse202 & {
+    headers: Headers;
+};
+export type attachInstanceFloatingIpResponseError = (attachInstanceFloatingIpResponse409 | attachInstanceFloatingIpResponseDefault) & {
+    headers: Headers;
+};
+export type attachInstanceFloatingIpResponse = attachInstanceFloatingIpResponseSuccess | attachInstanceFloatingIpResponseError;
+export declare const getAttachInstanceFloatingIpUrl: (instanceId: string) => string;
+/**
+ * Changes the public IP binding on the instance's primary network interface. The instance shows the `bind_floating_ip` operation until the binding is confirmed.
+ * @summary Bind a floating IP to an instance
+ */
+export declare const attachInstanceFloatingIp: (instanceId: string, attachFloatingIPRequestBody: AttachFloatingIPRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<attachInstanceFloatingIpResponse>;
+export type detachInstanceFloatingIpResponse202 = {
+    data: FloatingIPResource;
+    status: 202;
+};
+export type detachInstanceFloatingIpResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type detachInstanceFloatingIpResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type detachInstanceFloatingIpResponseSuccess = detachInstanceFloatingIpResponse202 & {
+    headers: Headers;
+};
+export type detachInstanceFloatingIpResponseError = (detachInstanceFloatingIpResponse409 | detachInstanceFloatingIpResponseDefault) & {
+    headers: Headers;
+};
+export type detachInstanceFloatingIpResponse = detachInstanceFloatingIpResponseSuccess | detachInstanceFloatingIpResponseError;
+export declare const getDetachInstanceFloatingIpUrl: (instanceId: string, floatingIpId: string) => string;
+/**
+ * Changes the public IP binding on the instance's primary network interface. The instance shows the `unbind_floating_ip` operation until the change is confirmed.
+ * @summary Unbind the floating IP of an instance
+ */
+export declare const detachInstanceFloatingIp: (instanceId: string, floatingIpId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<detachInstanceFloatingIpResponse>;
+export type listInstancePortsResponse200 = {
+    data: PortAttachmentList;
+    status: 200;
+};
+export type listInstancePortsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInstancePortsResponseSuccess = listInstancePortsResponse200 & {
+    headers: Headers;
+};
+export type listInstancePortsResponseError = listInstancePortsResponseDefault & {
+    headers: Headers;
+};
+export type listInstancePortsResponse = listInstancePortsResponseSuccess | listInstancePortsResponseError;
+export declare const getListInstancePortsUrl: (instanceId: string, params?: ListInstancePortsParams) => string;
+/**
+ * @summary List the network interfaces of an instance
+ */
+export declare const listInstancePorts: (instanceId: string, params?: ListInstancePortsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInstancePortsResponse>;
+export type attachPortResponse202 = {
+    data: PortResource;
+    status: 202;
+};
+export type attachPortResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type attachPortResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type attachPortResponseSuccess = attachPortResponse202 & {
+    headers: Headers;
+};
+export type attachPortResponseError = (attachPortResponse409 | attachPortResponseDefault) & {
+    headers: Headers;
+};
+export type attachPortResponse = attachPortResponseSuccess | attachPortResponseError;
+export declare const getAttachPortUrl: (instanceId: string) => string;
+/**
+ * Returns the network interface; the instance shows the `attach_port` operation and the interface the `attach` operation until the attachment is confirmed.
+ * @summary Attach a network interface
+ */
+export declare const attachPort: (instanceId: string, attachPortRequestBody: AttachPortRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<attachPortResponse>;
+export type detachPortResponse202 = {
+    data: PortResource;
+    status: 202;
+};
+export type detachPortResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type detachPortResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type detachPortResponseSuccess = detachPortResponse202 & {
+    headers: Headers;
+};
+export type detachPortResponseError = (detachPortResponse409 | detachPortResponseDefault) & {
+    headers: Headers;
+};
+export type detachPortResponse = detachPortResponseSuccess | detachPortResponseError;
+export declare const getDetachPortUrl: (instanceId: string, portId: string) => string;
+/**
+ * The primary network interface cannot be detached; the instance would lose its network address.
+ *
+ * Returns the network interface; the instance shows the `detach_port` operation and the interface the `detach` operation until it is detached.
+ * @summary Detach a network interface
+ */
+export declare const detachPort: (instanceId: string, portId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<detachPortResponse>;
+export type listOperationLogsResponse200 = {
+    data: OperationLogListResponseBody;
+    status: 200;
+};
+export type listOperationLogsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listOperationLogsResponseSuccess = listOperationLogsResponse200 & {
+    headers: Headers;
+};
+export type listOperationLogsResponseError = listOperationLogsResponseDefault & {
+    headers: Headers;
+};
+export type listOperationLogsResponse = listOperationLogsResponseSuccess | listOperationLogsResponseError;
+export declare const getListOperationLogsUrl: (params?: ListOperationLogsParams) => string;
+/**
+ * Records every write operation in the project: who performed it, when, on what, and whether it succeeded. Read operations are not recorded.
+ *
+ * **Operations performed by the platform are included, but the individual operator is not disclosed** and `by_platform` is true. Suspension for non-payment and bans for abuse are examples: the time at which an instance was stopped by the platform is needed, whereas the operator is internal information.
+ *
+ * Fields such as passwords are replaced with a placeholder as the record is written and never appear in `payload`.
+ * @summary List the operation log of the project
+ */
+export declare const listOperationLogs: (params?: ListOperationLogsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listOperationLogsResponse>;
+export type listPortsResponse200 = {
+    data: PortListResponseBody;
+    status: 200;
+};
+export type listPortsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listPortsResponseSuccess = listPortsResponse200 & {
+    headers: Headers;
+};
+export type listPortsResponseError = listPortsResponseDefault & {
+    headers: Headers;
+};
+export type listPortsResponse = listPortsResponseSuccess | listPortsResponseError;
+export declare const getListPortsUrl: (params?: ListPortsParams) => string;
+/**
+ * @summary List network interfaces
+ */
+export declare const listPorts: (params?: ListPortsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPortsResponse>;
+export type createPortResponse202 = {
+    data: PortResource;
+    status: 202;
+};
+export type createPortResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type createPortResponseSuccess = createPortResponse202 & {
+    headers: Headers;
+};
+export type createPortResponseError = createPortResponseDefault & {
+    headers: Headers;
+};
+export type createPortResponse = createPortResponseSuccess | createPortResponseError;
+export declare const getCreatePortUrl: () => string;
+/**
+ * The new network interface is not attached to any instance. Primary network interfaces are not created here; they are created with the instance.
+ * @summary Create a network interface
+ */
+export declare const createPort: (createPortRequestBody: CreatePortRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createPortResponse>;
+export type deletePortResponse202 = {
+    data: PortResource;
+    status: 202;
+};
+export type deletePortResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deletePortResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deletePortResponseSuccess = deletePortResponse202 & {
+    headers: Headers;
+};
+export type deletePortResponseError = (deletePortResponse409 | deletePortResponseDefault) & {
+    headers: Headers;
+};
+export type deletePortResponse = deletePortResponseSuccess | deletePortResponseError;
+export declare const getDeletePortUrl: (portId: string) => string;
+/**
+ * The primary network interface cannot be deleted on its own, as it is released with the instance. A network interface still attached to an instance cannot be deleted either.
+ * @summary Delete a network interface
+ */
+export declare const deletePort: (portId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deletePortResponse>;
+export type listPrivateNetworksResponse200 = {
+    data: PrivateNetworkListResponseBody;
+    status: 200;
+};
+export type listPrivateNetworksResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listPrivateNetworksResponseSuccess = listPrivateNetworksResponse200 & {
+    headers: Headers;
+};
+export type listPrivateNetworksResponseError = listPrivateNetworksResponseDefault & {
+    headers: Headers;
+};
+export type listPrivateNetworksResponse = listPrivateNetworksResponseSuccess | listPrivateNetworksResponseError;
+export declare const getListPrivateNetworksUrl: (params?: ListPrivateNetworksParams) => string;
+/**
+ * @summary List private networks
+ */
+export declare const listPrivateNetworks: (params?: ListPrivateNetworksParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPrivateNetworksResponse>;
+export type createPrivateNetworkResponse202 = {
+    data: PrivateNetworkResource;
+    status: 202;
+};
+export type createPrivateNetworkResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type createPrivateNetworkResponseSuccess = createPrivateNetworkResponse202 & {
+    headers: Headers;
+};
+export type createPrivateNetworkResponseError = createPrivateNetworkResponseDefault & {
+    headers: Headers;
+};
+export type createPrivateNetworkResponse = createPrivateNetworkResponseSuccess | createPrivateNetworkResponseError;
+export declare const getCreatePrivateNetworkUrl: () => string;
+/**
+ * Creates a private network definition and its default security group. The default security group denies all inbound traffic and permits all outbound traffic.
+ * @summary Create a private network
+ */
+export declare const createPrivateNetwork: (createPrivateNetworkRequestBody: CreatePrivateNetworkRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createPrivateNetworkResponse>;
+export type getPrivateNetworkResponse200 = {
+    data: PrivateNetworkResource;
+    status: 200;
+};
+export type getPrivateNetworkResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getPrivateNetworkResponseSuccess = getPrivateNetworkResponse200 & {
+    headers: Headers;
+};
+export type getPrivateNetworkResponseError = getPrivateNetworkResponseDefault & {
+    headers: Headers;
+};
+export type getPrivateNetworkResponse = getPrivateNetworkResponseSuccess | getPrivateNetworkResponseError;
+export declare const getGetPrivateNetworkUrl: (privateNetworkId: string) => string;
+/**
+ * @summary Retrieve a private network
+ */
+export declare const getPrivateNetwork: (privateNetworkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getPrivateNetworkResponse>;
+export type renamePrivateNetworkResponse200 = {
+    data: PrivateNetworkResource;
+    status: 200;
+};
+export type renamePrivateNetworkResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renamePrivateNetworkResponseSuccess = renamePrivateNetworkResponse200 & {
+    headers: Headers;
+};
+export type renamePrivateNetworkResponseError = renamePrivateNetworkResponseDefault & {
+    headers: Headers;
+};
+export type renamePrivateNetworkResponse = renamePrivateNetworkResponseSuccess | renamePrivateNetworkResponseError;
+export declare const getRenamePrivateNetworkUrl: (privateNetworkId: string) => string;
+/**
+ * Changes the display name only. The CIDR, the routes and the internet gateway are immutable.
+ * @summary Rename a private network
+ */
+export declare const renamePrivateNetwork: (privateNetworkId: string, renamePrivateNetworkRequestBody: RenamePrivateNetworkRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renamePrivateNetworkResponse>;
+export type deletePrivateNetworkResponse202 = {
+    data: PrivateNetworkResource;
+    status: 202;
+};
+export type deletePrivateNetworkResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deletePrivateNetworkResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deletePrivateNetworkResponseSuccess = deletePrivateNetworkResponse202 & {
+    headers: Headers;
+};
+export type deletePrivateNetworkResponseError = (deletePrivateNetworkResponse409 | deletePrivateNetworkResponseDefault) & {
+    headers: Headers;
+};
+export type deletePrivateNetworkResponse = deletePrivateNetworkResponseSuccess | deletePrivateNetworkResponseError;
+export declare const getDeletePrivateNetworkUrl: (privateNetworkId: string) => string;
+/**
+ * Deletion is rejected while instances or network interfaces remain in the network. Its subnets, routes, security groups and IPv6 configuration are removed with it.
+ * @summary Release a private network
+ */
+export declare const deletePrivateNetwork: (privateNetworkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deletePrivateNetworkResponse>;
+export type getPrivateNetworkIpv6Response200 = {
+    data: IPv6ResponseBody;
+    status: 200;
+};
+export type getPrivateNetworkIpv6ResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getPrivateNetworkIpv6ResponseSuccess = getPrivateNetworkIpv6Response200 & {
+    headers: Headers;
+};
+export type getPrivateNetworkIpv6ResponseError = getPrivateNetworkIpv6ResponseDefault & {
+    headers: Headers;
+};
+export type getPrivateNetworkIpv6Response = getPrivateNetworkIpv6ResponseSuccess | getPrivateNetworkIpv6ResponseError;
+export declare const getGetPrivateNetworkIpv6Url: (privateNetworkId: string) => string;
+/**
+ * @summary Retrieve the IPv6 configuration of a private network
+ */
+export declare const getPrivateNetworkIpv6: (privateNetworkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getPrivateNetworkIpv6Response>;
+export type enablePrivateNetworkIpv6Response202 = {
+    data: IPv6ResponseBody;
+    status: 202;
+};
+export type enablePrivateNetworkIpv6Response409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type enablePrivateNetworkIpv6ResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type enablePrivateNetworkIpv6ResponseSuccess = enablePrivateNetworkIpv6Response202 & {
+    headers: Headers;
+};
+export type enablePrivateNetworkIpv6ResponseError = (enablePrivateNetworkIpv6Response409 | enablePrivateNetworkIpv6ResponseDefault) & {
+    headers: Headers;
+};
+export type enablePrivateNetworkIpv6Response = enablePrivateNetworkIpv6ResponseSuccess | enablePrivateNetworkIpv6ResponseError;
+export declare const getEnablePrivateNetworkIpv6Url: (privateNetworkId: string) => string;
+/**
+ * Allocates an IPv6 prefix to the private network. Addresses are assigned to instances by the network itself, can be neither requested nor released individually, and consume no public IPv4 address.
+ *
+ * If the private network is not yet connected to the internet, connectivity is established as part of this call.
+ * @summary Enable IPv6 on a private network
+ */
+export declare const enablePrivateNetworkIpv6: (privateNetworkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<enablePrivateNetworkIpv6Response>;
+export type disablePrivateNetworkIpv6Response202 = {
+    data: IPv6ResponseBody;
+    status: 202;
+};
+export type disablePrivateNetworkIpv6Response409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type disablePrivateNetworkIpv6ResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type disablePrivateNetworkIpv6ResponseSuccess = disablePrivateNetworkIpv6Response202 & {
+    headers: Headers;
+};
+export type disablePrivateNetworkIpv6ResponseError = (disablePrivateNetworkIpv6Response409 | disablePrivateNetworkIpv6ResponseDefault) & {
+    headers: Headers;
+};
+export type disablePrivateNetworkIpv6Response = disablePrivateNetworkIpv6ResponseSuccess | disablePrivateNetworkIpv6ResponseError;
+export declare const getDisablePrivateNetworkIpv6Url: (privateNetworkId: string) => string;
+/**
+ * A released prefix is not re-allocated immediately.
+ * @summary Disable IPv6 on a private network
+ */
+export declare const disablePrivateNetworkIpv6: (privateNetworkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<disablePrivateNetworkIpv6Response>;
+export type listRoutesResponse200 = {
+    data: RouteListResponseBody;
+    status: 200;
+};
+export type listRoutesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listRoutesResponseSuccess = listRoutesResponse200 & {
+    headers: Headers;
+};
+export type listRoutesResponseError = listRoutesResponseDefault & {
+    headers: Headers;
+};
+export type listRoutesResponse = listRoutesResponseSuccess | listRoutesResponseError;
+export declare const getListRoutesUrl: (privateNetworkId: string, params?: ListRoutesParams) => string;
+/**
+ * @summary List static routes
+ */
+export declare const listRoutes: (privateNetworkId: string, params?: ListRoutesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listRoutesResponse>;
+export type createRouteResponse201 = {
+    data: RouteResource;
+    status: 201;
+};
+export type createRouteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createRouteResponseSuccess = createRouteResponse201 & {
+    headers: Headers;
+};
+export type createRouteResponseError = createRouteResponseDefault & {
+    headers: Headers;
+};
+export type createRouteResponse = createRouteResponseSuccess | createRouteResponseError;
+export declare const getCreateRouteUrl: (privateNetworkId: string) => string;
+/**
+ * Three forms that would sever connectivity are rejected: a destination of `0.0.0.0/0`, which overrides the default route and takes every floating IP offline immediately; a destination equal to the CIDR of a subnet, which overrides its directly connected route; and a next hop equal to the gateway of a subnet, which points back at the router itself.
+ * @summary Create a static route
+ */
+export declare const createRoute: (privateNetworkId: string, createRouteRequestBody: CreateRouteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createRouteResponse>;
+export type deleteRouteResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteRouteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteRouteResponseSuccess = deleteRouteResponse204 & {
+    headers: Headers;
+};
+export type deleteRouteResponseError = deleteRouteResponseDefault & {
+    headers: Headers;
+};
+export type deleteRouteResponse = deleteRouteResponseSuccess | deleteRouteResponseError;
+export declare const getDeleteRouteUrl: (privateNetworkId: string, routeId: string) => string;
+/**
+ * @summary Delete a static route
+ */
+export declare const deleteRoute: (privateNetworkId: string, routeId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteRouteResponse>;
+export type listSubnetsResponse200 = {
+    data: SubnetListResponseBody;
+    status: 200;
+};
+export type listSubnetsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSubnetsResponseSuccess = listSubnetsResponse200 & {
+    headers: Headers;
+};
+export type listSubnetsResponseError = listSubnetsResponseDefault & {
+    headers: Headers;
+};
+export type listSubnetsResponse = listSubnetsResponseSuccess | listSubnetsResponseError;
+export declare const getListSubnetsUrl: (privateNetworkId: string, params?: ListSubnetsParams) => string;
+/**
+ * IPv6 subnets are included, with `ip_version` 6. They are created when IPv6 is enabled and cannot be deleted individually.
+ * @summary List subnets
+ */
+export declare const listSubnets: (privateNetworkId: string, params?: ListSubnetsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSubnetsResponse>;
+export type createSubnetResponse201 = {
+    data: SubnetResource;
+    status: 201;
+};
+export type createSubnetResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createSubnetResponseSuccess = createSubnetResponse201 & {
+    headers: Headers;
+};
+export type createSubnetResponseError = createSubnetResponseDefault & {
+    headers: Headers;
+};
+export type createSubnetResponse = createSubnetResponseSuccess | createSubnetResponseError;
+export declare const getCreateSubnetUrl: (privateNetworkId: string) => string;
+/**
+ * @summary Create a subnet
+ */
+export declare const createSubnet: (privateNetworkId: string, createSubnetRequestBody: CreateSubnetRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createSubnetResponse>;
+export type suggestSubnetCidrResponse200 = {
+    data: NextFreeCidrResponseBody;
+    status: 200;
+};
+export type suggestSubnetCidrResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type suggestSubnetCidrResponseSuccess = suggestSubnetCidrResponse200 & {
+    headers: Headers;
+};
+export type suggestSubnetCidrResponseError = suggestSubnetCidrResponseDefault & {
+    headers: Headers;
+};
+export type suggestSubnetCidrResponse = suggestSubnetCidrResponseSuccess | suggestSubnetCidrResponseError;
+export declare const getSuggestSubnetCidrUrl: (privateNetworkId: string, params?: SuggestSubnetCidrParams) => string;
+/**
+ * The returned value is a suggestion and is validated again when the subnet is created. It exists to avoid errors when computing the next free CIDR by hand.
+ * @summary Suggest the next free CIDR
+ */
+export declare const suggestSubnetCidr: (privateNetworkId: string, params?: SuggestSubnetCidrParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<suggestSubnetCidrResponse>;
+export type deleteSubnetResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteSubnetResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteSubnetResponseSuccess = deleteSubnetResponse204 & {
+    headers: Headers;
+};
+export type deleteSubnetResponseError = deleteSubnetResponseDefault & {
+    headers: Headers;
+};
+export type deleteSubnetResponse = deleteSubnetResponseSuccess | deleteSubnetResponseError;
+export declare const getDeleteSubnetUrl: (privateNetworkId: string, subnetId: string) => string;
+/**
+ * Deletion is rejected while network interfaces remain in the subnet, or while a static route has a next hop inside its CIDR.
+ * @summary Delete a subnet
+ */
+export declare const deleteSubnet: (privateNetworkId: string, subnetId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSubnetResponse>;
+export type listSecurityGroupsResponse200 = {
+    data: SecurityGroupListResponseBody;
+    status: 200;
+};
+export type listSecurityGroupsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSecurityGroupsResponseSuccess = listSecurityGroupsResponse200 & {
+    headers: Headers;
+};
+export type listSecurityGroupsResponseError = listSecurityGroupsResponseDefault & {
+    headers: Headers;
+};
+export type listSecurityGroupsResponse = listSecurityGroupsResponseSuccess | listSecurityGroupsResponseError;
+export declare const getListSecurityGroupsUrl: (params?: ListSecurityGroupsParams) => string;
+/**
+ * @summary List security groups
+ */
+export declare const listSecurityGroups: (params?: ListSecurityGroupsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSecurityGroupsResponse>;
+export type createSecurityGroupResponse201 = {
+    data: SecurityGroupResource;
+    status: 201;
+};
+export type createSecurityGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createSecurityGroupResponseSuccess = createSecurityGroupResponse201 & {
+    headers: Headers;
+};
+export type createSecurityGroupResponseError = createSecurityGroupResponseDefault & {
+    headers: Headers;
+};
+export type createSecurityGroupResponse = createSecurityGroupResponseSuccess | createSecurityGroupResponseError;
+export declare const getCreateSecurityGroupUrl: () => string;
+/**
+ * A new security group carries one rule, permitting ICMP fragmentation-needed messages (type 3, code 4). Without it path MTU discovery fails, which presents as connections that establish and then stall on large packets.
+ * @summary Create a security group
+ */
+export declare const createSecurityGroup: (createSecurityGroupRequestBody: CreateSecurityGroupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createSecurityGroupResponse>;
+export type getSecurityGroupResponse200 = {
+    data: SecurityGroupResource;
+    status: 200;
+};
+export type getSecurityGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSecurityGroupResponseSuccess = getSecurityGroupResponse200 & {
+    headers: Headers;
+};
+export type getSecurityGroupResponseError = getSecurityGroupResponseDefault & {
+    headers: Headers;
+};
+export type getSecurityGroupResponse = getSecurityGroupResponseSuccess | getSecurityGroupResponseError;
+export declare const getGetSecurityGroupUrl: (securityGroupId: string) => string;
+/**
+ * @summary Retrieve a security group
+ */
+export declare const getSecurityGroup: (securityGroupId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSecurityGroupResponse>;
+export type renameSecurityGroupResponse200 = {
+    data: SecurityGroupResource;
+    status: 200;
+};
+export type renameSecurityGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renameSecurityGroupResponseSuccess = renameSecurityGroupResponse200 & {
+    headers: Headers;
+};
+export type renameSecurityGroupResponseError = renameSecurityGroupResponseDefault & {
+    headers: Headers;
+};
+export type renameSecurityGroupResponse = renameSecurityGroupResponseSuccess | renameSecurityGroupResponseError;
+export declare const getRenameSecurityGroupUrl: (securityGroupId: string) => string;
+/**
+ * Changes the name only. Use the rule endpoints to change rules.
+ * @summary Rename a security group
+ */
+export declare const renameSecurityGroup: (securityGroupId: string, renameSecurityGroupRequestBody: RenameSecurityGroupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renameSecurityGroupResponse>;
+export type deleteSecurityGroupResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteSecurityGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteSecurityGroupResponseSuccess = deleteSecurityGroupResponse204 & {
+    headers: Headers;
+};
+export type deleteSecurityGroupResponseError = deleteSecurityGroupResponseDefault & {
+    headers: Headers;
+};
+export type deleteSecurityGroupResponse = deleteSecurityGroupResponseSuccess | deleteSecurityGroupResponseError;
+export declare const getDeleteSecurityGroupUrl: (securityGroupId: string) => string;
+/**
+ * The default security group cannot be deleted, as it is released with the private network. A security group still referenced by a network interface cannot be deleted either.
+ * @summary Delete a security group
+ */
+export declare const deleteSecurityGroup: (securityGroupId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSecurityGroupResponse>;
+export type listSecurityGroupRulesResponse200 = {
+    data: SecurityRuleListResponseBody;
+    status: 200;
+};
+export type listSecurityGroupRulesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSecurityGroupRulesResponseSuccess = listSecurityGroupRulesResponse200 & {
+    headers: Headers;
+};
+export type listSecurityGroupRulesResponseError = listSecurityGroupRulesResponseDefault & {
+    headers: Headers;
+};
+export type listSecurityGroupRulesResponse = listSecurityGroupRulesResponseSuccess | listSecurityGroupRulesResponseError;
+export declare const getListSecurityGroupRulesUrl: (securityGroupId: string, params?: ListSecurityGroupRulesParams) => string;
+/**
+ * @summary List security group rules
+ */
+export declare const listSecurityGroupRules: (securityGroupId: string, params?: ListSecurityGroupRulesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSecurityGroupRulesResponse>;
+export type createSecurityGroupRuleResponse201 = {
+    data: SecurityRuleResource;
+    status: 201;
+};
+export type createSecurityGroupRuleResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createSecurityGroupRuleResponseSuccess = createSecurityGroupRuleResponse201 & {
+    headers: Headers;
+};
+export type createSecurityGroupRuleResponseError = createSecurityGroupRuleResponseDefault & {
+    headers: Headers;
+};
+export type createSecurityGroupRuleResponse = createSecurityGroupRuleResponseSuccess | createSecurityGroupRuleResponseError;
+export declare const getCreateSecurityGroupRuleUrl: (securityGroupId: string) => string;
+/**
+ * Adding an identical rule twice is rejected. For that comparison `0.0.0.0/0`, `::/0` and an omitted value are treated as equivalent.
+ * @summary Create a security group rule
+ */
+export declare const createSecurityGroupRule: (securityGroupId: string, createSecurityRuleRequestBody: CreateSecurityRuleRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createSecurityGroupRuleResponse>;
+export type deleteSecurityGroupRuleResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteSecurityGroupRuleResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteSecurityGroupRuleResponseSuccess = deleteSecurityGroupRuleResponse204 & {
+    headers: Headers;
+};
+export type deleteSecurityGroupRuleResponseError = deleteSecurityGroupRuleResponseDefault & {
+    headers: Headers;
+};
+export type deleteSecurityGroupRuleResponse = deleteSecurityGroupRuleResponseSuccess | deleteSecurityGroupRuleResponseError;
+export declare const getDeleteSecurityGroupRuleUrl: (securityGroupId: string, ruleId: string) => string;
+/**
+ * @summary Delete a security group rule
+ */
+export declare const deleteSecurityGroupRule: (securityGroupId: string, ruleId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSecurityGroupRuleResponse>;
+export type getSnapshotQuotaResponse200 = {
+    data: SnapshotQuota;
+    status: 200;
+};
+export type getSnapshotQuotaResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSnapshotQuotaResponseSuccess = getSnapshotQuotaResponse200 & {
+    headers: Headers;
+};
+export type getSnapshotQuotaResponseError = getSnapshotQuotaResponseDefault & {
+    headers: Headers;
+};
+export type getSnapshotQuotaResponse = getSnapshotQuotaResponseSuccess | getSnapshotQuotaResponseError;
+export declare const getGetSnapshotQuotaUrl: (regionId: string) => string;
+/**
+ * The snapshot count quota for the authenticated project in this region. Counts simultaneous
+ * snapshot holdings, not lifetime create calls or storage bytes. Without an active purchase,
+ * limit and available are zero; existing holdings, if any, still appear in used.
+ *
+ * pending and provisioning creations reserve a slot. Snapshots being deleted or whose cleanup
+ * is uncertain retain their slots until absence or deletion is confirmed. available is
+ * max(limit - used, 0) while active, and zero when creation is not permitted; additional
+ * creation is refused while the quota is inactive, suspended or exhausted.
+ *
+ * Canceling the quota's subscription through Billing is refused while any snapshot exists in
+ * the region: the cancellation fails with SNAPSHOT_QUOTA_IN_USE. Reclaiming the quota for
+ * non-payment deletes its snapshots, as for other reclaimed resources.
+ * @summary Get regional snapshot quota
+ */
+export declare const getSnapshotQuota: (regionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSnapshotQuotaResponse>;
+export type setSnapshotQuotaResponse202 = {
+    data: SetSnapshotQuotaResponseBody;
+    status: 202;
+};
+export type setSnapshotQuotaResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type setSnapshotQuotaResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type setSnapshotQuotaResponseSuccess = setSnapshotQuotaResponse202 & {
+    headers: Headers;
+};
+export type setSnapshotQuotaResponseError = (setSnapshotQuotaResponse409 | setSnapshotQuotaResponseDefault) & {
+    headers: Headers;
+};
+export type setSnapshotQuotaResponse = setSnapshotQuotaResponseSuccess | setSnapshotQuotaResponseError;
+export declare const getSetSnapshotQuotaUrl: (regionId: string) => string;
+/**
+ * Purchases or changes the maximum number of snapshots this project may hold in this region.
+ * limit is the target total, not an additional number of slots or a consumable create allowance.
+ * billing chooses one of the quota's pricing options; a change of an existing purchase keeps its
+ * billing mode and period, and billing must name that option. The purchased quantity is this count.
+ *
+ * Returns the quota with the order. pending_limit records the target while the current limit stays
+ * in force; the new limit applies once the order is accepted and the quota is activated. Snapshots
+ * create no further orders or subscriptions, and deleting one frees a slot without refunding the
+ * quota purchase.
+ *
+ * Repeating the same target and billing choice while its purchase is pending returns the same order. A
+ * conflicting pending purchase is refused with SNAPSHOT_QUOTA_CHANGE_PENDING. An already effective
+ * identical target and billing choice returns its existing purchase without charging again; renewing its
+ * term is a separate Billing renewal operation. A requested limit below used is refused with
+ * 409 SNAPSHOT_QUOTA_IN_USE, with meta.used and meta.limit. A change never deletes snapshots.
+ * @summary Set regional snapshot quota
+ */
+export declare const setSnapshotQuota: (regionId: string, setSnapshotQuotaRequestBody: SetSnapshotQuotaRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setSnapshotQuotaResponse>;
+export type createSnapshotQuotaQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createSnapshotQuotaQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createSnapshotQuotaQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createSnapshotQuotaQuoteResponseSuccess = createSnapshotQuotaQuoteResponse200 & {
+    headers: Headers;
+};
+export type createSnapshotQuotaQuoteResponseError = (createSnapshotQuotaQuoteResponse409 | createSnapshotQuotaQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createSnapshotQuotaQuoteResponse = createSnapshotQuotaQuoteResponseSuccess | createSnapshotQuotaQuoteResponseError;
+export declare const getCreateSnapshotQuotaQuoteUrl: (regionId: string) => string;
+/**
+ * Prices what `set-snapshot-quota` would order, including a change of an existing purchase as of now, for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote setting the regional snapshot quota
+ */
+export declare const createSnapshotQuotaQuote: (regionId: string, setSnapshotQuotaQuoteRequestBody: SetSnapshotQuotaQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createSnapshotQuotaQuoteResponse>;
+export type getBackupServiceResponse200 = {
+    data: BackupService;
+    status: 200;
+};
+export type getBackupServiceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getBackupServiceResponseSuccess = getBackupServiceResponse200 & {
+    headers: Headers;
+};
+export type getBackupServiceResponseError = getBackupServiceResponseDefault & {
+    headers: Headers;
+};
+export type getBackupServiceResponse = getBackupServiceResponseSuccess | getBackupServiceResponseError;
+export declare const getGetBackupServiceUrl: (regionId: string) => string;
+/**
+ * The backup service of the authenticated project in this region. Backups can be created only while it is `active`. Each hour, Compute covers retained backup capacity up to the total `capacity_gib` of the capacity packs active in the region and meters only the excess on this service's subscription, per GiB-hour.
+ *
+ * Canceling the service's subscription through Billing is refused while any backup is retained in the region: the cancellation fails with `BACKUP_SERVICE_IN_USE`. Delete the backups first. Capacity packs are canceled separately, under their own refund terms. Reclaiming the service for non-payment deletes its backups.
+ * @summary Get the backup service of a region
+ */
+export declare const getBackupService: (regionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getBackupServiceResponse>;
+export type createBackupServiceResponse202 = {
+    data: CreateBackupServiceResponseBody;
+    status: 202;
+};
+export type createBackupServiceResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createBackupServiceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type createBackupServiceResponseSuccess = createBackupServiceResponse202 & {
+    headers: Headers;
+};
+export type createBackupServiceResponseError = (createBackupServiceResponse409 | createBackupServiceResponseDefault) & {
+    headers: Headers;
+};
+export type createBackupServiceResponse = createBackupServiceResponseSuccess | createBackupServiceResponseError;
+export declare const getCreateBackupServiceUrl: (regionId: string) => string;
+/**
+ * Purchases the backup service for this project and region. The service itself has no charge; backups are billed under it postpaid, by retained capacity. It takes no billing choice. Returns the service as `pending` with its order; it becomes `active` once the order is accepted.
+ *
+ * Refused with 409 `BACKUP_SERVICE_EXISTS` while an activation is pending or the service is active or suspended.
+ * @summary Activate the backup service in a region
+ */
+export declare const createBackupService: (regionId: string, createBackupServiceRequestBody: CreateBackupServiceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBackupServiceResponse>;
+export type createBackupServiceQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createBackupServiceQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createBackupServiceQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createBackupServiceQuoteResponseSuccess = createBackupServiceQuoteResponse200 & {
+    headers: Headers;
+};
+export type createBackupServiceQuoteResponseError = (createBackupServiceQuoteResponse409 | createBackupServiceQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createBackupServiceQuoteResponse = createBackupServiceQuoteResponseSuccess | createBackupServiceQuoteResponseError;
+export declare const getCreateBackupServiceQuoteUrl: (regionId: string) => string;
+/**
+ * Prices what `create-backup-service` would order for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote activating the backup service
+ */
+export declare const createBackupServiceQuote: (regionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBackupServiceQuoteResponse>;
+export type listBackupCapacityPacksResponse200 = {
+    data: BackupCapacityPackListResponseBody;
+    status: 200;
+};
+export type listBackupCapacityPacksResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listBackupCapacityPacksResponseSuccess = listBackupCapacityPacksResponse200 & {
+    headers: Headers;
+};
+export type listBackupCapacityPacksResponseError = listBackupCapacityPacksResponseDefault & {
+    headers: Headers;
+};
+export type listBackupCapacityPacksResponse = listBackupCapacityPacksResponseSuccess | listBackupCapacityPacksResponseError;
+export declare const getListBackupCapacityPacksUrl: (regionId: string, params?: ListBackupCapacityPacksParams) => string;
+/**
+ * The capacity packs of the authenticated project in this region, newest first, including ended ones.
+ * @summary List backup capacity packs
+ */
+export declare const listBackupCapacityPacks: (regionId: string, params?: ListBackupCapacityPacksParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listBackupCapacityPacksResponse>;
+export type createBackupCapacityPackResponse202 = {
+    data: CreateBackupCapacityPackResponseBody;
+    status: 202;
+};
+export type createBackupCapacityPackResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createBackupCapacityPackResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type createBackupCapacityPackResponseSuccess = createBackupCapacityPackResponse202 & {
+    headers: Headers;
+};
+export type createBackupCapacityPackResponseError = (createBackupCapacityPackResponse409 | createBackupCapacityPackResponseDefault) & {
+    headers: Headers;
+};
+export type createBackupCapacityPackResponse = createBackupCapacityPackResponseSuccess | createBackupCapacityPackResponseError;
+export declare const getCreateBackupCapacityPackUrl: (regionId: string) => string;
+/**
+ * Purchases a capacity pack, prepaid backup capacity for this project and region bought by month or year: `billing` must be prepaid with a period, as offered in the backup service's `capacity_pack_pricing`. Compute applies the coverage: each hour, retained backup capacity up to the total `capacity_gib` of the packs active in the region is covered, and Compute meters only the excess on the backup service's subscription. A pack is not a Billing allowance or credit; Billing takes its order and payment and handles its renewal and cancellation through the pack's subscription.
+ *
+ * Returns the pack as `pending` with its order; it applies once the order is accepted. Refused with 409 `BACKUP_SERVICE_NOT_ACTIVE` and `meta.region_id` when the region's backup service is not active.
+ * @summary Buy a backup capacity pack
+ */
+export declare const createBackupCapacityPack: (regionId: string, createBackupCapacityPackRequestBody: CreateBackupCapacityPackRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBackupCapacityPackResponse>;
+export type createBackupCapacityPackQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createBackupCapacityPackQuoteResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type createBackupCapacityPackQuoteResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createBackupCapacityPackQuoteResponseSuccess = createBackupCapacityPackQuoteResponse200 & {
+    headers: Headers;
+};
+export type createBackupCapacityPackQuoteResponseError = (createBackupCapacityPackQuoteResponse409 | createBackupCapacityPackQuoteResponseDefault) & {
+    headers: Headers;
+};
+export type createBackupCapacityPackQuoteResponse = createBackupCapacityPackQuoteResponseSuccess | createBackupCapacityPackQuoteResponseError;
+export declare const getCreateBackupCapacityPackQuoteUrl: (regionId: string) => string;
+/**
+ * Prices what `create-backup-capacity-pack` would order for the same request, without ordering or creating anything; nothing is reserved or recorded. Billing evaluates applicable account discounts and tax as for automatic checkout. `total` is what automatic checkout would collect before credit grants and balance; give it as `checkout.expected_amount` to be refused rather than charged a different amount. `estimated_usage_amount` projects postpaid usage over one month of 730 hours and is not collected at checkout. A request the purchase would refuse is refused the same way. Prices may change, so quote again before final confirmation.
+ * @summary Quote buying a backup capacity pack
+ */
+export declare const createBackupCapacityPackQuote: (regionId: string, createBackupCapacityPackQuoteRequestBody: CreateBackupCapacityPackQuoteRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBackupCapacityPackQuoteResponse>;
+export type listSnapshotsResponse200 = {
+    data: SnapshotListResponseBody;
+    status: 200;
+};
+export type listSnapshotsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSnapshotsResponseSuccess = listSnapshotsResponse200 & {
+    headers: Headers;
+};
+export type listSnapshotsResponseError = listSnapshotsResponseDefault & {
+    headers: Headers;
+};
+export type listSnapshotsResponse = listSnapshotsResponseSuccess | listSnapshotsResponseError;
+export declare const getListSnapshotsUrl: (params?: ListSnapshotsParams) => string;
+/**
+ * @summary List snapshots
+ */
+export declare const listSnapshots: (params?: ListSnapshotsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSnapshotsResponse>;
+export type createSnapshotResponse202 = {
+    data: SnapshotResource;
+    status: 202;
+};
+export type createSnapshotResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type createSnapshotResponseSuccess = createSnapshotResponse202 & {
+    headers: Headers;
+};
+export type createSnapshotResponseError = createSnapshotResponseDefault & {
+    headers: Headers;
+};
+export type createSnapshotResponse = createSnapshotResponseSuccess | createSnapshotResponseError;
+export declare const getCreateSnapshotUrl: () => string;
+/**
+ * Disks attached to a running instance can be snapshotted. A snapshot records the state of the block device at a point in time and may be inconsistent at the file-system level, so run `sync` inside the instance first where the data matters.
+ *
+ * **A snapshot of a system disk cannot be used to revert that system disk**: reverting requires the disk to be detached, and a system disk cannot be detached. It can be used to create a new data disk. To preserve and restore an entire system, use a private image; for a copy that crosses availability zones and survives deletion of the disk, use a backup.
+ *
+ * Snapshot slots are purchased separately for this project and the source disk's region. This operation reserves one available slot and returns the snapshot as `pending`; it places no order and charges nothing. `pending` and `provisioning` snapshots occupy slots, so concurrent requests cannot exceed the purchased limit. Read the snapshot until it is `available` or `failed`.
+ *
+ * Refused with SNAPSHOT_QUOTA_EXCEEDED when no slot is available. meta.region_id, meta.limit and meta.used identify the applicable quota. A failed creation releases its slot only after any snapshot data has been confirmed absent or removed.
+ * @summary Create a snapshot
+ */
+export declare const createSnapshot: (createSnapshotRequestBody: CreateSnapshotRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createSnapshotResponse>;
+export type getSnapshotResponse200 = {
+    data: SnapshotResource;
+    status: 200;
+};
+export type getSnapshotResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSnapshotResponseSuccess = getSnapshotResponse200 & {
+    headers: Headers;
+};
+export type getSnapshotResponseError = getSnapshotResponseDefault & {
+    headers: Headers;
+};
+export type getSnapshotResponse = getSnapshotResponseSuccess | getSnapshotResponseError;
+export declare const getGetSnapshotUrl: (snapshotId: string) => string;
+/**
+ * @summary Retrieve a snapshot
+ */
+export declare const getSnapshot: (snapshotId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSnapshotResponse>;
+export type renameSnapshotResponse200 = {
+    data: SnapshotResource;
+    status: 200;
+};
+export type renameSnapshotResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type renameSnapshotResponseSuccess = renameSnapshotResponse200 & {
+    headers: Headers;
+};
+export type renameSnapshotResponseError = renameSnapshotResponseDefault & {
+    headers: Headers;
+};
+export type renameSnapshotResponse = renameSnapshotResponseSuccess | renameSnapshotResponseError;
+export declare const getRenameSnapshotUrl: (snapshotId: string) => string;
+/**
+ * @summary Rename a snapshot
+ */
+export declare const renameSnapshot: (snapshotId: string, renameSnapshotRequestBody: RenameSnapshotRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renameSnapshotResponse>;
+export type deleteSnapshotResponse202 = {
+    data: SnapshotResource;
+    status: 202;
+};
+export type deleteSnapshotResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deleteSnapshotResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deleteSnapshotResponseSuccess = deleteSnapshotResponse202 & {
+    headers: Headers;
+};
+export type deleteSnapshotResponseError = (deleteSnapshotResponse409 | deleteSnapshotResponseDefault) & {
+    headers: Headers;
+};
+export type deleteSnapshotResponse = deleteSnapshotResponseSuccess | deleteSnapshotResponseError;
+export declare const getDeleteSnapshotUrl: (snapshotId: string) => string;
+/**
+ * Deletes this snapshot without canceling the project's snapshot quota purchase. A snapshot has no individual Billing subscription. Its slot stays occupied until the deletion is confirmed.
+ * @summary Delete a snapshot
+ */
+export declare const deleteSnapshot: (snapshotId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSnapshotResponse>;
+export type listIpv4PoolsResponse200 = {
+    data: IPv4PoolListResponseBody;
+    status: 200;
+};
+export type listIpv4PoolsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listIpv4PoolsResponseSuccess = listIpv4PoolsResponse200 & {
+    headers: Headers;
+};
+export type listIpv4PoolsResponseError = listIpv4PoolsResponseDefault & {
+    headers: Headers;
+};
+export type listIpv4PoolsResponse = listIpv4PoolsResponseSuccess | listIpv4PoolsResponseError;
+export declare const getListIpv4PoolsUrl: (params?: ListIpv4PoolsParams) => string;
+/**
+ * Lists the public IP pools available for new allocations in this region.
+ * @summary List public IP pools
+ */
+export declare const listIpv4Pools: (params?: ListIpv4PoolsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listIpv4PoolsResponse>;
+export type listPeeringsResponse200 = {
+    data: PeeringListResponseBody;
+    status: 200;
+};
+export type listPeeringsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listPeeringsResponseSuccess = listPeeringsResponse200 & {
+    headers: Headers;
+};
+export type listPeeringsResponseError = listPeeringsResponseDefault & {
+    headers: Headers;
+};
+export type listPeeringsResponse = listPeeringsResponseSuccess | listPeeringsResponseError;
+export declare const getListPeeringsUrl: (params?: ListPeeringsParams) => string;
+/**
+ * @summary List peerings
+ */
+export declare const listPeerings: (params?: ListPeeringsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPeeringsResponse>;
+export type createPeeringResponse201 = {
+    data: PeeringResource;
+    status: 201;
+};
+export type createPeeringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createPeeringResponseSuccess = createPeeringResponse201 & {
+    headers: Headers;
+};
+export type createPeeringResponseError = createPeeringResponseDefault & {
+    headers: Headers;
+};
+export type createPeeringResponse = createPeeringResponseSuccess | createPeeringResponseError;
+export declare const getCreatePeeringUrl: () => string;
+/**
+ * Request IPv4 peering between non-overlapping VPCs in the same Region. The target project must accept before any connectivity is created. Does not change security groups or provide transitive routing.
+ * @summary Create peering
+ */
+export declare const createPeering: (createPeeringRequestBody: CreatePeeringRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createPeeringResponse>;
+export type getPeeringResponse200 = {
+    data: PeeringResource;
+    status: 200;
+};
+export type getPeeringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getPeeringResponseSuccess = getPeeringResponse200 & {
+    headers: Headers;
+};
+export type getPeeringResponseError = getPeeringResponseDefault & {
+    headers: Headers;
+};
+export type getPeeringResponse = getPeeringResponseSuccess | getPeeringResponseError;
+export declare const getGetPeeringUrl: (peeringId: string) => string;
+/**
+ * @summary Get peering
+ */
+export declare const getPeering: (peeringId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getPeeringResponse>;
+export type deletePeeringResponse202 = {
+    data: PeeringResource;
+    status: 202;
+};
+export type deletePeeringResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type deletePeeringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type deletePeeringResponseSuccess = deletePeeringResponse202 & {
+    headers: Headers;
+};
+export type deletePeeringResponseError = (deletePeeringResponse409 | deletePeeringResponseDefault) & {
+    headers: Headers;
+};
+export type deletePeeringResponse = deletePeeringResponseSuccess | deletePeeringResponseError;
+export declare const getDeletePeeringUrl: (peeringId: string) => string;
+/**
+ * @summary Delete peering
+ */
+export declare const deletePeering: (peeringId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deletePeeringResponse>;
+export type acceptPeeringResponse202 = {
+    data: PeeringResource;
+    status: 202;
+};
+export type acceptPeeringResponse409 = {
+    data: ConflictResponse;
+    status: 409;
+};
+export type acceptPeeringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 202 | 409>;
+};
+export type acceptPeeringResponseSuccess = acceptPeeringResponse202 & {
+    headers: Headers;
+};
+export type acceptPeeringResponseError = (acceptPeeringResponse409 | acceptPeeringResponseDefault) & {
+    headers: Headers;
+};
+export type acceptPeeringResponse = acceptPeeringResponseSuccess | acceptPeeringResponseError;
+export declare const getAcceptPeeringUrl: (peeringId: string) => string;
+/**
+ * @summary Accept peering
+ */
+export declare const acceptPeering: (peeringId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<acceptPeeringResponse>;
+export type rejectPeeringResponse200 = {
+    data: PeeringResource;
+    status: 200;
+};
+export type rejectPeeringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type rejectPeeringResponseSuccess = rejectPeeringResponse200 & {
+    headers: Headers;
+};
+export type rejectPeeringResponseError = rejectPeeringResponseDefault & {
+    headers: Headers;
+};
+export type rejectPeeringResponse = rejectPeeringResponseSuccess | rejectPeeringResponseError;
+export declare const getRejectPeeringUrl: (peeringId: string) => string;
+/**
+ * @summary Reject peering
+ */
+export declare const rejectPeering: (peeringId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<rejectPeeringResponse>;