@diia-inhouse/workflow 1.17.7 → 2.5.0

package/dist/cli/syncTemporalSchedules.js

@@ -1,92 +1,75 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { TemporalClient } from "../services/client.js";
+import { EnvService } from "@diia-inhouse/env";
+import { ScheduleAlreadyRunning } from "@temporalio/client";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { utils } from "@diia-inhouse/utils";
+//#region src/cli/syncTemporalSchedules.ts
+var SyncTemporalSchedulesCommand = class {
+	logger;
+	envService;
+	constructor(logger, envService) {
+		this.logger = logger;
+		this.envService = envService;
+	}
+	async run(schedulesPath = "worker/schedules", taskQueueParam) {
+		const startTime = Date.now();
+		this.logger.info("Starting sync temporal schedules", {
+			schedulesPath,
+			taskQueue: taskQueueParam
+		});
+		const schedules = await this.loadSchedules(schedulesPath);
+		if (!schedules) {
+			this.logger.info("Temporal schedules not found under provided path", { schedulesPath });
+			return;
+		}
+		const taskQueue = taskQueueParam || this.getTaskQueue();
+		if (!taskQueue) throw new Error("Task queue is not provided");
+		const client = new TemporalClient({
+			address: EnvService.getVar("TEMPORAL_ADDRESS"),
+			namespace: EnvService.getVar("TEMPORAL_NAMESPACE", "string", "default"),
+			taskQueue,
+			encryptionEnabled: EnvService.getVar("TEMPORAL_ENCRYPTION_ENABLED", "boolean", false),
+			encryptionKeyId: EnvService.getVar("TEMPORAL_ENCRYPTION_KEY_ID", "string", "")
+		}, this.envService, this.logger);
+		await client.onInit();
+		await this.syncSchedules(client, schedules);
+		this.logger.info(`Sync temporal schedules finished! It took ${((Date.now() - startTime) / 1e3).toFixed(1)} seconds`);
+		await client.nativeClient.connection.close();
+		process.exit(0);
+	}
+	async loadSchedules(schedulesPath) {
+		const fullSchedulesPath = this.resolveSchedulesPath(schedulesPath);
+		if (!existsSync(fullSchedulesPath)) return;
+		const { default: _default, ...schedules } = await import(fullSchedulesPath);
+		return schedules;
+	}
+	resolveSchedulesPath(schedulesPath) {
+		const baseDir = path.resolve("./dist");
+		const fullPath = path.resolve(baseDir, schedulesPath, "index.js");
+		if (!fullPath.startsWith(baseDir + path.sep)) throw new Error(`Invalid schedules path: path traversal detected in '${schedulesPath}'`);
+		return fullPath;
+	}
+	async syncSchedules(client, schedules) {
+		try {
+			const scheduleNames = Object.keys(schedules);
+			this.logger.info(`Found ${scheduleNames.length} schedules to sync: ${scheduleNames.join(", ")}`);
+			await client.syncSchedules(schedules);
+			this.logger.info("Successfully synced temporal schedules");
+		} catch (err) {
+			if (err instanceof ScheduleAlreadyRunning) {
+				this.logger.info("Schedule already running, skipping creation");
+				return;
+			}
+			this.logger.error("Failed to sync temporal schedules", { err });
+			throw err;
+		}
+	}
+	getTaskQueue() {
+		const taskQueue = EnvService.getVar("TEMPORAL_TASK_QUEUE", "string", "");
+		if (!taskQueue) return utils.getServiceName();
+		return taskQueue;
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncTemporalSchedulesCommand = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const client_1 = require("@temporalio/client");
-const ts_node_1 = require("ts-node");
-const env_1 = require("@diia-inhouse/env");
-const utils_1 = require("@diia-inhouse/utils");
-const client_2 = require("../services/client");
-(0, ts_node_1.register)();
-class SyncTemporalSchedulesCommand {
-    logger;
-    envService;
-    constructor(logger, envService) {
-        this.logger = logger;
-        this.envService = envService;
-    }
-    async run(schedulesPath = 'worker/schedules', taskQueueParam) {
-        const startTime = Date.now();
-        this.logger.info('Starting sync temporal schedules', { schedulesPath, taskQueue: taskQueueParam });
-        const schedules = await this.loadSchedules(schedulesPath);
-        if (!schedules) {
-            this.logger.info('Temporal schedules not found under provided path', { schedulesPath });
-            return;
-        }
-        const taskQueue = taskQueueParam || this.getTaskQueue();
-        if (!taskQueue) {
-            throw new Error('Task queue is not provided');
-        }
-        const temporalConfig = {
-            address: env_1.EnvService.getVar('TEMPORAL_ADDRESS'),
-            namespace: env_1.EnvService.getVar('TEMPORAL_NAMESPACE', 'string', 'default'),
-            taskQueue,
-            encryptionEnabled: env_1.EnvService.getVar('TEMPORAL_ENCRYPTION_ENABLED', 'boolean', false),
-            encryptionKeyId: env_1.EnvService.getVar('TEMPORAL_ENCRYPTION_KEY_ID', 'string', ''),
-        };
-        const client = new client_2.TemporalClient(temporalConfig, this.envService, this.logger);
-        await client.onInit();
-        await this.syncSchedules(client, schedules);
-        this.logger.info(`Sync temporal schedules finished! It took ${((Date.now() - startTime) / 1000).toFixed(1)} seconds`);
-        await client.nativeClient.connection.close();
-        // eslint-disable-next-line unicorn/no-process-exit
-        process.exit(0);
-    }
-    async loadSchedules(schedulesPath) {
-        const fullSchedulesPath = this.resolveSchedulesPath(schedulesPath);
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        const schedulesExist = (0, node_fs_1.existsSync)(fullSchedulesPath); // nosemgrep: eslint.detect-non-literal-fs-filename
-        if (!schedulesExist) {
-            return;
-        }
-        const module = await import(fullSchedulesPath);
-        return module.default;
-    }
-    resolveSchedulesPath(schedulesPath) {
-        const baseDir = node_path_1.default.resolve('./dist');
-        const fullPath = node_path_1.default.resolve(baseDir, schedulesPath, 'index.js');
-        if (!fullPath.startsWith(baseDir + node_path_1.default.sep)) {
-            throw new Error(`Invalid schedules path: path traversal detected in '${schedulesPath}'`);
-        }
-        return fullPath;
-    }
-    async syncSchedules(client, schedules) {
-        try {
-            const scheduleNames = Object.keys(schedules);
-            this.logger.info(`Found ${scheduleNames.length} schedules to sync: ${scheduleNames.join(', ')}`);
-            await client.syncSchedules(schedules);
-            this.logger.info('Successfully synced temporal schedules');
-        }
-        catch (err) {
-            if (err instanceof client_1.ScheduleAlreadyRunning) {
-                this.logger.info('Schedule already running, skipping creation');
-                return;
-            }
-            this.logger.error('Failed to sync temporal schedules', { err });
-            throw err;
-        }
-    }
-    getTaskQueue() {
-        const taskQueue = env_1.EnvService.getVar('TEMPORAL_TASK_QUEUE', 'string', '');
-        if (!taskQueue) {
-            return utils_1.utils.getServiceName();
-        }
-        return taskQueue;
-    }
-}
-exports.SyncTemporalSchedulesCommand = SyncTemporalSchedulesCommand;
-//# sourceMappingURL=syncTemporalSchedules.js.map
+//#endregion
+export { SyncTemporalSchedulesCommand };

package/dist/cli/updateTemporalSchedule.js

@@ -1,53 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateTemporalScheduleCommand = void 0;
-const env_1 = require("@diia-inhouse/env");
-const utils_1 = require("@diia-inhouse/utils");
-const client_1 = require("../services/client");
-class UpdateTemporalScheduleCommand {
-    logger;
-    envService;
-    constructor(logger, envService) {
-        this.logger = logger;
-        this.envService = envService;
-    }
-    async run(scheduleId, updateData) {
-        const startTime = Date.now();
-        this.logger.info('Starting update temporal schedule', { scheduleId });
-        const taskQueue = this.getTaskQueue();
-        if (!taskQueue) {
-            throw new Error('Task queue is not provided');
-        }
-        const temporalConfig = {
-            address: env_1.EnvService.getVar('TEMPORAL_ADDRESS'),
-            namespace: env_1.EnvService.getVar('TEMPORAL_NAMESPACE', 'string', 'default'),
-            taskQueue,
-            encryptionEnabled: env_1.EnvService.getVar('TEMPORAL_ENCRYPTION_ENABLED', 'boolean', false),
-            encryptionKeyId: env_1.EnvService.getVar('TEMPORAL_ENCRYPTION_KEY_ID', 'string', ''),
-        };
-        const client = new client_1.TemporalClient(temporalConfig, this.envService, this.logger);
-        await client.onInit();
-        try {
-            await client.updateSchedule(scheduleId, updateData);
-        }
-        catch (err) {
-            this.logger.error('Failed to update temporal schedule', { err });
-            throw err;
-        }
-        finally {
-            await client.nativeClient.connection.close();
-        }
-        this.logger.info(`Update temporal schedule finished! It took ${((Date.now() - startTime) / 1000).toFixed(1)} seconds`);
-        // eslint-disable-next-line unicorn/no-process-exit
-        process.exit(0);
-    }
-    getTaskQueue() {
-        const taskQueue = env_1.EnvService.getVar('TEMPORAL_TASK_QUEUE', 'string', '');
-        if (!taskQueue) {
-            return utils_1.utils.getServiceName();
-        }
-        return taskQueue;
-    }
-}
-exports.UpdateTemporalScheduleCommand = UpdateTemporalScheduleCommand;
-//# sourceMappingURL=updateTemporalSchedule.js.map
+import { TemporalClient } from "../services/client.js";
+import { EnvService } from "@diia-inhouse/env";
+import { utils } from "@diia-inhouse/utils";
+//#region src/cli/updateTemporalSchedule.ts
+var UpdateTemporalScheduleCommand = class {
+	logger;
+	envService;
+	constructor(logger, envService) {
+		this.logger = logger;
+		this.envService = envService;
+	}
+	async run(scheduleId, updateData) {
+		const startTime = Date.now();
+		this.logger.info("Starting update temporal schedule", { scheduleId });
+		const taskQueue = this.getTaskQueue();
+		if (!taskQueue) throw new Error("Task queue is not provided");
+		const client = new TemporalClient({
+			address: EnvService.getVar("TEMPORAL_ADDRESS"),
+			namespace: EnvService.getVar("TEMPORAL_NAMESPACE", "string", "default"),
+			taskQueue,
+			encryptionEnabled: EnvService.getVar("TEMPORAL_ENCRYPTION_ENABLED", "boolean", false),
+			encryptionKeyId: EnvService.getVar("TEMPORAL_ENCRYPTION_KEY_ID", "string", "")
+		}, this.envService, this.logger);
+		await client.onInit();
+		try {
+			await client.updateSchedule(scheduleId, updateData);
+		} catch (err) {
+			this.logger.error("Failed to update temporal schedule", { err });
+			throw err;
+		} finally {
+			await client.nativeClient.connection.close();
+		}
+		this.logger.info(`Update temporal schedule finished! It took ${((Date.now() - startTime) / 1e3).toFixed(1)} seconds`);
+		process.exit(0);
+	}
+	getTaskQueue() {
+		const taskQueue = EnvService.getVar("TEMPORAL_TASK_QUEUE", "string", "");
+		if (!taskQueue) return utils.getServiceName();
+		return taskQueue;
+	}
+};
+//#endregion
+export { UpdateTemporalScheduleCommand };

package/dist/client.d.ts

@@ -0,0 +1,3 @@
+import { TemporalClient } from "./services/client.js";
+import { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, DayOfWeek, MONTHS, Month, ProtoFailure, ScheduleOptions, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient, WorkflowHandleWithFirstExecutionRunId } from "@temporalio/client";
+export { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, type DayOfWeek, MONTHS, type Month, type ProtoFailure, type ScheduleOptions, ServerFailure, TemporalClient, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient, type WorkflowHandleWithFirstExecutionRunId };

package/dist/client.js

@@ -1,19 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemporalClient = exports.ChildWorkflowFailure = exports.ApplicationFailure = exports.TerminatedFailure = exports.CancelledFailure = exports.TemporalFailure = exports.TimeoutFailure = exports.ServerFailure = exports.ActivityFailure = exports.WorkflowClient = exports.MONTHS = exports.DAYS_OF_WEEK = exports.Client = void 0;
-var client_1 = require("@temporalio/client");
-Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
-Object.defineProperty(exports, "DAYS_OF_WEEK", { enumerable: true, get: function () { return client_1.DAYS_OF_WEEK; } });
-Object.defineProperty(exports, "MONTHS", { enumerable: true, get: function () { return client_1.MONTHS; } });
-Object.defineProperty(exports, "WorkflowClient", { enumerable: true, get: function () { return client_1.WorkflowClient; } });
-Object.defineProperty(exports, "ActivityFailure", { enumerable: true, get: function () { return client_1.ActivityFailure; } });
-Object.defineProperty(exports, "ServerFailure", { enumerable: true, get: function () { return client_1.ServerFailure; } });
-Object.defineProperty(exports, "TimeoutFailure", { enumerable: true, get: function () { return client_1.TimeoutFailure; } });
-Object.defineProperty(exports, "TemporalFailure", { enumerable: true, get: function () { return client_1.TemporalFailure; } });
-Object.defineProperty(exports, "CancelledFailure", { enumerable: true, get: function () { return client_1.CancelledFailure; } });
-Object.defineProperty(exports, "TerminatedFailure", { enumerable: true, get: function () { return client_1.TerminatedFailure; } });
-Object.defineProperty(exports, "ApplicationFailure", { enumerable: true, get: function () { return client_1.ApplicationFailure; } });
-Object.defineProperty(exports, "ChildWorkflowFailure", { enumerable: true, get: function () { return client_1.ChildWorkflowFailure; } });
-var client_2 = require("./services/client");
-Object.defineProperty(exports, "TemporalClient", { enumerable: true, get: function () { return client_2.TemporalClient; } });
-//# sourceMappingURL=client.js.map
+import { TemporalClient } from "./services/client.js";
+import { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, MONTHS, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient } from "@temporalio/client";
+export { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, MONTHS, ServerFailure, TemporalClient, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient };

package/dist/common.d.ts

@@ -0,0 +1,2 @@
+import { DataConverter, WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause } from "@temporalio/common";
+export { type DataConverter, WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause };

package/dist/common.js

@@ -1,13 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowExecutionAlreadyStartedError = exports.rootCause = exports.defaultFailureConverter = exports.extractWorkflowType = exports.ensureTemporalFailure = exports.ensureApplicationFailure = exports.cutoffStackTrace = exports.arrayFromPayloads = void 0;
-var common_1 = require("@temporalio/common");
-Object.defineProperty(exports, "arrayFromPayloads", { enumerable: true, get: function () { return common_1.arrayFromPayloads; } });
-Object.defineProperty(exports, "cutoffStackTrace", { enumerable: true, get: function () { return common_1.cutoffStackTrace; } });
-Object.defineProperty(exports, "ensureApplicationFailure", { enumerable: true, get: function () { return common_1.ensureApplicationFailure; } });
-Object.defineProperty(exports, "ensureTemporalFailure", { enumerable: true, get: function () { return common_1.ensureTemporalFailure; } });
-Object.defineProperty(exports, "extractWorkflowType", { enumerable: true, get: function () { return common_1.extractWorkflowType; } });
-Object.defineProperty(exports, "defaultFailureConverter", { enumerable: true, get: function () { return common_1.defaultFailureConverter; } });
-Object.defineProperty(exports, "rootCause", { enumerable: true, get: function () { return common_1.rootCause; } });
-Object.defineProperty(exports, "WorkflowExecutionAlreadyStartedError", { enumerable: true, get: function () { return common_1.WorkflowExecutionAlreadyStartedError; } });
-//# sourceMappingURL=common.js.map
+import { WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause } from "@temporalio/common";
+export { WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause };

package/dist/encryption/crypto.d.ts

@@ -0,0 +1,7 @@
+import { webcrypto } from "crypto";
+
+//#region src/encryption/crypto.d.ts
+declare function encrypt(data: Uint8Array, key: webcrypto.CryptoKey): Promise<Uint8Array>;
+declare function decrypt(encryptedData: Uint8Array, key: webcrypto.CryptoKey): Promise<Uint8Array>;
+//#endregion
+export { decrypt, encrypt };

package/dist/encryption/crypto.js

@@ -1,28 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encrypt = encrypt;
-exports.decrypt = decrypt;
-const crypto_1 = require("crypto");
-const CIPHER = 'AES-GCM';
+import { webcrypto } from "crypto";
+//#region src/encryption/crypto.ts
+const CIPHER = "AES-GCM";
 const IV_LENGTH_BYTES = 12;
 const TAG_LENGTH_BYTES = 16;
 async function encrypt(data, key) {
-    const iv = crypto_1.webcrypto.getRandomValues(new Uint8Array(IV_LENGTH_BYTES));
-    const encrypted = await crypto_1.webcrypto.subtle.encrypt({
-        name: CIPHER,
-        iv,
-        tagLength: TAG_LENGTH_BYTES * 8,
-    }, key, data);
-    return Buffer.concat([iv, new Uint8Array(encrypted)]);
+	const iv = webcrypto.getRandomValues(new Uint8Array(IV_LENGTH_BYTES));
+	const encrypted = await webcrypto.subtle.encrypt({
+		name: CIPHER,
+		iv,
+		tagLength: TAG_LENGTH_BYTES * 8
+	}, key, data);
+	return Buffer.concat([iv, new Uint8Array(encrypted)]);
 }
 async function decrypt(encryptedData, key) {
-    const iv = encryptedData.subarray(0, IV_LENGTH_BYTES);
-    const ciphertext = encryptedData.subarray(IV_LENGTH_BYTES);
-    const decrypted = await crypto_1.webcrypto.subtle.decrypt({
-        name: CIPHER,
-        iv,
-        tagLength: TAG_LENGTH_BYTES * 8,
-    }, key, ciphertext);
-    return new Uint8Array(decrypted);
+	const iv = encryptedData.subarray(0, IV_LENGTH_BYTES);
+	const ciphertext = encryptedData.subarray(IV_LENGTH_BYTES);
+	const decrypted = await webcrypto.subtle.decrypt({
+		name: CIPHER,
+		iv,
+		tagLength: TAG_LENGTH_BYTES * 8
+	}, key, ciphertext);
+	return new Uint8Array(decrypted);
 }
-//# sourceMappingURL=crypto.js.map
+//#endregion
+export { decrypt, encrypt };

package/dist/encryption/dataConverter.d.ts

@@ -0,0 +1,7 @@
+import { EnvService } from "@diia-inhouse/env";
+import { DataConverter } from "@temporalio/common";
+
+//#region src/encryption/dataConverter.d.ts
+declare function getDataConverter(keyId: string, envService: EnvService, refreshInterval?: number): Promise<DataConverter>;
+//#endregion
+export { getDataConverter };

package/dist/encryption/dataConverter.js

@@ -1,27 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDataConverter = getDataConverter;
-const env_1 = require("@diia-inhouse/env");
-const types_1 = require("@diia-inhouse/types");
-const encryptionCodec_1 = require("./encryptionCodec");
+import { EncryptionCodec } from "./encryptionCodec.js";
+import { EnvService } from "@diia-inhouse/env";
+import { DurationMs } from "@diia-inhouse/types";
+//#region src/encryption/dataConverter.ts
 let dataConverterPromise;
-const defaultRefreshInterval = types_1.DurationMs.Day;
+const defaultRefreshInterval = DurationMs.Day;
 async function getDataConverter(keyId, envService, refreshInterval) {
-    if (!dataConverterPromise) {
-        dataConverterPromise = createDataConverter(keyId, envService, refreshInterval);
-    }
-    return await dataConverterPromise;
+	if (!dataConverterPromise) dataConverterPromise = createDataConverter(keyId, envService, refreshInterval);
+	return await dataConverterPromise;
 }
 async function createDataConverter(keyId, envService, refreshInterval = defaultRefreshInterval) {
-    const vaultEnabled = env_1.EnvService.getVar('VAULT_ENABLED', 'boolean', false);
-    const codec = await encryptionCodec_1.EncryptionCodec.create(keyId, envService, { vaultEnabled });
-    if (vaultEnabled && refreshInterval > 0) {
-        setInterval(async () => {
-            await codec?.refreshDefaultKey();
-        }, refreshInterval);
-    }
-    return {
-        payloadCodecs: [codec],
-    };
+	const vaultEnabled = EnvService.getVar("VAULT_ENABLED", "boolean", false);
+	const codec = await EncryptionCodec.create(keyId, envService, { vaultEnabled });
+	if (vaultEnabled && refreshInterval > 0) setInterval(async () => {
+		await codec?.refreshDefaultKey();
+	}, refreshInterval);
+	return { payloadCodecs: [codec] };
 }
-//# sourceMappingURL=dataConverter.js.map
+//#endregion
+export { getDataConverter };

package/dist/encryption/encryptionCodec.d.ts

@@ -0,0 +1,31 @@
+import { EnvService } from "@diia-inhouse/env";
+import { Logger } from "@diia-inhouse/types";
+import { webcrypto } from "node:crypto";
+import { Payload, PayloadCodec } from "@temporalio/common";
+
+//#region src/encryption/encryptionCodec.d.ts
+declare class EncryptionCodec implements PayloadCodec {
+  private readonly keys;
+  private defaultKeyId;
+  private readonly envService;
+  private readonly logger;
+  private readonly batchSize;
+  private readonly encoding;
+  private readonly metadataEncryptionKeyId;
+  constructor(keys: Map<string, webcrypto.CryptoKey>, defaultKeyId: string, envService: EnvService, logger: Logger, options?: {
+    batchSize?: number;
+    vaultEnabled?: boolean;
+  });
+  static create(keyId: string, envService: EnvService, options: {
+    batchSize?: number;
+    vaultEnabled?: boolean;
+  }, logger?: Logger): Promise<EncryptionCodec>;
+  private static createCryptoKey;
+  refreshDefaultKey(): Promise<void>;
+  encode(payloads: Payload[]): Promise<Payload[]>;
+  decode(payloads: Payload[]): Promise<Payload[]>;
+  private processBatch;
+  private splitKeyId;
+}
+//#endregion
+export { EncryptionCodec };