@scaleway/sdk 2.28.0 → 2.30.0

package/dist/api/baremetal/v1/marshalling.gen.cjs

@@ -143,6 +143,7 @@ const unmarshalOffer = (data) => {
     fee: data.fee ? customMarshalling.unmarshalMoney(data.fee) : void 0,
     id: data.id,
     incompatibleOsIds: data.incompatible_os_ids,
+    maxBandwidth: data.max_bandwidth,
     memories: marshalling.unmarshalArrayOfObject(data.memories, unmarshalMemory),
     name: data.name,
     operationPath: data.operation_path,

package/dist/api/baremetal/v1/marshalling.gen.js

@@ -141,6 +141,7 @@ const unmarshalOffer = (data) => {
     fee: data.fee ? unmarshalMoney(data.fee) : void 0,
     id: data.id,
     incompatibleOsIds: data.incompatible_os_ids,
+    maxBandwidth: data.max_bandwidth,
     memories: unmarshalArrayOfObject(data.memories, unmarshalMemory),
     name: data.name,
     operationPath: data.operation_path,

package/dist/api/baremetal/v1/types.gen.d.ts

@@ -183,6 +183,11 @@ export interface Offer {
     stock: OfferStock;
     /** Public bandwidth available (in bits/s) with the offer. */
     bandwidth: number;
+    /**
+     * Maximum public bandwidth available (in bits/s) depending on available
+     * options.
+     */
+    maxBandwidth: number;
     /** Commercial range of the offer. */
     commercialRange: string;
     /**

package/dist/api/index.d.ts

@@ -17,6 +17,7 @@ export * as IPAM from './ipam';
 export * as IPFS from './ipfs';
 export * as Jobs from './jobs';
 export * as K8S from './k8s';
+export * as KeyManager from './key_manager';
 export * as LB from './lb';
 export * as LLMInference from './llm_inference';
 export * as Marketplace from './marketplace';

package/dist/api/ipam/v1/api.gen.cjs

@@ -40,6 +40,14 @@ class API extends api.API {
     method: "DELETE",
     path: `/ipam/v1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/ips/${marshalling.validatePathParam("ipId", request.ipId)}`
   });
+  releaseIPSet = (request = {}) => this.client.fetch({
+    body: JSON.stringify(
+      marshalling_gen.marshalReleaseIPSetRequest(request, this.client.settings)
+    ),
+    headers: jsonContentHeaders,
+    method: "POST",
+    path: `/ipam/v1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/ip-sets/release`
+  });
   /**
    * Get an IP. Retrieve details of an existing IP, specified by its IP ID.
    *

package/dist/api/ipam/v1/api.gen.d.ts

@@ -1,6 +1,6 @@
 import { API as ParentAPI } from '../../../bridge';
 import type { Region } from '../../../bridge';
-import type { BookIPRequest, GetIPRequest, IP, ListIPsRequest, ListIPsResponse, ReleaseIPRequest, UpdateIPRequest } from './types.gen';
+import type { BookIPRequest, GetIPRequest, IP, ListIPsRequest, ListIPsResponse, ReleaseIPRequest, ReleaseIPSetRequest, UpdateIPRequest } from './types.gen';
 /**
  * IPAM API.
  *
@@ -25,6 +25,7 @@ export declare class API extends ParentAPI {
      * @param request - The request {@link ReleaseIPRequest}
      */
     releaseIP: (request: Readonly<ReleaseIPRequest>) => Promise<void>;
+    releaseIPSet: (request?: Readonly<ReleaseIPSetRequest>) => Promise<void>;
     /**
      * Get an IP. Retrieve details of an existing IP, specified by its IP ID.
      *

package/dist/api/ipam/v1/api.gen.js

@@ -1,7 +1,7 @@
 import { API as API$1 } from "../../../scw/api.js";
 import { validatePathParam, urlParams, resolveOneOf } from "../../../helpers/marshalling.js";
 import { enrichForPagination } from "../../../scw/fetch/resource-paginator.js";
-import { marshalBookIPRequest, unmarshalIP, marshalUpdateIPRequest, unmarshalListIPsResponse } from "./marshalling.gen.js";
+import { marshalBookIPRequest, unmarshalIP, marshalReleaseIPSetRequest, marshalUpdateIPRequest, unmarshalListIPsResponse } from "./marshalling.gen.js";
 const jsonContentHeaders = {
   "Content-Type": "application/json; charset=utf-8"
 };
@@ -38,6 +38,14 @@ class API extends API$1 {
     method: "DELETE",
     path: `/ipam/v1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/ips/${validatePathParam("ipId", request.ipId)}`
   });
+  releaseIPSet = (request = {}) => this.client.fetch({
+    body: JSON.stringify(
+      marshalReleaseIPSetRequest(request, this.client.settings)
+    ),
+    headers: jsonContentHeaders,
+    method: "POST",
+    path: `/ipam/v1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/ip-sets/release`
+  });
   /**
    * Get an IP. Retrieve details of an existing IP, specified by its IP ID.
    *

package/dist/api/ipam/v1/index.gen.d.ts

@@ -1,3 +1,3 @@
 export { API } from './api.gen';
-export type { BookIPRequest, GetIPRequest, IP, ListIPsRequest, ListIPsRequestOrderBy, ListIPsResponse, ReleaseIPRequest, Resource, ResourceType, Reverse, Source, UpdateIPRequest, } from './types.gen';
+export type { BookIPRequest, GetIPRequest, IP, ListIPsRequest, ListIPsRequestOrderBy, ListIPsResponse, ReleaseIPRequest, ReleaseIPSetRequest, Resource, ResourceType, Reverse, Source, UpdateIPRequest, } from './types.gen';
 export * as ValidationRules from './validation-rules.gen';

package/dist/api/ipam/v1/marshalling.gen.cjs

@@ -84,6 +84,9 @@ const marshalBookIPRequest = (request, defaults) => ({
   source: marshalSource(request.source),
   tags: request.tags
 });
+const marshalReleaseIPSetRequest = (request, defaults) => ({
+  ip_ids: request.ipIds
+});
 const marshalReverse = (request, defaults) => ({
   address: request.address,
   hostname: request.hostname
@@ -93,6 +96,7 @@ const marshalUpdateIPRequest = (request, defaults) => ({
   tags: request.tags
 });
 exports.marshalBookIPRequest = marshalBookIPRequest;
+exports.marshalReleaseIPSetRequest = marshalReleaseIPSetRequest;
 exports.marshalUpdateIPRequest = marshalUpdateIPRequest;
 exports.unmarshalIP = unmarshalIP;
 exports.unmarshalListIPsResponse = unmarshalListIPsResponse;

package/dist/api/ipam/v1/marshalling.gen.d.ts

@@ -1,6 +1,7 @@
 import type { DefaultValues } from '../../../bridge';
-import type { BookIPRequest, IP, ListIPsResponse, UpdateIPRequest } from './types.gen';
+import type { BookIPRequest, IP, ListIPsResponse, ReleaseIPSetRequest, UpdateIPRequest } from './types.gen';
 export declare const unmarshalIP: (data: unknown) => IP;
 export declare const unmarshalListIPsResponse: (data: unknown) => ListIPsResponse;
 export declare const marshalBookIPRequest: (request: BookIPRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalReleaseIPSetRequest: (request: ReleaseIPSetRequest, defaults: DefaultValues) => Record<string, unknown>;
 export declare const marshalUpdateIPRequest: (request: UpdateIPRequest, defaults: DefaultValues) => Record<string, unknown>;

package/dist/api/ipam/v1/marshalling.gen.js

@@ -82,6 +82,9 @@ const marshalBookIPRequest = (request, defaults) => ({
   source: marshalSource(request.source),
   tags: request.tags
 });
+const marshalReleaseIPSetRequest = (request, defaults) => ({
+  ip_ids: request.ipIds
+});
 const marshalReverse = (request, defaults) => ({
   address: request.address,
   hostname: request.hostname
@@ -92,6 +95,7 @@ const marshalUpdateIPRequest = (request, defaults) => ({
 });
 export {
   marshalBookIPRequest,
+  marshalReleaseIPSetRequest,
   marshalUpdateIPRequest,
   unmarshalIP,
   unmarshalListIPsResponse

package/dist/api/ipam/v1/types.gen.d.ts

@@ -191,6 +191,14 @@ export type ReleaseIPRequest = {
     /** IP ID. */
     ipId: string;
 };
+export type ReleaseIPSetRequest = {
+    /**
+     * Region to target. If none is passed will use default region from the
+     * config.
+     */
+    region?: Region;
+    ipIds?: string[];
+};
 export type UpdateIPRequest = {
     /**
      * Region to target. If none is passed will use default region from the

package/dist/api/key_manager/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_gen = require("./v1alpha1/index.gen.cjs");
+exports.v1alpha1 = index_gen;

package/dist/api/key_manager/index.d.ts

@@ -0,0 +1 @@
+export * as v1alpha1 from './v1alpha1/index.gen';

package/dist/api/key_manager/index.js

@@ -0,0 +1,4 @@
+import * as index_gen from "./v1alpha1/index.gen.js";
+export {
+  index_gen as v1alpha1
+};

package/dist/api/key_manager/v1alpha1/api.gen.cjs

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const api = require("../../../scw/api.cjs");
+const marshalling = require("../../../helpers/marshalling.cjs");
+const resourcePaginator = require("../../../scw/fetch/resource-paginator.cjs");
+const marshalling_gen = require("./marshalling.gen.cjs");
+const jsonContentHeaders = {
+  "Content-Type": "application/json; charset=utf-8"
+};
+class API extends api.API {
+  /** Lists the available regions of the API. */
+  static LOCALITIES = ["fr-par", "nl-ams", "pl-waw"];
+  /**
+   * Create a key. Create a key in a given region specified by the `region`
+   * parameter. Keys only support symmetric encryption. You can use keys to
+   * encrypt or decrypt arbitrary payloads, or to generate data encryption keys
+   * that can be used without being stored in Key Manager.
+   *
+   * @param request - The request {@link CreateKeyRequest}
+   * @returns A Promise of Key
+   */
+  createKey = (request) => this.client.fetch(
+    {
+      body: JSON.stringify(
+        marshalling_gen.marshalCreateKeyRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Get key metadata. Retrieve the metadata of a key specified by the `region`
+   * and `key_id` parameters.
+   *
+   * @param request - The request {@link GetKeyRequest}
+   * @returns A Promise of Key
+   */
+  getKey = (request) => this.client.fetch(
+    {
+      method: "GET",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Update a key. Update a key's metadata (name, description and tags),
+   * specified by the `key_id` and `region` parameters.
+   *
+   * @param request - The request {@link UpdateKeyRequest}
+   * @returns A Promise of Key
+   */
+  updateKey = (request) => this.client.fetch(
+    {
+      body: JSON.stringify(
+        marshalling_gen.marshalUpdateKeyRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "PATCH",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Delete a key. Delete an existing key specified by the `region` and `key_id`
+   * parameters. Deleting a key is permanent and cannot be undone. All data
+   * encrypted using this key, including data encryption keys, will become
+   * unusable.
+   *
+   * @param request - The request {@link DeleteKeyRequest}
+   */
+  deleteKey = (request) => this.client.fetch({
+    method: "DELETE",
+    path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}`
+  });
+  /**
+   * Rotate a key. Generate a new version of an existing key with randomly
+   * generated key material. Rotated keys can still be used to decrypt
+   * previously encrypted data. The key's new material will be used for
+   * subsequent encryption operations and data key generation.
+   *
+   * @param request - The request {@link RotateKeyRequest}
+   * @returns A Promise of Key
+   */
+  rotateKey = (request) => this.client.fetch(
+    {
+      body: "{}",
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/rotate`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Apply key protection. Apply key protection to a given key specified by the
+   * `key_id` parameter. Applying key protection means that your key can be used
+   * and modified, but it cannot be deleted.
+   *
+   * @param request - The request {@link ProtectKeyRequest}
+   * @returns A Promise of Key
+   */
+  protectKey = (request) => this.client.fetch(
+    {
+      body: "{}",
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/protect`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Remove key protection. Remove key protection from a given key specified by
+   * the `key_id` parameter. Removing key protection means that your key can be
+   * deleted anytime.
+   *
+   * @param request - The request {@link UnprotectKeyRequest}
+   * @returns A Promise of Key
+   */
+  unprotectKey = (request) => this.client.fetch(
+    {
+      body: "{}",
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/unprotect`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Enable key. Enable a given key to be used for cryptographic operations.
+   * Enabling a key allows you to make a disabled key usable again. You must
+   * specify the `region` and `key_id` parameters.
+   *
+   * @param request - The request {@link EnableKeyRequest}
+   * @returns A Promise of Key
+   */
+  enableKey = (request) => this.client.fetch(
+    {
+      body: "{}",
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/enable`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  /**
+   * Disable key. Disable a given key to be used for cryptographic operations.
+   * Disabling a key renders it unusable. You must specify the `region` and
+   * `key_id` parameters.
+   *
+   * @param request - The request {@link DisableKeyRequest}
+   * @returns A Promise of Key
+   */
+  disableKey = (request) => this.client.fetch(
+    {
+      body: "{}",
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/disable`
+    },
+    marshalling_gen.unmarshalKey
+  );
+  pageOfListKeys = (request = {}) => this.client.fetch(
+    {
+      method: "GET",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys`,
+      urlParams: marshalling.urlParams(
+        ["name", request.name],
+        ["order_by", request.orderBy],
+        ["organization_id", request.organizationId],
+        ["page", request.page],
+        [
+          "page_size",
+          request.pageSize ?? this.client.settings.defaultPageSize
+        ],
+        ["project_id", request.projectId],
+        ["tags", request.tags]
+      )
+    },
+    marshalling_gen.unmarshalListKeysResponse
+  );
+  /**
+   * List keys. Retrieve the list of keys created within all Projects of an
+   * Organization or in a given Project. You must specify the `region`, and
+   * either the `organization_id` or the `project_id`.
+   *
+   * @param request - The request {@link ListKeysRequest}
+   * @returns A Promise of ListKeysResponse
+   */
+  listKeys = (request = {}) => resourcePaginator.enrichForPagination("keys", this.pageOfListKeys, request);
+  /**
+   * Generate a data encryption key. Generate a new data encryption key to use
+   * for cryptographic operations outside of Key Manager. Note that Key Manager
+   * does not store your data encryption key. The data encryption key is
+   * encrypted and must be decrypted using the key you have created in Key
+   * Manager. The data encryption key's plaintext is returned in the response
+   * object, for immediate usage.
+   *
+   * Always store the data encryption key's ciphertext, rather than its
+   * plaintext, which must not be stored. To retrieve your key's plaintext, call
+   * the Decrypt endpoint with your key's ID and ciphertext.
+   *
+   * @param request - The request {@link GenerateDataKeyRequest}
+   * @returns A Promise of DataKey
+   */
+  generateDataKey = (request) => this.client.fetch(
+    {
+      body: JSON.stringify(
+        marshalling_gen.marshalGenerateDataKeyRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/generate-data-key`
+    },
+    marshalling_gen.unmarshalDataKey
+  );
+  /**
+   * Encrypt data. Encrypt data using an existing key, specified by the `key_id`
+   * parameter. Only keys with a usage set to **symmetric_encryption** are
+   * supported by this method. The maximum payload size that can be encrypted is
+   * 64KB of plaintext.
+   *
+   * @param request - The request {@link EncryptRequest}
+   * @returns A Promise of EncryptResponse
+   */
+  encrypt = (request) => this.client.fetch(
+    {
+      body: JSON.stringify(
+        marshalling_gen.marshalEncryptRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/encrypt`
+    },
+    marshalling_gen.unmarshalEncryptResponse
+  );
+  /**
+   * Decrypt data. Decrypt data using an existing key, specified by the `key_id`
+   * parameter. The maximum payload size that can be decrypted is the result of
+   * the encryption of 64KB of data (around 131KB).
+   *
+   * @param request - The request {@link DecryptRequest}
+   * @returns A Promise of DecryptResponse
+   */
+  decrypt = (request) => this.client.fetch(
+    {
+      body: JSON.stringify(
+        marshalling_gen.marshalDecryptRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${marshalling.validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${marshalling.validatePathParam("keyId", request.keyId)}/decrypt`
+    },
+    marshalling_gen.unmarshalDecryptResponse
+  );
+}
+exports.API = API;

package/dist/api/key_manager/v1alpha1/api.gen.d.ts

@@ -0,0 +1,142 @@
+import { API as ParentAPI } from '../../../bridge';
+import type { Region } from '../../../bridge';
+import type { CreateKeyRequest, DataKey, DecryptRequest, DecryptResponse, DeleteKeyRequest, DisableKeyRequest, EnableKeyRequest, EncryptRequest, EncryptResponse, GenerateDataKeyRequest, GetKeyRequest, Key, ListKeysRequest, ListKeysResponse, ProtectKeyRequest, RotateKeyRequest, UnprotectKeyRequest, UpdateKeyRequest } from './types.gen';
+/**
+ * Key Manager API.
+ *
+ * This API allows you to create, manage and use cryptographic keys in a
+ * centralized and secure service.
+ */
+export declare class API extends ParentAPI {
+    /** Lists the available regions of the API. */
+    static readonly LOCALITIES: Region[];
+    /**
+     * Create a key. Create a key in a given region specified by the `region`
+     * parameter. Keys only support symmetric encryption. You can use keys to
+     * encrypt or decrypt arbitrary payloads, or to generate data encryption keys
+     * that can be used without being stored in Key Manager.
+     *
+     * @param request - The request {@link CreateKeyRequest}
+     * @returns A Promise of Key
+     */
+    createKey: (request: Readonly<CreateKeyRequest>) => Promise<Key>;
+    /**
+     * Get key metadata. Retrieve the metadata of a key specified by the `region`
+     * and `key_id` parameters.
+     *
+     * @param request - The request {@link GetKeyRequest}
+     * @returns A Promise of Key
+     */
+    getKey: (request: Readonly<GetKeyRequest>) => Promise<Key>;
+    /**
+     * Update a key. Update a key's metadata (name, description and tags),
+     * specified by the `key_id` and `region` parameters.
+     *
+     * @param request - The request {@link UpdateKeyRequest}
+     * @returns A Promise of Key
+     */
+    updateKey: (request: Readonly<UpdateKeyRequest>) => Promise<Key>;
+    /**
+     * Delete a key. Delete an existing key specified by the `region` and `key_id`
+     * parameters. Deleting a key is permanent and cannot be undone. All data
+     * encrypted using this key, including data encryption keys, will become
+     * unusable.
+     *
+     * @param request - The request {@link DeleteKeyRequest}
+     */
+    deleteKey: (request: Readonly<DeleteKeyRequest>) => Promise<void>;
+    /**
+     * Rotate a key. Generate a new version of an existing key with randomly
+     * generated key material. Rotated keys can still be used to decrypt
+     * previously encrypted data. The key's new material will be used for
+     * subsequent encryption operations and data key generation.
+     *
+     * @param request - The request {@link RotateKeyRequest}
+     * @returns A Promise of Key
+     */
+    rotateKey: (request: Readonly<RotateKeyRequest>) => Promise<Key>;
+    /**
+     * Apply key protection. Apply key protection to a given key specified by the
+     * `key_id` parameter. Applying key protection means that your key can be used
+     * and modified, but it cannot be deleted.
+     *
+     * @param request - The request {@link ProtectKeyRequest}
+     * @returns A Promise of Key
+     */
+    protectKey: (request: Readonly<ProtectKeyRequest>) => Promise<Key>;
+    /**
+     * Remove key protection. Remove key protection from a given key specified by
+     * the `key_id` parameter. Removing key protection means that your key can be
+     * deleted anytime.
+     *
+     * @param request - The request {@link UnprotectKeyRequest}
+     * @returns A Promise of Key
+     */
+    unprotectKey: (request: Readonly<UnprotectKeyRequest>) => Promise<Key>;
+    /**
+     * Enable key. Enable a given key to be used for cryptographic operations.
+     * Enabling a key allows you to make a disabled key usable again. You must
+     * specify the `region` and `key_id` parameters.
+     *
+     * @param request - The request {@link EnableKeyRequest}
+     * @returns A Promise of Key
+     */
+    enableKey: (request: Readonly<EnableKeyRequest>) => Promise<Key>;
+    /**
+     * Disable key. Disable a given key to be used for cryptographic operations.
+     * Disabling a key renders it unusable. You must specify the `region` and
+     * `key_id` parameters.
+     *
+     * @param request - The request {@link DisableKeyRequest}
+     * @returns A Promise of Key
+     */
+    disableKey: (request: Readonly<DisableKeyRequest>) => Promise<Key>;
+    protected pageOfListKeys: (request?: Readonly<ListKeysRequest>) => Promise<ListKeysResponse>;
+    /**
+     * List keys. Retrieve the list of keys created within all Projects of an
+     * Organization or in a given Project. You must specify the `region`, and
+     * either the `organization_id` or the `project_id`.
+     *
+     * @param request - The request {@link ListKeysRequest}
+     * @returns A Promise of ListKeysResponse
+     */
+    listKeys: (request?: Readonly<ListKeysRequest>) => Promise<ListKeysResponse> & {
+        all: () => Promise<Key[]>;
+        [Symbol.asyncIterator]: () => AsyncGenerator<Key[], void, void>;
+    };
+    /**
+     * Generate a data encryption key. Generate a new data encryption key to use
+     * for cryptographic operations outside of Key Manager. Note that Key Manager
+     * does not store your data encryption key. The data encryption key is
+     * encrypted and must be decrypted using the key you have created in Key
+     * Manager. The data encryption key's plaintext is returned in the response
+     * object, for immediate usage.
+     *
+     * Always store the data encryption key's ciphertext, rather than its
+     * plaintext, which must not be stored. To retrieve your key's plaintext, call
+     * the Decrypt endpoint with your key's ID and ciphertext.
+     *
+     * @param request - The request {@link GenerateDataKeyRequest}
+     * @returns A Promise of DataKey
+     */
+    generateDataKey: (request: Readonly<GenerateDataKeyRequest>) => Promise<DataKey>;
+    /**
+     * Encrypt data. Encrypt data using an existing key, specified by the `key_id`
+     * parameter. Only keys with a usage set to **symmetric_encryption** are
+     * supported by this method. The maximum payload size that can be encrypted is
+     * 64KB of plaintext.
+     *
+     * @param request - The request {@link EncryptRequest}
+     * @returns A Promise of EncryptResponse
+     */
+    encrypt: (request: Readonly<EncryptRequest>) => Promise<EncryptResponse>;
+    /**
+     * Decrypt data. Decrypt data using an existing key, specified by the `key_id`
+     * parameter. The maximum payload size that can be decrypted is the result of
+     * the encryption of 64KB of data (around 131KB).
+     *
+     * @param request - The request {@link DecryptRequest}
+     * @returns A Promise of DecryptResponse
+     */
+    decrypt: (request: Readonly<DecryptRequest>) => Promise<DecryptResponse>;
+}