@scaleway/sdk 2.28.0 → 2.30.0

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

@@ -0,0 +1,257 @@
+import { API as API$1 } from "../../../scw/api.js";
+import { validatePathParam, urlParams } from "../../../helpers/marshalling.js";
+import { enrichForPagination } from "../../../scw/fetch/resource-paginator.js";
+import { marshalCreateKeyRequest, unmarshalKey, marshalUpdateKeyRequest, unmarshalListKeysResponse, marshalGenerateDataKeyRequest, unmarshalDataKey, marshalEncryptRequest, unmarshalEncryptResponse, marshalDecryptRequest, unmarshalDecryptResponse } from "./marshalling.gen.js";
+const jsonContentHeaders = {
+  "Content-Type": "application/json; charset=utf-8"
+};
+class API extends API$1 {
+  /** 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(
+        marshalCreateKeyRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys`
+    },
+    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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}`
+    },
+    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(
+        marshalUpdateKeyRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "PATCH",
+      path: `/key-manager/v1alpha1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}`
+    },
+    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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/rotate`
+    },
+    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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/protect`
+    },
+    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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/unprotect`
+    },
+    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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/enable`
+    },
+    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/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/disable`
+    },
+    unmarshalKey
+  );
+  pageOfListKeys = (request = {}) => this.client.fetch(
+    {
+      method: "GET",
+      path: `/key-manager/v1alpha1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys`,
+      urlParams: 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]
+      )
+    },
+    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 = {}) => 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(
+        marshalGenerateDataKeyRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/generate-data-key`
+    },
+    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(
+        marshalEncryptRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/encrypt`
+    },
+    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(
+        marshalDecryptRequest(request, this.client.settings)
+      ),
+      headers: jsonContentHeaders,
+      method: "POST",
+      path: `/key-manager/v1alpha1/regions/${validatePathParam("region", request.region ?? this.client.settings.defaultRegion)}/keys/${validatePathParam("keyId", request.keyId)}/decrypt`
+    },
+    unmarshalDecryptResponse
+  );
+}
+export {
+  API
+};

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

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

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

@@ -0,0 +1,2 @@
+export { API } from './api.gen';
+export type { CreateKeyRequest, DataKey, DataKeyAlgorithmSymmetricEncryption, DecryptRequest, DecryptResponse, DeleteKeyRequest, DisableKeyRequest, EnableKeyRequest, EncryptRequest, EncryptResponse, GenerateDataKeyRequest, GetKeyRequest, Key, KeyAlgorithmSymmetricEncryption, KeyRotationPolicy, KeyState, KeyUsage, ListKeysRequest, ListKeysRequestOrderBy, ListKeysResponse, ProtectKeyRequest, RotateKeyRequest, UnprotectKeyRequest, UpdateKeyRequest, } from './types.gen';

package/dist/api/key_manager/v1alpha1/index.gen.js

@@ -0,0 +1,4 @@
+import { API } from "./api.gen.js";
+export {
+  API
+};

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../../helpers/json.cjs");
+const marshalling = require("../../../helpers/marshalling.cjs");
+const unmarshalKeyRotationPolicy = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'KeyRotationPolicy' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    nextRotationAt: marshalling.unmarshalDate(data.next_rotation_at),
+    rotationPeriod: data.rotation_period
+  };
+};
+const unmarshalKeyUsage = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'KeyUsage' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    symmetricEncryption: data.symmetric_encryption ? data.symmetric_encryption : void 0
+  };
+};
+const unmarshalKey = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'Key' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    createdAt: marshalling.unmarshalDate(data.created_at),
+    description: data.description,
+    id: data.id,
+    locked: data.locked,
+    name: data.name,
+    projectId: data.project_id,
+    protected: data.protected,
+    region: data.region,
+    rotatedAt: marshalling.unmarshalDate(data.rotated_at),
+    rotationCount: data.rotation_count,
+    rotationPolicy: data.rotation_policy ? unmarshalKeyRotationPolicy(data.rotation_policy) : void 0,
+    state: data.state,
+    tags: data.tags,
+    updatedAt: marshalling.unmarshalDate(data.updated_at),
+    usage: data.usage ? unmarshalKeyUsage(data.usage) : void 0
+  };
+};
+const unmarshalDataKey = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'DataKey' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    algorithm: data.algorithm,
+    ciphertext: data.ciphertext,
+    createdAt: marshalling.unmarshalDate(data.created_at),
+    keyId: data.key_id,
+    plaintext: data.plaintext
+  };
+};
+const unmarshalDecryptResponse = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'DecryptResponse' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    ciphertext: data.ciphertext,
+    keyId: data.key_id,
+    plaintext: data.plaintext
+  };
+};
+const unmarshalEncryptResponse = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'EncryptResponse' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    ciphertext: data.ciphertext,
+    keyId: data.key_id
+  };
+};
+const unmarshalListKeysResponse = (data) => {
+  if (!json.isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'ListKeysResponse' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    keys: marshalling.unmarshalArrayOfObject(data.keys, unmarshalKey),
+    totalCount: data.total_count
+  };
+};
+const marshalKeyRotationPolicy = (request, defaults) => ({
+  next_rotation_at: request.nextRotationAt,
+  rotation_period: request.rotationPeriod
+});
+const marshalKeyUsage = (request, defaults) => ({
+  ...marshalling.resolveOneOf([
+    { param: "symmetric_encryption", value: request.symmetricEncryption }
+  ])
+});
+const marshalCreateKeyRequest = (request, defaults) => ({
+  description: request.description,
+  name: request.name,
+  project_id: request.projectId ?? defaults.defaultProjectId,
+  rotation_policy: request.rotationPolicy !== void 0 ? marshalKeyRotationPolicy(request.rotationPolicy) : void 0,
+  tags: request.tags,
+  unprotected: request.unprotected,
+  usage: request.usage !== void 0 ? marshalKeyUsage(request.usage) : void 0
+});
+const marshalDecryptRequest = (request, defaults) => ({
+  associated_data: request.associatedData,
+  ciphertext: request.ciphertext
+});
+const marshalEncryptRequest = (request, defaults) => ({
+  associated_data: request.associatedData,
+  plaintext: request.plaintext
+});
+const marshalGenerateDataKeyRequest = (request, defaults) => ({
+  algorithm: request.algorithm,
+  without_plaintext: request.withoutPlaintext
+});
+const marshalUpdateKeyRequest = (request, defaults) => ({
+  description: request.description,
+  name: request.name,
+  rotation_policy: request.rotationPolicy !== void 0 ? marshalKeyRotationPolicy(request.rotationPolicy) : void 0,
+  tags: request.tags
+});
+exports.marshalCreateKeyRequest = marshalCreateKeyRequest;
+exports.marshalDecryptRequest = marshalDecryptRequest;
+exports.marshalEncryptRequest = marshalEncryptRequest;
+exports.marshalGenerateDataKeyRequest = marshalGenerateDataKeyRequest;
+exports.marshalUpdateKeyRequest = marshalUpdateKeyRequest;
+exports.unmarshalDataKey = unmarshalDataKey;
+exports.unmarshalDecryptResponse = unmarshalDecryptResponse;
+exports.unmarshalEncryptResponse = unmarshalEncryptResponse;
+exports.unmarshalKey = unmarshalKey;
+exports.unmarshalListKeysResponse = unmarshalListKeysResponse;

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

@@ -0,0 +1,12 @@
+import type { DefaultValues } from '../../../bridge';
+import type { CreateKeyRequest, DataKey, DecryptRequest, DecryptResponse, EncryptRequest, EncryptResponse, GenerateDataKeyRequest, Key, ListKeysResponse, UpdateKeyRequest } from './types.gen';
+export declare const unmarshalKey: (data: unknown) => Key;
+export declare const unmarshalDataKey: (data: unknown) => DataKey;
+export declare const unmarshalDecryptResponse: (data: unknown) => DecryptResponse;
+export declare const unmarshalEncryptResponse: (data: unknown) => EncryptResponse;
+export declare const unmarshalListKeysResponse: (data: unknown) => ListKeysResponse;
+export declare const marshalCreateKeyRequest: (request: CreateKeyRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalDecryptRequest: (request: DecryptRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalEncryptRequest: (request: EncryptRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalGenerateDataKeyRequest: (request: GenerateDataKeyRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalUpdateKeyRequest: (request: UpdateKeyRequest, defaults: DefaultValues) => Record<string, unknown>;

package/dist/api/key_manager/v1alpha1/marshalling.gen.js

@@ -0,0 +1,143 @@
+import { isJSONObject } from "../../../helpers/json.js";
+import { unmarshalDate, unmarshalArrayOfObject, resolveOneOf } from "../../../helpers/marshalling.js";
+const unmarshalKeyRotationPolicy = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'KeyRotationPolicy' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    nextRotationAt: unmarshalDate(data.next_rotation_at),
+    rotationPeriod: data.rotation_period
+  };
+};
+const unmarshalKeyUsage = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'KeyUsage' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    symmetricEncryption: data.symmetric_encryption ? data.symmetric_encryption : void 0
+  };
+};
+const unmarshalKey = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'Key' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    createdAt: unmarshalDate(data.created_at),
+    description: data.description,
+    id: data.id,
+    locked: data.locked,
+    name: data.name,
+    projectId: data.project_id,
+    protected: data.protected,
+    region: data.region,
+    rotatedAt: unmarshalDate(data.rotated_at),
+    rotationCount: data.rotation_count,
+    rotationPolicy: data.rotation_policy ? unmarshalKeyRotationPolicy(data.rotation_policy) : void 0,
+    state: data.state,
+    tags: data.tags,
+    updatedAt: unmarshalDate(data.updated_at),
+    usage: data.usage ? unmarshalKeyUsage(data.usage) : void 0
+  };
+};
+const unmarshalDataKey = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'DataKey' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    algorithm: data.algorithm,
+    ciphertext: data.ciphertext,
+    createdAt: unmarshalDate(data.created_at),
+    keyId: data.key_id,
+    plaintext: data.plaintext
+  };
+};
+const unmarshalDecryptResponse = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'DecryptResponse' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    ciphertext: data.ciphertext,
+    keyId: data.key_id,
+    plaintext: data.plaintext
+  };
+};
+const unmarshalEncryptResponse = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'EncryptResponse' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    ciphertext: data.ciphertext,
+    keyId: data.key_id
+  };
+};
+const unmarshalListKeysResponse = (data) => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(
+      `Unmarshalling the type 'ListKeysResponse' failed as data isn't a dictionary.`
+    );
+  }
+  return {
+    keys: unmarshalArrayOfObject(data.keys, unmarshalKey),
+    totalCount: data.total_count
+  };
+};
+const marshalKeyRotationPolicy = (request, defaults) => ({
+  next_rotation_at: request.nextRotationAt,
+  rotation_period: request.rotationPeriod
+});
+const marshalKeyUsage = (request, defaults) => ({
+  ...resolveOneOf([
+    { param: "symmetric_encryption", value: request.symmetricEncryption }
+  ])
+});
+const marshalCreateKeyRequest = (request, defaults) => ({
+  description: request.description,
+  name: request.name,
+  project_id: request.projectId ?? defaults.defaultProjectId,
+  rotation_policy: request.rotationPolicy !== void 0 ? marshalKeyRotationPolicy(request.rotationPolicy) : void 0,
+  tags: request.tags,
+  unprotected: request.unprotected,
+  usage: request.usage !== void 0 ? marshalKeyUsage(request.usage) : void 0
+});
+const marshalDecryptRequest = (request, defaults) => ({
+  associated_data: request.associatedData,
+  ciphertext: request.ciphertext
+});
+const marshalEncryptRequest = (request, defaults) => ({
+  associated_data: request.associatedData,
+  plaintext: request.plaintext
+});
+const marshalGenerateDataKeyRequest = (request, defaults) => ({
+  algorithm: request.algorithm,
+  without_plaintext: request.withoutPlaintext
+});
+const marshalUpdateKeyRequest = (request, defaults) => ({
+  description: request.description,
+  name: request.name,
+  rotation_policy: request.rotationPolicy !== void 0 ? marshalKeyRotationPolicy(request.rotationPolicy) : void 0,
+  tags: request.tags
+});
+export {
+  marshalCreateKeyRequest,
+  marshalDecryptRequest,
+  marshalEncryptRequest,
+  marshalGenerateDataKeyRequest,
+  marshalUpdateKeyRequest,
+  unmarshalDataKey,
+  unmarshalDecryptResponse,
+  unmarshalEncryptResponse,
+  unmarshalKey,
+  unmarshalListKeysResponse
+};