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

package/dist/compute/v1/generated/functions.js

@@ -0,0 +1,2673 @@
+export const getListBackupsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/backups?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/backups`;
+};
+/**
+ * @summary List backups
+ */
+export const listBackups = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListBackupsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateBackupUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/backups`;
+};
+/**
+ * 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 const createBackup = async (createBackupRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateBackupUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createBackupRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetBackupUrl = (backupId) => {
+    return `https://compute.leaflow.cloud/api/v1/backups/${encodeURIComponent(String(backupId))}`;
+};
+/**
+ * Returns the stored state of the backup; it does not query the cloud. Use it to poll creation progress.
+ * @summary Retrieve a backup
+ */
+export const getBackup = async (backupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetBackupUrl(backupId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenameBackupUrl = (backupId) => {
+    return `https://compute.leaflow.cloud/api/v1/backups/${encodeURIComponent(String(backupId))}`;
+};
+/**
+ * @summary Rename a backup
+ */
+export const renameBackup = async (backupId, renameBackupRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenameBackupUrl(backupId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renameBackupRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteBackupUrl = (backupId) => {
+    return `https://compute.leaflow.cloud/api/v1/backups/${encodeURIComponent(String(backupId))}`;
+};
+/**
+ * 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 const deleteBackup = async (backupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBackupUrl(backupId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRestoreBackupUrl = (backupId) => {
+    return `https://compute.leaflow.cloud/api/v1/backups/${encodeURIComponent(String(backupId))}/restore`;
+};
+/**
+ * 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 Checkout Session; it cannot be attached until it is `available`.
+ * @summary Restore from a backup
+ */
+export const restoreBackup = async (backupId, restoreBackupRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRestoreBackupUrl(backupId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(restoreBackupRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListDiskTypesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/disk-types?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/disk-types`;
+};
+/**
+ * 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 const listDiskTypes = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListDiskTypesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetDiskTypeUrl = (diskTypeId) => {
+    return `https://compute.leaflow.cloud/api/v1/disk-types/${encodeURIComponent(String(diskTypeId))}`;
+};
+/**
+ * Retrieve capacity and performance constraints for an existing disk, including system disk types and types withdrawn from sale.
+ * @summary Get a disk type
+ */
+export const getDiskType = async (diskTypeId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetDiskTypeUrl(diskTypeId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListImagesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/images?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/images`;
+};
+/**
+ * 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 const listImages = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListImagesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateImageUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/images`;
+};
+/**
+ * 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 Checkout Session, 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, under the region's `private_image_billing`. Quote it with Billing first.
+ * @summary Capture an instance as a private image
+ */
+export const createImage = async (createImageRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateImageUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createImageRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetImageUrl = (imageId) => {
+    return `https://compute.leaflow.cloud/api/v1/images/${encodeURIComponent(String(imageId))}`;
+};
+/**
+ * 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 const getImage = async (imageId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetImageUrl(imageId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenameImageUrl = (imageId) => {
+    return `https://compute.leaflow.cloud/api/v1/images/${encodeURIComponent(String(imageId))}`;
+};
+/**
+ * Only a private image of this project can be renamed; any other image is reported as not found.
+ * @summary Rename a private image
+ */
+export const renameImage = async (imageId, renameImageRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenameImageUrl(imageId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renameImageRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteImageUrl = (imageId) => {
+    return `https://compute.leaflow.cloud/api/v1/images/${encodeURIComponent(String(imageId))}`;
+};
+/**
+ * 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.
+ *
+ * When subscriptions pay for the image, its `release_subscription_ids`, this request cancels them in Billing, and the response carries that cancellation. Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms, and release begins when Billing begins the cancellation. When any of them can only be canceled at the end of its paid period, all of them are canceled then, and the image is kept until `scheduled_at`. Deleting again while the cancellation is open returns it. Without subscriptions, deletion begins at once and `cancellation` is null.
+ * @summary Delete a private image
+ */
+export const deleteImage = async (imageId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteImageUrl(imageId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInstanceTypesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/instance-types?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/instance-types`;
+};
+/**
+ * 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 const listInstanceTypes = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInstanceTypesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListRegionsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/regions?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/regions`;
+};
+/**
+ * @summary List available regions
+ */
+export const listRegions = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListRegionsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListAvailabilityZonesUrl = (regionId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/availability-zones?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/availability-zones`;
+};
+/**
+ * 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 const listAvailabilityZones = async (regionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListAvailabilityZonesUrl(regionId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListDisksUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/disks?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/disks`;
+};
+/**
+ * When both `region_code` and `availability_zone` are supplied, only disks attachable to an instance at that location are returned.
+ * @summary List disks
+ */
+export const listDisks = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListDisksUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateDiskUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/disks`;
+};
+/**
+ * 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 const createDisk = async (createDiskRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateDiskUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createDiskRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetDiskUrl = (diskId) => {
+    return `https://compute.leaflow.cloud/api/v1/disks/${encodeURIComponent(String(diskId))}`;
+};
+/**
+ * Returns the stored state of the disk; it does not query the cloud.
+ * @summary Retrieve a disk
+ */
+export const getDisk = async (diskId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetDiskUrl(diskId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenameDiskUrl = (diskId) => {
+    return `https://compute.leaflow.cloud/api/v1/disks/${encodeURIComponent(String(diskId))}`;
+};
+/**
+ * Changes the name only. Use the resize endpoint for capacity; type and availability zone are immutable.
+ * @summary Rename a disk
+ */
+export const renameDisk = async (diskId, renameDiskRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenameDiskUrl(diskId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renameDiskRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteDiskUrl = (diskId) => {
+    return `https://compute.leaflow.cloud/api/v1/disks/${encodeURIComponent(String(diskId))}`;
+};
+/**
+ * Deletion is rejected while the disk is attached, or while snapshots created from it still exist.
+ *
+ * When subscriptions pay for the disk, its `release_subscription_ids`, this request cancels them in Billing, and the response carries that cancellation. Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms, and release begins when Billing begins the cancellation. When any of them can only be canceled at the end of its paid period, all of them are canceled then, and the disk is kept until `scheduled_at`. Deleting again while the cancellation is open returns it. Without subscriptions, deletion begins at once and `cancellation` is null.
+ * @summary Delete a disk
+ */
+export const deleteDisk = async (diskId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteDiskUrl(diskId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getResizeDiskUrl = (diskId) => {
+    return `https://compute.leaflow.cloud/api/v1/disks/${encodeURIComponent(String(diskId))}/resize`;
+};
+/**
+ * Capacity can only be increased; shrinking is not supported. Returns the disk with the Checkout Session for the resize, which keeps the disk's usage type and period. The disk shows the `resize` operation until the resize is applied, its Checkout Session expires or its order is canceled, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. The 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 checkout is not completed, the order is not accepted or the resize fails, the disk keeps its size and Billing 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 const resizeDisk = async (diskId, resizeDiskRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getResizeDiskUrl(diskId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(resizeDiskRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRevertDiskUrl = (diskId) => {
+    return `https://compute.leaflow.cloud/api/v1/disks/${encodeURIComponent(String(diskId))}/revert`;
+};
+/**
+ * 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 const revertDisk = async (diskId, revertDiskRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRevertDiskUrl(diskId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(revertDiskRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListFloatingIpsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/floating-ips?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/floating-ips`;
+};
+/**
+ * @summary List floating IPs
+ */
+export const listFloatingIps = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListFloatingIpsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAllocateFloatingIpUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/floating-ips`;
+};
+/**
+ * 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 Checkout Session; `address` is null until the address is allocated after the order is accepted. A requested `address` is not held while pending; if it is no longer available then, the 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 Checkout Session is created, when the private network's `status` is not `available`. `meta.private_network_id` names it.
+ * @summary Allocate a floating IP
+ */
+export const allocateFloatingIp = async (allocateFloatingIPRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAllocateFloatingIpUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(allocateFloatingIPRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetFloatingIpUrl = (floatingIpId) => {
+    return `https://compute.leaflow.cloud/api/v1/floating-ips/${encodeURIComponent(String(floatingIpId))}`;
+};
+/**
+ * @summary Retrieve a floating IP
+ */
+export const getFloatingIp = async (floatingIpId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetFloatingIpUrl(floatingIpId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getReleaseFloatingIpUrl = (floatingIpId) => {
+    return `https://compute.leaflow.cloud/api/v1/floating-ips/${encodeURIComponent(String(floatingIpId))}`;
+};
+/**
+ * Releases the floating IP after unbinding it. The floating IP shows the `delete` operation until it is released.
+ *
+ * When subscriptions pay for the address, its `release_subscription_ids`, this request cancels them in Billing, and the response carries that cancellation. Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms, and release begins when Billing begins the cancellation. When any of them can only be canceled at the end of its paid period, all of them are canceled then, and the floating IP is kept until `scheduled_at`. Deleting again while the cancellation is open returns it. Without subscriptions, release begins at once and `cancellation` is null.
+ * @summary Release a floating IP
+ */
+export const releaseFloatingIp = async (floatingIpId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getReleaseFloatingIpUrl(floatingIpId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetFloatingIpBandwidthUrl = (floatingIpId) => {
+    return `https://compute.leaflow.cloud/api/v1/floating-ips/${encodeURIComponent(String(floatingIpId))}/bandwidth`;
+};
+/**
+ * Changes the bandwidth of this floating IP through an order that keeps its usage type 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, its Checkout Session expires or its order is canceled, 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 checkout is not completed, the order is not accepted or the change fails, `bandwidth_mbps` keeps its value and Billing 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 const setFloatingIpBandwidth = async (floatingIpId, setFloatingIPBandwidthRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetFloatingIpBandwidthUrl(floatingIpId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(setFloatingIPBandwidthRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getBindFloatingIpUrl = (floatingIpId) => {
+    return `https://compute.leaflow.cloud/api/v1/floating-ips/${encodeURIComponent(String(floatingIpId))}/binding`;
+};
+/**
+ * The floating IP shows the `bind` operation until the binding is confirmed.
+ * @summary Bind a floating IP to a network interface
+ */
+export const bindFloatingIp = async (floatingIpId, bindFloatingIPRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getBindFloatingIpUrl(floatingIpId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(bindFloatingIPRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUnbindFloatingIpUrl = (floatingIpId) => {
+    return `https://compute.leaflow.cloud/api/v1/floating-ips/${encodeURIComponent(String(floatingIpId))}/binding`;
+};
+/**
+ * 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 const unbindFloatingIp = async (floatingIpId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getUnbindFloatingIpUrl(floatingIpId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInstancesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/instances?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/instances`;
+};
+/**
+ * Every instance in the project, newest first, in their stored state.
+ * @summary List instances
+ */
+export const listInstances = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInstancesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getLaunchInstanceUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/instances`;
+};
+/**
+ * Creates a Billing Checkout Session, including for metered pricing, and returns one `pending` instance per requested instance with it. `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, the instances stay `pending` until the customer completes checkout in Billing and the order is paid; an expired Checkout Session, or a canceled or expired order, leaves them `failed` with `checkout_expired`, `order_canceled` or `order_expired`. Do not submit another creation request after paying. After an uncertain response, look the Checkout Session up in Billing before submitting again.
+ *
+ * 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 Checkout Session 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 const launchInstance = async (launchInstanceRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getLaunchInstanceUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(launchInstanceRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}`;
+};
+/**
+ * Returns the stored state of the instance; it does not query the cloud. Use it to poll creation progress.
+ * @summary Retrieve an instance
+ */
+export const getInstance = async (instanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetInstanceUrl(instanceId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenameInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}`;
+};
+/**
+ * Changes the display name only. The hostname inside the instance is unchanged; it equals the instance id.
+ * @summary Rename an instance
+ */
+export const renameInstance = async (instanceId, renameInstanceRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenameInstanceUrl(instanceId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renameInstanceRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}`;
+};
+/**
+ * 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.
+ *
+ * When subscriptions pay for the instance, or for a disk deleted with it, its `release_subscription_ids`, this request cancels them in Billing, and the response carries that cancellation. Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms, and release begins when Billing begins the cancellation. When any of them can only be canceled at the end of its paid period, all of them are canceled then, and the instance is kept until `scheduled_at`. Deleting again while the cancellation is open returns it. Without subscriptions, release begins at once and `cancellation` is null.
+ * @summary Release an instance
+ */
+export const deleteInstance = async (instanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteInstanceUrl(instanceId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRunInstanceCommandUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/commands`;
+};
+/**
+ * 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 const runInstanceCommand = async (instanceId, runCommandRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRunInstanceCommandUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(runCommandRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getOpenInstanceConsoleUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/console`;
+};
+/**
+ * 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 const openInstanceConsole = async (instanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getOpenInstanceConsoleUrl(instanceId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetInstanceConsoleOutputUrl = (instanceId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/console-output?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/console-output`;
+};
+/**
+ * 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 const getInstanceConsoleOutput = async (instanceId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetInstanceConsoleOutputUrl(instanceId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetInstanceLabelsUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/labels`;
+};
+/**
+ * Records what this instance is for, as key-value pairs. Nothing on the platform reads them.
+ *
+ * **The whole set is replaced**: whatever is absent from the request is removed.
+ *
+ * Do not put credentials here. Labels are visible to platform operators.
+ * @summary Replace an instance's labels
+ */
+export const setInstanceLabels = async (instanceId, setInstanceLabelsRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetInstanceLabelsUrl(instanceId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(setInstanceLabelsRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetInstanceNotesUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/notes`;
+};
+/**
+ * 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 const setInstanceNotes = async (instanceId, setInstanceNotesRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetInstanceNotesUrl(instanceId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(setInstanceNotesRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getResetInstancePasswordUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/password`;
+};
+/**
+ * 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 const resetInstancePassword = async (instanceId, resetPasswordRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getResetInstancePasswordUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(resetPasswordRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRebootInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/reboot`;
+};
+/**
+ * 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 const rebootInstance = async (instanceId, rebootInstanceRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRebootInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(rebootInstanceRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRebuildInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/rebuild`;
+};
+/**
+ * **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 const rebuildInstance = async (instanceId, rebuildInstanceRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRebuildInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(rebuildInstanceRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getResizeInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/resize`;
+};
+/**
+ * Creates a Billing Checkout Session for the change, including for metered pricing, and returns the instance with it. The instance keeps its usage type and period, priced with the target type's matching option; a target type without that option is refused with 409 `BILLING_OPTION_UNAVAILABLE`. Do not submit a new purchase after paying. After an uncertain response, look the Checkout Session up in Billing before submitting again.
+ *
+ * The instance shows the `resize` operation until the resize is applied, its Checkout Session expires or its order is canceled, so other operations and a second resize are refused with `COMPUTE_RESOURCE_BUSY` meanwhile. It keeps its current type until the resize is applied; the new type takes effect, and is billed from then on, when `instance_type_id` shows it. If checkout is not completed, the order is not accepted or the resize fails, the instance keeps its current type and Billing shows the outcome. A completed resize is final and cannot be reverted; to return to the previous type, submit another resize.
+ * @summary Resize an instance
+ */
+export const resizeInstance = async (instanceId, resizeInstanceRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getResizeInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(resizeInstanceRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getStartInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/start`;
+};
+/**
+ * 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 const startInstance = async (instanceId, powerRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getStartInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(powerRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getStopInstanceUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/stop`;
+};
+/**
+ * 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 const stopInstance = async (instanceId, powerRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getStopInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(powerRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInstanceDisksUrl = (instanceId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/disks?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/disks`;
+};
+/**
+ * @summary List the disks attached to an instance
+ */
+export const listInstanceDisks = async (instanceId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInstanceDisksUrl(instanceId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAttachDiskUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/disks`;
+};
+/**
+ * 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 const attachDisk = async (instanceId, attachDiskRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAttachDiskUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(attachDiskRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDetachDiskUrl = (instanceId, diskId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/disks/${encodeURIComponent(String(diskId))}`;
+};
+/**
+ * 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 const detachDisk = async (instanceId, diskId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDetachDiskUrl(instanceId, diskId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAttachInstanceFloatingIpUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/floating-ips`;
+};
+/**
+ * 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 const attachInstanceFloatingIp = async (instanceId, attachFloatingIPRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAttachInstanceFloatingIpUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(attachFloatingIPRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDetachInstanceFloatingIpUrl = (instanceId, floatingIpId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/floating-ips/${encodeURIComponent(String(floatingIpId))}`;
+};
+/**
+ * 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 const detachInstanceFloatingIp = async (instanceId, floatingIpId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDetachInstanceFloatingIpUrl(instanceId, floatingIpId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInstancePortsUrl = (instanceId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/ports?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/ports`;
+};
+/**
+ * @summary List the network interfaces of an instance
+ */
+export const listInstancePorts = async (instanceId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInstancePortsUrl(instanceId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAttachPortUrl = (instanceId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/ports`;
+};
+/**
+ * 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 const attachPort = async (instanceId, attachPortRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAttachPortUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(attachPortRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDetachPortUrl = (instanceId, portId) => {
+    return `https://compute.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/ports/${encodeURIComponent(String(portId))}`;
+};
+/**
+ * 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 const detachPort = async (instanceId, portId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDetachPortUrl(instanceId, portId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListOperationLogsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/operation-logs?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/operation-logs`;
+};
+/**
+ * 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 const listOperationLogs = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListOperationLogsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPortsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/ports?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/ports`;
+};
+/**
+ * @summary List network interfaces
+ */
+export const listPorts = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPortsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePortUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/ports`;
+};
+/**
+ * The new network interface is not attached to any instance. Primary network interfaces are not created here; they are created with the instance.
+ * @summary Create a network interface
+ */
+export const createPort = async (createPortRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePortUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createPortRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeletePortUrl = (portId) => {
+    return `https://compute.leaflow.cloud/api/v1/ports/${encodeURIComponent(String(portId))}`;
+};
+/**
+ * The primary network interface cannot be deleted on its own, as it is released with the instance. A network interface still attached to an instance cannot be deleted either.
+ * @summary Delete a network interface
+ */
+export const deletePort = async (portId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeletePortUrl(portId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPrivateNetworksUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/private-networks?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/private-networks`;
+};
+/**
+ * @summary List private networks
+ */
+export const listPrivateNetworks = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPrivateNetworksUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePrivateNetworkUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks`;
+};
+/**
+ * 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 const createPrivateNetwork = async (createPrivateNetworkRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePrivateNetworkUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createPrivateNetworkRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPrivateNetworkUrl = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}`;
+};
+/**
+ * @summary Retrieve a private network
+ */
+export const getPrivateNetwork = async (privateNetworkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetPrivateNetworkUrl(privateNetworkId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenamePrivateNetworkUrl = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}`;
+};
+/**
+ * Changes the display name only. The CIDR, the routes and the internet gateway are immutable.
+ * @summary Rename a private network
+ */
+export const renamePrivateNetwork = async (privateNetworkId, renamePrivateNetworkRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenamePrivateNetworkUrl(privateNetworkId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renamePrivateNetworkRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeletePrivateNetworkUrl = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}`;
+};
+/**
+ * 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 const deletePrivateNetwork = async (privateNetworkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeletePrivateNetworkUrl(privateNetworkId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPrivateNetworkIpv6Url = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/ipv6`;
+};
+/**
+ * @summary Retrieve the IPv6 configuration of a private network
+ */
+export const getPrivateNetworkIpv6 = async (privateNetworkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetPrivateNetworkIpv6Url(privateNetworkId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getEnablePrivateNetworkIpv6Url = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/ipv6`;
+};
+/**
+ * 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 const enablePrivateNetworkIpv6 = async (privateNetworkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getEnablePrivateNetworkIpv6Url(privateNetworkId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDisablePrivateNetworkIpv6Url = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/ipv6`;
+};
+/**
+ * A released prefix is not re-allocated immediately.
+ * @summary Disable IPv6 on a private network
+ */
+export const disablePrivateNetworkIpv6 = async (privateNetworkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDisablePrivateNetworkIpv6Url(privateNetworkId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListRoutesUrl = (privateNetworkId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/routes?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/routes`;
+};
+/**
+ * @summary List static routes
+ */
+export const listRoutes = async (privateNetworkId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListRoutesUrl(privateNetworkId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateRouteUrl = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/routes`;
+};
+/**
+ * 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 const createRoute = async (privateNetworkId, createRouteRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateRouteUrl(privateNetworkId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createRouteRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteRouteUrl = (privateNetworkId, routeId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/routes/${encodeURIComponent(String(routeId))}`;
+};
+/**
+ * @summary Delete a static route
+ */
+export const deleteRoute = async (privateNetworkId, routeId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteRouteUrl(privateNetworkId, routeId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSubnetsUrl = (privateNetworkId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/subnets?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/subnets`;
+};
+/**
+ * IPv6 subnets are included, with `ip_version` 6. They are created when IPv6 is enabled and cannot be deleted individually.
+ * @summary List subnets
+ */
+export const listSubnets = async (privateNetworkId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSubnetsUrl(privateNetworkId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateSubnetUrl = (privateNetworkId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/subnets`;
+};
+/**
+ * @summary Create a subnet
+ */
+export const createSubnet = async (privateNetworkId, createSubnetRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateSubnetUrl(privateNetworkId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createSubnetRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSuggestSubnetCidrUrl = (privateNetworkId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/subnets/next-free-cidr?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/subnets/next-free-cidr`;
+};
+/**
+ * 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 const suggestSubnetCidr = async (privateNetworkId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getSuggestSubnetCidrUrl(privateNetworkId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteSubnetUrl = (privateNetworkId, subnetId) => {
+    return `https://compute.leaflow.cloud/api/v1/private-networks/${encodeURIComponent(String(privateNetworkId))}/subnets/${encodeURIComponent(String(subnetId))}`;
+};
+/**
+ * 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 const deleteSubnet = async (privateNetworkId, subnetId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSubnetUrl(privateNetworkId, subnetId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSecurityGroupsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/security-groups?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/security-groups`;
+};
+/**
+ * @summary List security groups
+ */
+export const listSecurityGroups = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSecurityGroupsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateSecurityGroupUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/security-groups`;
+};
+/**
+ * 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 const createSecurityGroup = async (createSecurityGroupRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateSecurityGroupUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createSecurityGroupRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSecurityGroupUrl = (securityGroupId) => {
+    return `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}`;
+};
+/**
+ * @summary Retrieve a security group
+ */
+export const getSecurityGroup = async (securityGroupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSecurityGroupUrl(securityGroupId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenameSecurityGroupUrl = (securityGroupId) => {
+    return `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}`;
+};
+/**
+ * Changes the name only. Use the rule endpoints to change rules.
+ * @summary Rename a security group
+ */
+export const renameSecurityGroup = async (securityGroupId, renameSecurityGroupRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenameSecurityGroupUrl(securityGroupId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renameSecurityGroupRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteSecurityGroupUrl = (securityGroupId) => {
+    return `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}`;
+};
+/**
+ * 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 const deleteSecurityGroup = async (securityGroupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSecurityGroupUrl(securityGroupId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSecurityGroupRulesUrl = (securityGroupId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}/rules?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}/rules`;
+};
+/**
+ * @summary List security group rules
+ */
+export const listSecurityGroupRules = async (securityGroupId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSecurityGroupRulesUrl(securityGroupId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateSecurityGroupRuleUrl = (securityGroupId) => {
+    return `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}/rules`;
+};
+/**
+ * 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 const createSecurityGroupRule = async (securityGroupId, createSecurityRuleRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateSecurityGroupRuleUrl(securityGroupId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createSecurityRuleRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteSecurityGroupRuleUrl = (securityGroupId, ruleId) => {
+    return `https://compute.leaflow.cloud/api/v1/security-groups/${encodeURIComponent(String(securityGroupId))}/rules/${encodeURIComponent(String(ruleId))}`;
+};
+/**
+ * @summary Delete a security group rule
+ */
+export const deleteSecurityGroupRule = async (securityGroupId, ruleId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSecurityGroupRuleUrl(securityGroupId, ruleId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSnapshotQuotaUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/snapshot-quota`;
+};
+/**
+ * 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.
+ *
+ * Deleting the quota, which cancels its subscription, is refused while any snapshot exists in the
+ * region 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 const getSnapshotQuota = async (regionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSnapshotQuotaUrl(regionId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetSnapshotQuotaUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/snapshot-quota`;
+};
+/**
+ * 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 how the quota is bought, among the prices Billing offers for the region's
+ * `snapshot_quota_billing`; a change of an existing purchase keeps its usage type and period, and billing
+ * must name them. The purchased quantity is this count.
+ *
+ * Returns the quota with the Checkout Session. 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 Checkout Session. 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 const setSnapshotQuota = async (regionId, setSnapshotQuotaRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetSnapshotQuotaUrl(regionId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(setSnapshotQuotaRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteSnapshotQuotaUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/snapshot-quota`;
+};
+/**
+ * Cancels the quota's subscription in Billing and returns the cancellation. Refused with 409 `SNAPSHOT_QUOTA_IN_USE` while any snapshot exists in the region; delete the snapshots first. Refused with 409 `SNAPSHOT_QUOTA_NOT_ACTIVE` when no subscription pays for a quota in the region.
+ *
+ * Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms. When the subscription can only be canceled at the end of its paid period, it is canceled then, and the quota stays in force until `scheduled_at`. Deleting again while the cancellation is open returns it.
+ * @summary Delete regional snapshot quota
+ */
+export const deleteSnapshotQuota = async (regionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSnapshotQuotaUrl(regionId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetBackupServiceUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-service`;
+};
+/**
+ * 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.
+ *
+ * Deleting the service, which cancels its subscription, is refused while any backup is retained in the region with `BACKUP_SERVICE_IN_USE`. Delete the backups first. Capacity packs are deleted separately, under their own refund terms. Reclaiming the service for non-payment deletes its backups.
+ * @summary Get the backup service of a region
+ */
+export const getBackupService = async (regionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetBackupServiceUrl(regionId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateBackupServiceUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-service`;
+};
+/**
+ * Purchases the backup service for this project and region. The service itself has no charge; backups are metered under it by retained capacity. It takes no billing choice. Returns the service as `pending` with its Checkout Session; 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 const createBackupService = async (regionId, createBackupServiceRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateBackupServiceUrl(regionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createBackupServiceRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteBackupServiceUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-service`;
+};
+/**
+ * Cancels the service's subscription in Billing and returns the cancellation. Refused with 409 `BACKUP_SERVICE_IN_USE` while any backup is retained in the region; delete the backups first. Capacity packs are deleted separately. Refused with 409 `BACKUP_SERVICE_NOT_ACTIVE` when no subscription pays for a service in the region.
+ *
+ * Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms. When the subscription can only be canceled at the end of its paid period, it is canceled then, and the service stays in force until `scheduled_at`. Deleting again while the cancellation is open returns it.
+ * @summary Delete the backup service of a region
+ */
+export const deleteBackupService = async (regionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBackupServiceUrl(regionId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListBackupCapacityPacksUrl = (regionId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-capacity-packs?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-capacity-packs`;
+};
+/**
+ * The capacity packs of the authenticated project in this region, newest first, including ended ones.
+ * @summary List backup capacity packs
+ */
+export const listBackupCapacityPacks = async (regionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListBackupCapacityPacksUrl(regionId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateBackupCapacityPackUrl = (regionId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-capacity-packs`;
+};
+/**
+ * Purchases a capacity pack, backup capacity for this project and region bought in advance by month or year: `billing` must be licensed with a period, as Billing offers for the region's `capacity_pack_billing`. 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 Checkout Session; 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 const createBackupCapacityPack = async (regionId, createBackupCapacityPackRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateBackupCapacityPackUrl(regionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createBackupCapacityPackRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteBackupCapacityPackUrl = (regionId, packId) => {
+    return `https://compute.leaflow.cloud/api/v1/regions/${encodeURIComponent(String(regionId))}/backup-capacity-packs/${encodeURIComponent(String(packId))}`;
+};
+/**
+ * Cancels the pack's subscription in Billing and returns the cancellation. Refused with 404 `BACKUP_CAPACITY_PACK_NOT_FOUND` when the project has no pack of this ID in the region, and with 409 `BACKUP_CAPACITY_PACK_ENDED` when the pack has ended.
+ *
+ * Pay-as-you-go subscriptions, and prepaid ones whose terms allow it, are canceled at once and refunded under those terms. When the subscription can only be canceled at the end of its paid period, it is canceled then, and its coverage stays in force until `scheduled_at`. Deleting again while the cancellation is open returns it.
+ * @summary Delete a backup capacity pack
+ */
+export const deleteBackupCapacityPack = async (regionId, packId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBackupCapacityPackUrl(regionId, packId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSnapshotsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/snapshots?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/snapshots`;
+};
+/**
+ * @summary List snapshots
+ */
+export const listSnapshots = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSnapshotsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateSnapshotUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/snapshots`;
+};
+/**
+ * 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 const createSnapshot = async (createSnapshotRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateSnapshotUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createSnapshotRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSnapshotUrl = (snapshotId) => {
+    return `https://compute.leaflow.cloud/api/v1/snapshots/${encodeURIComponent(String(snapshotId))}`;
+};
+/**
+ * @summary Retrieve a snapshot
+ */
+export const getSnapshot = async (snapshotId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSnapshotUrl(snapshotId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenameSnapshotUrl = (snapshotId) => {
+    return `https://compute.leaflow.cloud/api/v1/snapshots/${encodeURIComponent(String(snapshotId))}`;
+};
+/**
+ * @summary Rename a snapshot
+ */
+export const renameSnapshot = async (snapshotId, renameSnapshotRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenameSnapshotUrl(snapshotId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renameSnapshotRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteSnapshotUrl = (snapshotId) => {
+    return `https://compute.leaflow.cloud/api/v1/snapshots/${encodeURIComponent(String(snapshotId))}`;
+};
+/**
+ * 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 const deleteSnapshot = async (snapshotId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSnapshotUrl(snapshotId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListIpv4PoolsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/ipv4-pools?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/ipv4-pools`;
+};
+/**
+ * Lists the public IP pools available for new allocations in this region.
+ * @summary List public IP pools
+ */
+export const listIpv4Pools = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListIpv4PoolsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPeeringsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://compute.leaflow.cloud/api/v1/peerings?${stringifiedParams}`
+        : `https://compute.leaflow.cloud/api/v1/peerings`;
+};
+/**
+ * @summary List peerings
+ */
+export const listPeerings = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPeeringsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePeeringUrl = () => {
+    return `https://compute.leaflow.cloud/api/v1/peerings`;
+};
+/**
+ * Request IPv4 peering between non-overlapping VPCs in the same Region. The target project must accept before any connectivity is created. Does not change security groups or provide transitive routing.
+ * @summary Create peering
+ */
+export const createPeering = async (createPeeringRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePeeringUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createPeeringRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPeeringUrl = (peeringId) => {
+    return `https://compute.leaflow.cloud/api/v1/peerings/${encodeURIComponent(String(peeringId))}`;
+};
+/**
+ * @summary Get peering
+ */
+export const getPeering = async (peeringId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetPeeringUrl(peeringId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeletePeeringUrl = (peeringId) => {
+    return `https://compute.leaflow.cloud/api/v1/peerings/${encodeURIComponent(String(peeringId))}`;
+};
+/**
+ * @summary Delete peering
+ */
+export const deletePeering = async (peeringId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeletePeeringUrl(peeringId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAcceptPeeringUrl = (peeringId) => {
+    return `https://compute.leaflow.cloud/api/v1/peerings/${encodeURIComponent(String(peeringId))}/accept`;
+};
+/**
+ * @summary Accept peering
+ */
+export const acceptPeering = async (peeringId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getAcceptPeeringUrl(peeringId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRejectPeeringUrl = (peeringId) => {
+    return `https://compute.leaflow.cloud/api/v1/peerings/${encodeURIComponent(String(peeringId))}/reject`;
+};
+/**
+ * @summary Reject peering
+ */
+export const rejectPeering = async (peeringId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getRejectPeeringUrl(peeringId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};