@scaleway/sdk 2.29.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/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>;
+}