@leaflow/sdk 0.161.0 → 0.162.0

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

@@ -327,8 +327,17 @@ export const renameImage = async (imageId, renameImageRequestBody, options, fetc
     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))}`;
+export const getDeleteImageUrl = (imageId, 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/${encodeURIComponent(String(imageId))}?${stringifiedParams}`
+        : `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.
@@ -337,11 +346,11 @@ export const getDeleteImageUrl = (imageId) => {
  *
  * 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.
+ * When subscriptions pay for the image, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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), {
+export const deleteImage = async (imageId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteImageUrl(imageId, params), {
         ...options,
         method: "DELETE",
     });
@@ -532,17 +541,26 @@ export const renameDisk = async (diskId, renameDiskRequestBody, options, fetchFn
     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))}`;
+export const getDeleteDiskUrl = (diskId, 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/${encodeURIComponent(String(diskId))}?${stringifiedParams}`
+        : `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.
+ * When subscriptions pay for the disk, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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), {
+export const deleteDisk = async (diskId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteDiskUrl(diskId, params), {
         ...options,
         method: "DELETE",
     });
@@ -704,17 +722,26 @@ export const getFloatingIp = async (floatingIpId, options, fetchFn) => {
     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))}`;
+export const getReleaseFloatingIpUrl = (floatingIpId, 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/${encodeURIComponent(String(floatingIpId))}?${stringifiedParams}`
+        : `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.
+ * When subscriptions pay for the address, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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), {
+export const releaseFloatingIp = async (floatingIpId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getReleaseFloatingIpUrl(floatingIpId, params), {
         ...options,
         method: "DELETE",
     });
@@ -921,19 +948,28 @@ export const renameInstance = async (instanceId, renameInstanceRequestBody, opti
     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))}`;
+export const getDeleteInstanceUrl = (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))}?${stringifiedParams}`
+        : `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.
+ * When subscriptions pay for the instance, or for a disk deleted with it, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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), {
+export const deleteInstance = async (instanceId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteInstanceUrl(instanceId, params), {
         ...options,
         method: "DELETE",
     });
@@ -2236,17 +2272,26 @@ export const setSnapshotQuota = async (regionId, setSnapshotQuotaRequestBody, op
     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`;
+export const getDeleteSnapshotQuotaUrl = (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))}/snapshot-quota?${stringifiedParams}`
+        : `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.
+ * Cancels the quota's subscription in Billing as `cancellation_mode` says 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.
+ * Canceled now, it is refunded under its terms; canceled at the end of its paid period, 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), {
+export const deleteSnapshotQuota = async (regionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSnapshotQuotaUrl(regionId, params), {
         ...options,
         method: "DELETE",
     });
@@ -2307,17 +2352,26 @@ export const createBackupService = async (regionId, createBackupServiceRequestBo
     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`;
+export const getDeleteBackupServiceUrl = (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-service?${stringifiedParams}`
+        : `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.
+ * Cancels the service's subscription in Billing as `cancellation_mode` says 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.
+ * Canceled now, it is refunded under its terms; canceled at the end of its paid period, 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), {
+export const deleteBackupService = async (regionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBackupServiceUrl(regionId, params), {
         ...options,
         method: "DELETE",
     });
@@ -2385,17 +2439,26 @@ export const createBackupCapacityPack = async (regionId, createBackupCapacityPac
     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))}`;
+export const getDeleteBackupCapacityPackUrl = (regionId, packId, 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/${encodeURIComponent(String(packId))}?${stringifiedParams}`
+        : `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.
+ * Cancels the pack's subscription in Billing as `cancellation_mode` says 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.
+ * Canceled now, it is refunded under its terms; canceled at the end of its paid period, 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), {
+export const deleteBackupCapacityPack = async (regionId, packId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBackupCapacityPackUrl(regionId, packId, params), {
         ...options,
         method: "DELETE",
     });

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

@@ -144,14 +144,6 @@ export interface BillingComponent {
     /** What the line's metered price reads. Empty when the line is never metered or its usage is not estimated in advance. */
     meters: BillingMeter[];
 }
-/**
- * `immediate` releases the resource now and refunds under the subscriptions' terms; `period_end` keeps it until `scheduled_at`.
- */
-export type ResourceCancellationMode = (typeof ResourceCancellationMode)[keyof typeof ResourceCancellationMode];
-export declare const ResourceCancellationMode: {
-    readonly immediate: "immediate";
-    readonly period_end: "period_end";
-};
 /**
  * `requested` and `scheduled` have not begun release; `releasing` is releasing the resource.
  */
@@ -161,13 +153,25 @@ export declare const ResourceCancellationStatus: {
     readonly scheduled: "scheduled";
     readonly releasing: "releasing";
 };
+/**
+ * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+ * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+ * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+ * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+ * BILLING_CANCELLATION_MODE_FIXED.
+ */
+export type CancellationMode = (typeof CancellationMode)[keyof typeof CancellationMode];
+export declare const CancellationMode: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
 /**
  * The Billing cancellation of the subscriptions that pay for a resource. Read it in Billing with `get-cancellation` for its refund and progress.
  */
 export interface ResourceCancellation {
     id: string;
-    /** `immediate` releases the resource now and refunds under the subscriptions' terms; `period_end` keeps it until `scheduled_at`. */
-    mode: ResourceCancellationMode;
+    /** `immediate` releases the resource now; `period_end` keeps it until `scheduled_at`. */
+    mode: CancellationMode;
     /** `requested` and `scheduled` have not begun release; `releasing` is releasing the resource. */
     status: ResourceCancellationStatus;
     /**
@@ -2366,6 +2370,7 @@ export interface CursorPagination {
  * apply.
  */
 export type ConflictResponse = Error;
+export type CancellationModeParameter = CancellationMode;
 export type ListBackupsParams = {
     /**
      * Return only the backups of this disk
@@ -2425,6 +2430,16 @@ export type ListImagesParams = {
      */
     page_size?: number;
 };
+export type DeleteImageParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
 export type ListInstanceTypesParams = {
     region_id?: string;
     /**
@@ -2487,6 +2502,16 @@ export type ListDisksParams = {
      */
     page_size?: number;
 };
+export type DeleteDiskParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
 export type ListFloatingIpsParams = {
     /**
      * 1-based page number. Defaults to 1.
@@ -2501,6 +2526,16 @@ export type ListFloatingIpsParams = {
      */
     page_size?: number;
 };
+export type ReleaseFloatingIpParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
 export type ListInstancesParams = {
     /**
      * A label to filter by, written as `key:value`
@@ -2520,6 +2555,16 @@ export type ListInstancesParams = {
      */
     page_size?: number;
 };
+export type DeleteInstanceParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
 export type GetInstanceConsoleOutputParams = {
     /**
      * Number of trailing lines to return; 0 returns the entire output
@@ -2675,6 +2720,26 @@ export type ListSecurityGroupRulesParams = {
      */
     page_size?: number;
 };
+export type DeleteSnapshotQuotaParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
+export type DeleteBackupServiceParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
 export type ListBackupCapacityPacksParams = {
     /**
      * 1-based page number. Defaults to 1.
@@ -2689,6 +2754,16 @@ export type ListBackupCapacityPacksParams = {
      */
     page_size?: number;
 };
+export type DeleteBackupCapacityPackParams = {
+    /**
+     * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+     * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+     * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+     * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+     * BILLING_CANCELLATION_MODE_FIXED.
+     */
+    cancellation_mode?: CancellationModeParameter;
+};
 export type ListSnapshotsParams = {
     /**
      * Return only the snapshots of this disk

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

@@ -22,15 +22,15 @@ export const BillingMeterQuantity = {
     bandwidth_mbps: "bandwidth_mbps",
     stored_gib: "stored_gib",
 };
-export const ResourceCancellationMode = {
-    immediate: "immediate",
-    period_end: "period_end",
-};
 export const ResourceCancellationStatus = {
     requested: "requested",
     scheduled: "scheduled",
     releasing: "releasing",
 };
+export const CancellationMode = {
+    immediate: "immediate",
+    period_end: "period_end",
+};
 export const InstanceResourceStatus = {
     pending: "pending",
     provisioning: "provisioning",

package/dist/compute/v1/generated/schemas.zod.d.ts

@@ -227,12 +227,18 @@ export declare const RenameImageBody: zod.ZodObject<{
  *
  * 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.
+ * When subscriptions pay for the image, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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 declare const DeleteImageParams: zod.ZodObject<{
     imageId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DeleteImageQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * 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
@@ -343,12 +349,18 @@ export declare const RenameDiskBody: zod.ZodObject<{
 /**
  * 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.
+ * When subscriptions pay for the disk, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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 declare const DeleteDiskParams: zod.ZodObject<{
     diskId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DeleteDiskQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * 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.
  *
@@ -449,12 +461,18 @@ export declare const GetFloatingIpParams: zod.ZodObject<{
 /**
  * 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.
+ * When subscriptions pay for the address, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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 declare const ReleaseFloatingIpParams: zod.ZodObject<{
     floatingIpId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const ReleaseFloatingIpQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * 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.
  *
@@ -632,12 +650,18 @@ export declare const RenameInstanceBody: zod.ZodObject<{
  *
  * 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.
+ * When subscriptions pay for the instance, or for a disk deleted with it, its `release_subscription_ids`, this request cancels them in Billing as `cancellation_mode` says, and the response carries that cancellation. Canceled now, they are refunded under their terms and release begins when Billing begins the cancellation; canceled at the end of their paid period, 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 declare const DeleteInstanceParams: zod.ZodObject<{
     instanceId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DeleteInstanceQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * 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.
  *
@@ -1244,14 +1268,20 @@ export declare const SetSnapshotQuotaBody: zod.ZodObject<{
     proration_date: zod.ZodOptional<zod.z.ZodISODateTime>;
 }, zod.z.core.$strict>;
 /**
- * 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.
+ * Cancels the quota's subscription in Billing as `cancellation_mode` says 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.
+ * Canceled now, it is refunded under its terms; canceled at the end of its paid period, the quota stays in force until `scheduled_at`. Deleting again while the cancellation is open returns it.
  * @summary Delete regional snapshot quota
  */
 export declare const DeleteSnapshotQuotaParams: zod.ZodObject<{
     regionId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DeleteSnapshotQuotaQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * 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.
  *
@@ -1281,14 +1311,20 @@ export declare const CreateBackupServiceBody: zod.ZodObject<{
     }, zod.z.core.$strict>>;
 }, zod.z.core.$strict>;
 /**
- * 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.
+ * Cancels the service's subscription in Billing as `cancellation_mode` says 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.
+ * Canceled now, it is refunded under its terms; canceled at the end of its paid period, 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 declare const DeleteBackupServiceParams: zod.ZodObject<{
     regionId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DeleteBackupServiceQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * The capacity packs of the authenticated project in this region, newest first, including ended ones.
  * @summary List backup capacity packs
@@ -1342,15 +1378,21 @@ export declare const CreateBackupCapacityPackBody: zod.ZodObject<{
     }, zod.z.core.$strict>>;
 }, zod.z.core.$strict>;
 /**
- * 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.
+ * Cancels the pack's subscription in Billing as `cancellation_mode` says 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.
+ * Canceled now, it is refunded under its terms; canceled at the end of its paid period, its coverage stays in force until `scheduled_at`. Deleting again while the cancellation is open returns it.
  * @summary Delete a backup capacity pack
  */
 export declare const DeleteBackupCapacityPackParams: zod.ZodObject<{
     regionId: zod.ZodUUID;
     packId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DeleteBackupCapacityPackQueryParams: zod.ZodObject<{
+    cancellation_mode: zod.ZodOptional<zod.ZodEnum<{
+        immediate: "immediate";
+        period_end: "period_end";
+    }>>;
+}, zod.z.core.$strict>;
 /**
  * @summary List snapshots
  */