@qlik/api 1.30.0 → 1.32.0

package/di-projects.js

@@ -0,0 +1,164 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/VVD2DPKQ.js";
+import "./chunks/LTNGXTXG.js";
+import "./chunks/2ZQ3ZX7F.js";
+
+// src/public/rest/di-projects.ts
+var getDiProjects = async (query, options) => invokeFetch("di-projects", {
+  method: "get",
+  pathTemplate: "/api/v1/di-projects",
+  query,
+  options
+});
+var createDiProject = async (body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects",
+  body,
+  contentType: "application/json",
+  options
+});
+var getDiProject = async (actionId, query, options) => invokeFetch("di-projects", {
+  method: "get",
+  pathTemplate: "/api/v1/di-projects/actions/{actionId}",
+  pathVariables: { actionId },
+  query,
+  options
+});
+var exportDiProject = async (projectId, body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/actions/export",
+  pathVariables: { projectId },
+  body,
+  contentType: "application/json",
+  options
+});
+var importDiProject = async (projectId, body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/actions/import",
+  pathVariables: { projectId },
+  body,
+  contentType: "multipart/form-data",
+  options
+});
+var prepareDiProject = async (projectId, body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/actions/prepare",
+  pathVariables: { projectId },
+  body,
+  contentType: "application/json",
+  options
+});
+var validateDiProject = async (projectId, body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/actions/validate",
+  pathVariables: { projectId },
+  body,
+  contentType: "application/json",
+  options
+});
+var getDiProjectExportVariables = async (projectId, query, options) => invokeFetch("di-projects", {
+  method: "get",
+  pathTemplate: "/api/v1/di-projects/{projectId}/bindings",
+  pathVariables: { projectId },
+  query,
+  options
+});
+var setDiProjectExportVariables = async (projectId, body, options) => invokeFetch("di-projects", {
+  method: "put",
+  pathTemplate: "/api/v1/di-projects/{projectId}/bindings",
+  pathVariables: { projectId },
+  body,
+  contentType: "application/json",
+  options
+});
+var getDiProjectDiTasks = async (projectId, options) => invokeFetch("di-projects", {
+  method: "get",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks",
+  pathVariables: { projectId },
+  options
+});
+var getDiProjectDiTask = async (projectId, dataTaskId, options) => invokeFetch("di-projects", {
+  method: "get",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}",
+  pathVariables: { projectId, dataTaskId },
+  options
+});
+var prepareDiProjectDiTask = async (projectId, dataTaskId, body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}/actions/prepare",
+  pathVariables: { projectId, dataTaskId },
+  body,
+  contentType: "application/json",
+  options
+});
+var validateDiProjectDiTask = async (projectId, dataTaskId, body, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}/actions/validate",
+  pathVariables: { projectId, dataTaskId },
+  body,
+  contentType: "application/json",
+  options
+});
+var startDiProjectDiTaskRuntime = async (projectId, dataTaskId, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}/runtime/actions/start",
+  pathVariables: { projectId, dataTaskId },
+  options
+});
+var stopDiProjectDiTaskRuntime = async (projectId, dataTaskId, options) => invokeFetch("di-projects", {
+  method: "post",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}/runtime/actions/stop",
+  pathVariables: { projectId, dataTaskId },
+  options
+});
+var getDiProjectDiTaskRuntimeState = async (projectId, dataTaskId, options) => invokeFetch("di-projects", {
+  method: "get",
+  pathTemplate: "/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}/runtime/state",
+  pathVariables: { projectId, dataTaskId },
+  options
+});
+function clearCache() {
+  return clearApiCache("di-projects");
+}
+var diProjectsExport = {
+  getDiProjects,
+  createDiProject,
+  getDiProject,
+  exportDiProject,
+  importDiProject,
+  prepareDiProject,
+  validateDiProject,
+  getDiProjectExportVariables,
+  setDiProjectExportVariables,
+  getDiProjectDiTasks,
+  getDiProjectDiTask,
+  prepareDiProjectDiTask,
+  validateDiProjectDiTask,
+  startDiProjectDiTaskRuntime,
+  stopDiProjectDiTaskRuntime,
+  getDiProjectDiTaskRuntimeState,
+  clearCache
+};
+var di_projects_default = diProjectsExport;
+export {
+  clearCache,
+  createDiProject,
+  di_projects_default as default,
+  exportDiProject,
+  getDiProject,
+  getDiProjectDiTask,
+  getDiProjectDiTaskRuntimeState,
+  getDiProjectDiTasks,
+  getDiProjectExportVariables,
+  getDiProjects,
+  importDiProject,
+  prepareDiProject,
+  prepareDiProjectDiTask,
+  setDiProjectExportVariables,
+  startDiProjectDiTaskRuntime,
+  stopDiProjectDiTaskRuntime,
+  validateDiProject,
+  validateDiProjectDiTask
+};

package/docs/authentication.md

@@ -246,4 +246,51 @@ const hostConfig: HostConfig = {
 setDefaultHostConfig(hostConfig);
 ```
 
+## Registering a Host Config
+
+It is possible to register a named host config and reference it when making api-calls.
+
+When referencing a registered host config we use a special host config type with the auth type `reference` which only
+takes one property with the same name (`.reference`). There is no need to specify the auth type in the host config
+when using this host config type.
+
+This example shows how to use the `registerHostConfig` function and how to reference it.
+
+```ts
+import { auth, spaces } from "@qlik/api";
+
+auth.registerHostConfig("tenant 1", {
+  host: "tenant1.eu.qlikcloud.com",
+  authType: "apikey",
+  apiKey: "<api-key>",
+});
+
+auth.registerHostConfig("tenant 2", {
+  host: "tenant2.eu.qlikcloud.com",
+  authType: "apikey",
+  apiKey: "<api-key>",
+});
+
+const response = await spaces.getSpaces({}, { hostConfig: { reference: "tenant 1" } });
+console.log(`Tenant 1 has ${response.data.data.length} spaces`);
+const response2 = await spaces.getSpaces({}, { hostConfig: { reference: "tenant 2" } });
+console.log(`Tenant 2 has ${response2.data.data.length} spaces`);
+```
+
+This works equally well when using it in the `createQlikApi` function.
+
+```ts
+import { auth, createQlikApi } from "@qlik/api";
+
+auth.registerHostConfig("tenant 1", {
+  host: "tenant1.eu.qlikcloud.com",
+  authType: "apikey",
+  apiKey: "<api-key>",
+});
+
+const api = createQlikApi({ reference: "tenant 1" });
+
+// api is now bound to the registered host config "tenant 1"
+```
+
 ◁ [Back to overview](../README.md)

package/encryption.d.ts

@@ -0,0 +1,370 @@
+import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
+import './auth-types-DqfMuSRX.js';
+
+/**
+ * @example
+ * {
+ *   arn: "arn:aws:kms:eu-west-1:111222334455:key/mrk-1237c011a37erft67ei987c7612q456",
+ *   current: false,
+ *   description: "test description",
+ *   multiRegion: true,
+ *   name: "test name",
+ *   replicaKeys: [
+ *     {
+ *       arn: "arn:aws:kms:eu-west-3:111222334455:key/mrk-1237c011a37erft67ei987c7612q456",
+ *       region: "eu-west-3"
+ *     }
+ *   ]
+ * }
+ */
+type KeyProvider = {
+    /** The provider resource notation for the key. */
+    arn: string;
+    /** The ARN fingerprint. */
+    readonly arnFingerPrint?: string;
+    /** When key entry was created. */
+    readonly createdAt?: string;
+    /** Indicates whether the key is being used to encrypt/decrypt secrets. */
+    readonly current?: boolean;
+    /** When the key was demoted from being current to non active. */
+    readonly demotedFromCurrentAt?: string;
+    /** Description of key provider entry. */
+    description?: string;
+    /** Key Provider type. */
+    keyProvider?: "AWS-KMS";
+    /** Indicates whether the key has multi-region configurations and has replica key in qcs secondary region. */
+    readonly multiRegion?: boolean;
+    /** Name of key provider entry. */
+    name: string;
+    /** When the key was promoted to being the current active one. */
+    readonly promotedToCurrentAt?: string;
+    readonly replicaKeys?: {
+        /** Replica key keeps list of backup keys from the supported qcs secondary region. */
+        arn?: string;
+        /** Region indicates the backup qcs-region link to the primary region. */
+        region?: string;
+    }[];
+    /** Tenant ID. */
+    readonly tenantId?: string;
+};
+/**
+ * A JSON Patch document as defined in https://datatracker.ietf.org/doc/html/rfc6902.
+ * @example
+ * {
+ *   op: "replace",
+ *   path: "/name",
+ *   value: "New Encryption Key"
+ * }
+ */
+type KeyProviderPatchBase = {
+    /** The operation to be performed. */
+    op: "replace";
+    /** The property path. */
+    path: string;
+    /** The value to be used for this operation. */
+    value: string;
+};
+type KeyProviderPatchSchema = KeyProviderPatchBase[];
+type KeyProviders = {
+    errors?: KeyProvider[];
+};
+type KeyProvidersDeleteResponseBody = {
+    /** Successful response message. */
+    response?: string;
+};
+type ListKeyProviders = {
+    errors?: KeyProvider[];
+};
+type MigrationInformation = {
+    completedAt?: string;
+    /** Migration operation ID. */
+    id?: string;
+    initiatedAt?: string;
+    /** The key ARN being migrated from (in case of QlikVault, could be a short name only). */
+    migratingFrom?: string;
+    /** The new key ARN that keys should be migrated to. */
+    migratingTo?: string;
+    /** The new key ARN fingerprint. */
+    migratingToFingerprint?: string;
+    /** The new key prefix (to help services know which prefix should NOT be migrated). */
+    migratingToPrefix?: string;
+    /** Progress in percentage. */
+    progress?: number;
+    /** Migration operation state. */
+    state?: "New" | "InProgress" | "Completed";
+    /** Tenant ID. */
+    tenantId?: string;
+};
+type ResetMigrationNotNeeded = {
+    /** Tenant is already using Qlik KMS, no migration is required. */
+    message?: string;
+};
+type StandardError = {
+    errors: StandardErrorItem[];
+};
+type StandardErrorItem = {
+    /** The error code. */
+    code: string;
+    /** Extra information about the error. */
+    detail?: string;
+    /** Additional error object metadata. */
+    meta?: unknown;
+    /** Description of the error. */
+    title: string;
+};
+/**
+ * Returns a list of AWS key providers in the tenant. Use /actions/list to return all key providers.
+ *
+ * @throws GetEncryptionKeyprovidersHttpError
+ */
+declare const getEncryptionKeyproviders: (options?: ApiCallOptions) => Promise<GetEncryptionKeyprovidersHttpResponse>;
+type GetEncryptionKeyprovidersHttpResponse = {
+    data: KeyProviders;
+    headers: Headers;
+    status: 200;
+};
+type GetEncryptionKeyprovidersHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 417;
+};
+/**
+ * The AWS-KMS key configuration must match the Qlik Cloud region configuration requirements. Most regions should have a key deployed to the same AWS region as the Qlik Cloud tenant, with a replica key in the relevant Qlik Cloud DR region. Consult the documentation for DR region mappings.
+ *
+ * @param body an object with the body content
+ * @throws CreateEncryptionKeyproviderHttpError
+ */
+declare const createEncryptionKeyprovider: (body: KeyProvider, options?: ApiCallOptions) => Promise<CreateEncryptionKeyproviderHttpResponse>;
+type CreateEncryptionKeyproviderHttpResponse = {
+    data: KeyProvider;
+    headers: Headers;
+    status: 201;
+};
+type CreateEncryptionKeyproviderHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 401 | 403 | 406 | 408 | 409 | 417;
+};
+/**
+ * Returns a list of all key providers in the tenant, including the default Qlik key provider.
+ *
+ * @throws ListEncryptionKeyprovidersHttpError
+ */
+declare const listEncryptionKeyproviders: (options?: ApiCallOptions) => Promise<ListEncryptionKeyprovidersHttpResponse>;
+type ListEncryptionKeyprovidersHttpResponse = {
+    data: ListKeyProviders;
+    headers: Headers;
+    status: 200;
+};
+type ListEncryptionKeyprovidersHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 417;
+};
+/**
+ * Reset the encryption key back to the default Qlik managed provider. No action will be taken if tenant is already using the Qlik provider.
+ *
+ * @throws ResetEncryptionKeyprovidersHttpError
+ */
+declare const resetEncryptionKeyproviders: (options?: ApiCallOptions) => Promise<ResetEncryptionKeyprovidersHttpResponse>;
+type ResetEncryptionKeyprovidersHttpResponse = ResetEncryptionKeyproviders200HttpResponse | ResetEncryptionKeyproviders205HttpResponse;
+type ResetEncryptionKeyproviders200HttpResponse = {
+    data: ResetMigrationNotNeeded;
+    headers: Headers;
+    status: 200;
+};
+type ResetEncryptionKeyproviders205HttpResponse = {
+    data: MigrationInformation;
+    headers: Headers;
+    status: 205;
+};
+type ResetEncryptionKeyprovidersHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 401 | 406 | 412 | 424;
+};
+/**
+ * Retrieve details for the ongoing or last completed migration for the tenant.
+ *
+ * @throws GetEncryptionKeyprovidersMigrationDetailsHttpError
+ */
+declare const getEncryptionKeyprovidersMigrationDetails: (options?: ApiCallOptions) => Promise<GetEncryptionKeyprovidersMigrationDetailsHttpResponse>;
+type GetEncryptionKeyprovidersMigrationDetailsHttpResponse = {
+    data: MigrationInformation;
+    headers: Headers;
+    status: 200;
+};
+type GetEncryptionKeyprovidersMigrationDetailsHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 401 | 404 | 417;
+};
+/**
+ * Delete a key configuration from the tenant. Not supported for the default Qlik managed key provider. Key must not be in use.
+ *
+ * @param arnFingerPrint The fingerprint of the key provider you wish to delete.
+ * @throws DeleteEncryptionKeyproviderHttpError
+ */
+declare const deleteEncryptionKeyprovider: (arnFingerPrint: string, options?: ApiCallOptions) => Promise<DeleteEncryptionKeyproviderHttpResponse>;
+type DeleteEncryptionKeyproviderHttpResponse = {
+    data: KeyProvidersDeleteResponseBody;
+    headers: Headers;
+    status: 204;
+};
+type DeleteEncryptionKeyproviderHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 404 | 417 | 424;
+};
+/**
+ * Retrieve key provider detail by passing the ARN fingerprint as parameter.
+ *
+ * @param arnFingerPrint The fingerprint of the requested provider key.
+ * @throws GetEncryptionKeyproviderHttpError
+ */
+declare const getEncryptionKeyprovider: (arnFingerPrint: string, options?: ApiCallOptions) => Promise<GetEncryptionKeyproviderHttpResponse>;
+type GetEncryptionKeyproviderHttpResponse = {
+    data: KeyProvider;
+    headers: Headers;
+    status: 200;
+};
+type GetEncryptionKeyproviderHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 404 | 414;
+};
+/**
+ * Update the name and/or description of a key provider.
+ *
+ * @param arnFingerPrint The ARN fingerprint of an existing key provider key.
+ * @param body an object with the body content
+ * @throws PatchEncryptionKeyproviderHttpError
+ */
+declare const patchEncryptionKeyprovider: (arnFingerPrint: string, body: KeyProviderPatchSchema, options?: ApiCallOptions) => Promise<PatchEncryptionKeyproviderHttpResponse>;
+type PatchEncryptionKeyproviderHttpResponse = {
+    data: void;
+    headers: Headers;
+    status: 204;
+};
+type PatchEncryptionKeyproviderHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 401 | 404 | 417;
+};
+/**
+ * Migrate the active key from one provider to another. The migration process may take some time to complete, however this process will not impact users, and the tenant will continue to function normally during the migration. Use the migration details endpoint to monitor migration progress.
+ *
+ * @param arnFingerPrint The fingerprint of an existing key provider key.
+ * @throws MigrateEncryptionKeyproviderHttpError
+ */
+declare const migrateEncryptionKeyprovider: (arnFingerPrint: string, options?: ApiCallOptions) => Promise<MigrateEncryptionKeyproviderHttpResponse>;
+type MigrateEncryptionKeyproviderHttpResponse = {
+    data: MigrationInformation;
+    headers: Headers;
+    status: 200;
+};
+type MigrateEncryptionKeyproviderHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 401 | 404 | 412 | 424 | 428;
+};
+/**
+ * Validate a key to check if Qlik Cloud has required access to your AWS account and key policy, and the key configuration. If the key policy or configuration are changed from the required configuration, this may impact your ability to access your tenant.
+ *
+ * @param arnFingerPrint The fingerprint of an existing key provider key.
+ * @throws TestEncryptionKeyproviderHttpError
+ */
+declare const testEncryptionKeyprovider: (arnFingerPrint: string, options?: ApiCallOptions) => Promise<TestEncryptionKeyproviderHttpResponse>;
+type TestEncryptionKeyproviderHttpResponse = {
+    data: KeyProvider;
+    headers: Headers;
+    status: 201;
+};
+type TestEncryptionKeyproviderHttpError = {
+    data: StandardError;
+    headers: Headers;
+    status: 400 | 401 | 404 | 408;
+};
+/**
+ * Clears the cache for encryption api requests.
+ */
+declare function clearCache(): void;
+interface EncryptionAPI {
+    /**
+     * Returns a list of AWS key providers in the tenant. Use /actions/list to return all key providers.
+     *
+     * @throws GetEncryptionKeyprovidersHttpError
+     */
+    getEncryptionKeyproviders: typeof getEncryptionKeyproviders;
+    /**
+     * The AWS-KMS key configuration must match the Qlik Cloud region configuration requirements. Most regions should have a key deployed to the same AWS region as the Qlik Cloud tenant, with a replica key in the relevant Qlik Cloud DR region. Consult the documentation for DR region mappings.
+     *
+     * @param body an object with the body content
+     * @throws CreateEncryptionKeyproviderHttpError
+     */
+    createEncryptionKeyprovider: typeof createEncryptionKeyprovider;
+    /**
+     * Returns a list of all key providers in the tenant, including the default Qlik key provider.
+     *
+     * @throws ListEncryptionKeyprovidersHttpError
+     */
+    listEncryptionKeyproviders: typeof listEncryptionKeyproviders;
+    /**
+     * Reset the encryption key back to the default Qlik managed provider. No action will be taken if tenant is already using the Qlik provider.
+     *
+     * @throws ResetEncryptionKeyprovidersHttpError
+     */
+    resetEncryptionKeyproviders: typeof resetEncryptionKeyproviders;
+    /**
+     * Retrieve details for the ongoing or last completed migration for the tenant.
+     *
+     * @throws GetEncryptionKeyprovidersMigrationDetailsHttpError
+     */
+    getEncryptionKeyprovidersMigrationDetails: typeof getEncryptionKeyprovidersMigrationDetails;
+    /**
+     * Delete a key configuration from the tenant. Not supported for the default Qlik managed key provider. Key must not be in use.
+     *
+     * @param arnFingerPrint The fingerprint of the key provider you wish to delete.
+     * @throws DeleteEncryptionKeyproviderHttpError
+     */
+    deleteEncryptionKeyprovider: typeof deleteEncryptionKeyprovider;
+    /**
+     * Retrieve key provider detail by passing the ARN fingerprint as parameter.
+     *
+     * @param arnFingerPrint The fingerprint of the requested provider key.
+     * @throws GetEncryptionKeyproviderHttpError
+     */
+    getEncryptionKeyprovider: typeof getEncryptionKeyprovider;
+    /**
+     * Update the name and/or description of a key provider.
+     *
+     * @param arnFingerPrint The ARN fingerprint of an existing key provider key.
+     * @param body an object with the body content
+     * @throws PatchEncryptionKeyproviderHttpError
+     */
+    patchEncryptionKeyprovider: typeof patchEncryptionKeyprovider;
+    /**
+     * Migrate the active key from one provider to another. The migration process may take some time to complete, however this process will not impact users, and the tenant will continue to function normally during the migration. Use the migration details endpoint to monitor migration progress.
+     *
+     * @param arnFingerPrint The fingerprint of an existing key provider key.
+     * @throws MigrateEncryptionKeyproviderHttpError
+     */
+    migrateEncryptionKeyprovider: typeof migrateEncryptionKeyprovider;
+    /**
+     * Validate a key to check if Qlik Cloud has required access to your AWS account and key policy, and the key configuration. If the key policy or configuration are changed from the required configuration, this may impact your ability to access your tenant.
+     *
+     * @param arnFingerPrint The fingerprint of an existing key provider key.
+     * @throws TestEncryptionKeyproviderHttpError
+     */
+    testEncryptionKeyprovider: typeof testEncryptionKeyprovider;
+    /**
+     * Clears the cache for encryption api requests.
+     */
+    clearCache: typeof clearCache;
+}
+/**
+ * Functions for the encryption api
+ */
+declare const encryptionExport: EncryptionAPI;
+
+export { type CreateEncryptionKeyproviderHttpError, type CreateEncryptionKeyproviderHttpResponse, type DeleteEncryptionKeyproviderHttpError, type DeleteEncryptionKeyproviderHttpResponse, type EncryptionAPI, type GetEncryptionKeyproviderHttpError, type GetEncryptionKeyproviderHttpResponse, type GetEncryptionKeyprovidersHttpError, type GetEncryptionKeyprovidersHttpResponse, type GetEncryptionKeyprovidersMigrationDetailsHttpError, type GetEncryptionKeyprovidersMigrationDetailsHttpResponse, type KeyProvider, type KeyProviderPatchBase, type KeyProviderPatchSchema, type KeyProviders, type KeyProvidersDeleteResponseBody, type ListEncryptionKeyprovidersHttpError, type ListEncryptionKeyprovidersHttpResponse, type ListKeyProviders, type MigrateEncryptionKeyproviderHttpError, type MigrateEncryptionKeyproviderHttpResponse, type MigrationInformation, type PatchEncryptionKeyproviderHttpError, type PatchEncryptionKeyproviderHttpResponse, type ResetEncryptionKeyproviders200HttpResponse, type ResetEncryptionKeyproviders205HttpResponse, type ResetEncryptionKeyprovidersHttpError, type ResetEncryptionKeyprovidersHttpResponse, type ResetMigrationNotNeeded, type StandardError, type StandardErrorItem, type TestEncryptionKeyproviderHttpError, type TestEncryptionKeyproviderHttpResponse, clearCache, createEncryptionKeyprovider, encryptionExport as default, deleteEncryptionKeyprovider, getEncryptionKeyprovider, getEncryptionKeyproviders, getEncryptionKeyprovidersMigrationDetails, listEncryptionKeyproviders, migrateEncryptionKeyprovider, patchEncryptionKeyprovider, resetEncryptionKeyproviders, testEncryptionKeyprovider };

package/encryption.js

@@ -0,0 +1,98 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/VVD2DPKQ.js";
+import "./chunks/LTNGXTXG.js";
+import "./chunks/2ZQ3ZX7F.js";
+
+// src/public/rest/encryption.ts
+var getEncryptionKeyproviders = async (options) => invokeFetch("encryption", {
+  method: "get",
+  pathTemplate: "/api/v1/encryption/keyproviders",
+  options
+});
+var createEncryptionKeyprovider = async (body, options) => invokeFetch("encryption", {
+  method: "post",
+  pathTemplate: "/api/v1/encryption/keyproviders",
+  body,
+  contentType: "application/json",
+  options
+});
+var listEncryptionKeyproviders = async (options) => invokeFetch("encryption", {
+  method: "get",
+  pathTemplate: "/api/v1/encryption/keyproviders/actions/list",
+  options
+});
+var resetEncryptionKeyproviders = async (options) => invokeFetch("encryption", {
+  method: "post",
+  pathTemplate: "/api/v1/encryption/keyproviders/actions/reset-to-default-provider",
+  options
+});
+var getEncryptionKeyprovidersMigrationDetails = async (options) => invokeFetch("encryption", {
+  method: "get",
+  pathTemplate: "/api/v1/encryption/keyproviders/migration/actions/details",
+  options
+});
+var deleteEncryptionKeyprovider = async (arnFingerPrint, options) => invokeFetch("encryption", {
+  method: "delete",
+  pathTemplate: "/api/v1/encryption/keyproviders/{arnFingerPrint}",
+  pathVariables: { arnFingerPrint },
+  options
+});
+var getEncryptionKeyprovider = async (arnFingerPrint, options) => invokeFetch("encryption", {
+  method: "get",
+  pathTemplate: "/api/v1/encryption/keyproviders/{arnFingerPrint}",
+  pathVariables: { arnFingerPrint },
+  options
+});
+var patchEncryptionKeyprovider = async (arnFingerPrint, body, options) => invokeFetch("encryption", {
+  method: "patch",
+  pathTemplate: "/api/v1/encryption/keyproviders/{arnFingerPrint}",
+  pathVariables: { arnFingerPrint },
+  body,
+  contentType: "application/json",
+  options
+});
+var migrateEncryptionKeyprovider = async (arnFingerPrint, options) => invokeFetch("encryption", {
+  method: "post",
+  pathTemplate: "/api/v1/encryption/keyproviders/{arnFingerPrint}/actions/migrate",
+  pathVariables: { arnFingerPrint },
+  options
+});
+var testEncryptionKeyprovider = async (arnFingerPrint, options) => invokeFetch("encryption", {
+  method: "post",
+  pathTemplate: "/api/v1/encryption/keyproviders/{arnFingerPrint}/actions/test",
+  pathVariables: { arnFingerPrint },
+  options
+});
+function clearCache() {
+  return clearApiCache("encryption");
+}
+var encryptionExport = {
+  getEncryptionKeyproviders,
+  createEncryptionKeyprovider,
+  listEncryptionKeyproviders,
+  resetEncryptionKeyproviders,
+  getEncryptionKeyprovidersMigrationDetails,
+  deleteEncryptionKeyprovider,
+  getEncryptionKeyprovider,
+  patchEncryptionKeyprovider,
+  migrateEncryptionKeyprovider,
+  testEncryptionKeyprovider,
+  clearCache
+};
+var encryption_default = encryptionExport;
+export {
+  clearCache,
+  createEncryptionKeyprovider,
+  encryption_default as default,
+  deleteEncryptionKeyprovider,
+  getEncryptionKeyprovider,
+  getEncryptionKeyproviders,
+  getEncryptionKeyprovidersMigrationDetails,
+  listEncryptionKeyproviders,
+  migrateEncryptionKeyprovider,
+  patchEncryptionKeyprovider,
+  resetEncryptionKeyproviders,
+  testEncryptionKeyprovider
+};

package/extensions.d.ts

@@ -1,5 +1,5 @@
-import { A as ApiCallOptions } from './invoke-fetch-types-BXn-uSF5.js';
-import './auth-types-PkN9CAF_.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
+import './auth-types-DqfMuSRX.js';
 
 /**
  * Object containing meta data regarding the bundle the extension belongs to. If it does not belong to a bundle, this object is not defined.