@catbee/utils 2.0.0-next.0 → 2.0.0

package/context-store/index.cjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -231,8 +231,7 @@ var TypedContextKey = class {
   * @returns The value or defaultValue if not found
   */
   get() {
-    const value = ContextStore.get(this.symbol);
-    return value !== void 0 ? value : this.defaultValue;
+    return ContextStore.get(this.symbol) ?? this.defaultValue;
   }
   /**
   * Sets the value for this key.

package/context-store/index.d.ts

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,195 @@
  * SOFTWARE.
  */
 
-export * from './context-store.utils';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Type representing the store object used in AsyncLocalStorage.
+ * Keys must be unique symbols to ensure isolation and prevent collisions.
+ */
+interface Store {
+    [key: symbol]: unknown;
+}
+/**
+ * Predefined symbols used as keys in AsyncLocalStorage.
+ * Add new symbols here to avoid duplication.
+ */
+declare const StoreKeys: {
+    LOGGER: symbol;
+    REQUEST_ID: symbol;
+    USER: symbol;
+    SESSION: symbol;
+    TRANSACTION_ID: symbol;
+    USER_ID: symbol;
+    TENANT_ID: symbol;
+    TRACE_ID: symbol;
+    CORRELATION_ID: symbol;
+};
+/**
+ * Retrieves the current request ID from the async context, if available.
+ *
+ * @returns {string | undefined} The request ID string or undefined if not present in the current context.
+ */
+declare function getRequestId(): string | undefined;
+/**
+ * Type-safe getter for common context values.
+ *
+ * @param key The store key symbol
+ * @returns The typed value from the store
+ */
+declare function getFromContext<T>(key: symbol): T | undefined;
+/**
+ * ContextStore manages per-request scoped context using AsyncLocalStorage.
+ * It allows storing and retrieving data across async calls (e.g., request ID, logger).
+ *
+ * Example (Express middleware):
+ * ```
+ * // Middleware to initialize context and logger
+ * app.use((req, res, next) => {
+ *   const requestId = req.headers["x-request-id"]?.toString() || crypto.randomUUID();
+ *   ContextStore.run({ [StoreKeys.REQUEST_ID]: requestId }, () => {
+ *     ContextStore.set(StoreKeys.LOGGER, getLogger().child({ requestId }));
+ *     next();
+ *   });
+ * });
+ * ```
+ */
+declare class ContextStore {
+    /**
+     * The underlying AsyncLocalStorage instance for context.
+     * @private
+     */
+    private static readonly storage;
+    /**
+     * Returns the raw AsyncLocalStorage instance for advanced access.
+     *
+     * @returns {AsyncLocalStorage<Store>} The AsyncLocalStorage instance.
+     */
+    static getInstance(): AsyncLocalStorage<Store>;
+    /**
+     * Retrieves a value from the async context store by symbol key.
+     *
+     * @typeParam T - The expected return type of the value.
+     * @param {symbol} key - Unique symbol used as the store key.
+     * @returns {T | undefined} The value found (typed) or undefined if not present.
+     */
+    static get<T>(key: symbol): T | undefined;
+    /**
+     * Sets a value in the current context store by symbol key.
+     *
+     * @typeParam T - The value type to set.
+     * @param {symbol} key - Unique symbol key.
+     * @param {T} value - Value to set in context.
+     * @throws {Error} If called outside an active context (not within a .run call or in the wrong async boundaries).
+     */
+    static set<T>(key: symbol, value: T): void;
+    /**
+     * Retrieves the entire context store object for the current async context.
+     *
+     * @returns {Store | undefined} The current store object or undefined if called outside a context.
+     */
+    static getAll(): Store | undefined;
+    /**
+     * Initializes a new async context and executes a callback within it.
+     * This must be called at the beginning of a request or logical async flow.
+     *
+     * @typeParam T - The callback's return type.
+     * @param {Store} store - The initial key-value store object.
+     * @param {() => T} callback - The function to run within the new context.
+     * @returns {T} The result of the callback function.
+     */
+    static run<T>(store: Store, callback: () => T): T;
+    /**
+     * Checks if a key exists in the current context store.
+     *
+     * @param {symbol} key - The symbol key to check.
+     * @returns {boolean} True if the key exists, false otherwise.
+     */
+    static has(key: symbol): boolean;
+    /**
+     * Removes a value from the current context store by symbol key.
+     *
+     * @param {symbol} key - The symbol key to delete.
+     * @returns {boolean} True if the key was deleted, false if the key wasn't found or no active context.
+     * @throws {Error} If called outside an active context.
+     */
+    static delete(key: symbol): boolean;
+    /**
+     * Updates multiple values in the current context store at once.
+     *
+     * @param {Partial<Record<symbol, unknown>>} values - Object containing symbol keys and values to update.
+     * @throws {Error} If called outside an active context.
+     */
+    static patch(values: Partial<Record<symbol, unknown>>): void;
+    /**
+     * Executes a callback with a temporary store value that only exists during execution.
+     * Original store is restored after callback completes.
+     *
+     * @typeParam T - The callback's return type.
+     * @param {symbol} key - The symbol key to temporarily set.
+     * @param {unknown} value - The temporary value.
+     * @param {() => T} callback - The function to execute with the temporary value.
+     * @returns {T} The result of the callback function.
+     * @throws {Error} If called outside an active context.
+     */
+    static withValue<T>(key: symbol, value: unknown, callback: () => T): T;
+    /**
+     * Creates a new context that inherits values from the current context.
+     *
+     * @typeParam T - The callback's return type.
+     * @param {Partial<Record<symbol, unknown>>} newValues - New values to add to or override in the context.
+     * @param {() => T} callback - The function to execute in the new context.
+     * @returns {T} The result of the callback function.
+     */
+    static extend<T>(newValues: Partial<Record<symbol, unknown>>, callback: () => T): T;
+    /**
+     * Creates Express middleware that initializes a context for each request.
+     *
+     * @param {(req: any) => Partial<Record<symbol, unknown>>} initialValuesFactory - Function that returns initial context values.
+     * @returns Express middleware function.
+     */
+    static createExpressMiddleware(initialValuesFactory?: (req: any) => Partial<Record<symbol, unknown>>): (req: any, _res: any, next: any) => void;
+}
+/**
+ * Type-safe wrapper for accessing and modifying context values with specific types.
+ *
+ * @typeParam T - The value type.
+ */
+declare class TypedContextKey<T> {
+    private readonly symbol;
+    private readonly defaultValue?;
+    /**
+     * Creates a new typed context key.
+     *
+     * @param symbol - The unique symbol for this key
+     * @param defaultValue - Optional default value if key is not found
+     */
+    constructor(symbol: symbol, defaultValue?: T | undefined);
+    /**
+     * Gets the current value for this key.
+     *
+     * @returns The value or defaultValue if not found
+     */
+    get(): T | undefined;
+    /**
+     * Sets the value for this key.
+     *
+     * @param value The value to set
+     */
+    set(value: T): void;
+    /**
+     * Checks if this key exists in the context.
+     *
+     * @returns True if the key exists
+     */
+    exists(): boolean;
+    /**
+     * Deletes this key from the context.
+     *
+     * @returns True if the key was deleted
+     */
+    delete(): boolean;
+}
+
+export { ContextStore, StoreKeys, TypedContextKey, getFromContext, getRequestId };
+export type { Store };

package/context-store/index.mjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -229,8 +229,7 @@ var TypedContextKey = class {
   * @returns The value or defaultValue if not found
   */
   get() {
-    const value = ContextStore.get(this.symbol);
-    return value !== void 0 ? value : this.defaultValue;
+    return ContextStore.get(this.symbol) ?? this.defaultValue;
   }
   /**
   * Sets the value for this key.

package/crypto/index.cjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -30,6 +30,8 @@ var id = require('@catbee/utils/id');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var pbkdf2Async = util.promisify(crypto.pbkdf2);
+var scryptAsync = util.promisify(crypto.scrypt);
 function hmac(algorithm, input, secret, encoding = "hex") {
   return crypto.createHmac(algorithm, secret).update(input).digest(encoding);
 }
@@ -85,13 +87,13 @@ function safeCompare(a, b) {
   throw new Error("Cannot compare: inputs must be strings, Buffers, or Uint8Arrays");
 }
 __name(safeCompare, "safeCompare");
-var scryptAsync = util.promisify(crypto.scrypt);
 async function encrypt(data, key, options = {}) {
   const algorithm = options.algorithm || "aes-256-gcm";
   const inputEncoding = options.inputEncoding || "utf8";
   const outputEncoding = options.outputEncoding || "hex";
   const iv = crypto.randomBytes(16);
-  const derivedKey = typeof key === "string" ? await scryptAsync(key, iv.slice(0, 8), 32) : key;
+  const salt = crypto.randomBytes(8);
+  const derivedKey = typeof key === "string" ? await scryptAsync(key, salt, 32) : key;
   const cipher = crypto.createCipheriv(algorithm, derivedKey, iv);
   let ciphertext;
   if (typeof data === "string") {
@@ -109,7 +111,8 @@ async function encrypt(data, key, options = {}) {
     ciphertext,
     iv,
     authTag,
-    algorithm
+    algorithm,
+    salt
   };
 }
 __name(encrypt, "encrypt");
@@ -117,7 +120,7 @@ async function decrypt(encryptedData, key, options = {}) {
   const algorithm = options.algorithm || encryptedData.algorithm || "aes-256-gcm";
   const inputEncoding = options.inputEncoding || "hex";
   const outputEncoding = options.outputEncoding || "utf8";
-  const derivedKey = typeof key === "string" ? await scryptAsync(key, encryptedData.iv.slice(0, 8), 32) : key;
+  const derivedKey = typeof key === "string" ? await scryptAsync(key, encryptedData.salt, 32) : key;
   const decipher = crypto.createDecipheriv(algorithm, derivedKey, encryptedData.iv);
   if (encryptedData.authTag && algorithm.includes("gcm")) {
     decipher.setAuthTag(encryptedData.authTag);
@@ -164,19 +167,66 @@ function verifySignedToken(token, secret) {
   }
 }
 __name(verifySignedToken, "verifySignedToken");
+async function pbkdf2Hash(password, salt, keyLength = 32, iterations = 31e4) {
+  return pbkdf2Async(password, salt, iterations, keyLength, "sha256");
+}
+__name(pbkdf2Hash, "pbkdf2Hash");
+function generateNonce(byteLength = 16, encoding = "hex") {
+  return crypto.randomBytes(byteLength).toString(encoding);
+}
+__name(generateNonce, "generateNonce");
+function secureRandomInt(min, max) {
+  if (min > max) throw new Error("min must be less than or equal to max");
+  const range = max - min + 1;
+  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
+  const maxValid = Math.floor(256 ** bytesNeeded / range) * range;
+  let randomValue;
+  do {
+    const bytes = crypto.randomBytes(bytesNeeded);
+    randomValue = bytes.reduce((acc, byte, i) => acc + byte * 256 ** i, 0);
+  } while (randomValue >= maxValid);
+  return min + randomValue % range;
+}
+__name(secureRandomInt, "secureRandomInt");
+async function hashPassword(password, saltLength = 16, keyLength = 32) {
+  const salt = crypto.randomBytes(saltLength);
+  const scryptAsync2 = util.promisify(crypto.scrypt);
+  const derivedKey = await scryptAsync2(password, salt, keyLength);
+  return `${salt.toString("base64")}:${derivedKey.toString("base64")}`;
+}
+__name(hashPassword, "hashPassword");
+async function verifyPassword(password, hash2) {
+  try {
+    const [saltB64, keyB64] = hash2.split(":");
+    if (!saltB64 || !keyB64) return false;
+    const salt = Buffer.from(saltB64, "base64");
+    const key = Buffer.from(keyB64, "base64");
+    const scryptAsync2 = util.promisify(crypto.scrypt);
+    const derivedKey = await scryptAsync2(password, salt, key.length);
+    return crypto.timingSafeEqual(key, derivedKey);
+  } catch {
+    return false;
+  }
+}
+__name(verifyPassword, "verifyPassword");
 
 exports.createSignedToken = createSignedToken;
 exports.decrypt = decrypt;
 exports.encrypt = encrypt;
 exports.generateApiKey = generateApiKey;
+exports.generateNonce = generateNonce;
 exports.generateRandomBytes = generateRandomBytes;
 exports.generateRandomBytesAsString = generateRandomBytesAsString;
 exports.hash = hash;
+exports.hashPassword = hashPassword;
 exports.hmac = hmac;
 exports.md5 = md5;
+exports.pbkdf2Hash = pbkdf2Hash;
 exports.randomString = randomString;
 exports.safeCompare = safeCompare;
+exports.secureRandomInt = secureRandomInt;
 exports.sha1 = sha1;
 exports.sha256 = sha256;
 exports.sha256Hmac = sha256Hmac;
+exports.verifyPassword = verifyPassword;
 exports.verifySignedToken = verifySignedToken;

package/crypto/index.d.ts

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,227 @@
  * SOFTWARE.
  */
 
-export * from './crypto.utils';
+import { BinaryToTextEncoding, CipherGCMTypes } from 'node:crypto';
+
+type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'utf-16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
+/**
+ * Generates an HMAC digest using the specified algorithm and secret key.
+ *
+ * @param {string} algorithm - The hashing algorithm (e.g., 'sha256', 'sha1').
+ * @param {string} input - The string to hash.
+ * @param {string} secret - The secret key for HMAC.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding ('hex', 'base64', etc).
+ * @returns {string} HMAC digest as a string.
+ */
+declare function hmac(algorithm: string, input: string, secret: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a hash digest using the specified algorithm.
+ *
+ * @param {string} algorithm - The hashing algorithm (e.g., 'sha256', 'md5').
+ * @param {string} input - The string to hash.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding ('hex', 'base64', etc).
+ * @returns {string} Hash digest as a string.
+ */
+declare function hash(algorithm: string, input: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates an HMAC-SHA256 digest.
+ *
+ * @param {string} input - The string to hash.
+ * @param {string} secret - The secret key.
+ * @returns {string} SHA-256 HMAC digest as a string.
+ */
+declare function sha256Hmac(input: string, secret: string): string;
+/**
+ * Generates a SHA1 hash digest.
+ *
+ * @param {string} input - The string to hash.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} SHA-1 hash as a string.
+ */
+declare function sha1(input: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a SHA256 hash digest.
+ *
+ * @param {string} input - The string to hash.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} SHA-256 hash as a string.
+ */
+declare function sha256(input: string, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates an MD5 hash digest.
+ *
+ * @param {string} input - The string to hash.
+ * @returns {string} MD5 hash as a string.
+ */
+declare function md5(input: string): string;
+/**
+ * Generates a cryptographically strong random string by hashing a random UUID with SHA-256.
+ *
+ * @returns {string} Random string hashed with SHA-256 (hex encoding).
+ */
+declare function randomString(): string;
+/**
+ * Generates a secure random buffer of specified byte length.
+ *
+ * @param {number} [byteLength=32] - Number of random bytes to generate.
+ * @returns {Buffer} Buffer containing random bytes.
+ */
+declare function generateRandomBytes(byteLength?: number): Buffer;
+/**
+ * Generates a secure random string of specified byte length with specified encoding.
+ *
+ * @param {number} [byteLength=32] - Number of random bytes to generate.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} Random string in specified encoding.
+ */
+declare function generateRandomBytesAsString(byteLength?: number, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a secure API key with a specified format.
+ *
+ * @param {string} [prefix=''] - Optional prefix for the key.
+ * @param {number} [byteLength=24] - Number of random bytes to generate.
+ * @returns {string} Formatted API key.
+ */
+declare function generateApiKey(prefix?: string, byteLength?: number): string;
+/**
+ * Compares two strings, arrays, or buffers in constant time to prevent timing attacks.
+ *
+ * @param {string | Buffer | Uint8Array} a - First value to compare
+ * @param {string | Buffer | Uint8Array} b - Second value to compare
+ * @returns {boolean} True if values are equal
+ */
+declare function safeCompare(a: string | Buffer | Uint8Array, b: string | Buffer | Uint8Array): boolean;
+/**
+ * Interface for encryption options
+ */
+interface EncryptionOptions {
+    /** Algorithm to use (default: aes-256-gcm) */
+    algorithm?: CipherGCMTypes;
+    /** Input encoding for plaintext if string (default: utf8) */
+    inputEncoding?: BufferEncoding;
+    /** Output encoding for ciphertext (default: hex) */
+    outputEncoding?: BinaryToTextEncoding;
+}
+/**
+ * Interface for decryption options
+ */
+interface DecryptionOptions {
+    /** Algorithm to use (default: aes-256-gcm) */
+    algorithm?: CipherGCMTypes;
+    /** Input encoding for ciphertext if string (default: hex) */
+    inputEncoding?: BinaryToTextEncoding;
+    /** Output encoding for plaintext (default: utf8) */
+    outputEncoding?: BufferEncoding;
+}
+/**
+ * Result of encryption operation including all data needed for decryption
+ */
+interface EncryptionResult {
+    /** Encrypted data (string or Buffer based on options) */
+    ciphertext: string | Buffer;
+    /** Initialization vector */
+    iv: Buffer;
+    /** Authentication tag (for GCM mode) */
+    authTag?: Buffer;
+    /** Algorithm used */
+    algorithm: string;
+    /** Salt used for key derivation */
+    salt: Buffer;
+}
+/**
+ * Encrypts data using a symmetric key with secure defaults (AES-256-GCM).
+ *
+ * @param {string | Buffer} data - Data to encrypt
+ * @param {string | Buffer} key - Encryption key or passphrase
+ * @param {EncryptionOptions} [options] - Encryption options
+ * @returns {Promise<EncryptionResult>} Encrypted data with metadata
+ */
+declare function encrypt(data: string | Buffer, key: string | Buffer, options?: EncryptionOptions): Promise<EncryptionResult>;
+/**
+ * Decrypts data that was encrypted with the encrypt function.
+ *
+ * @param {EncryptionResult} encryptedData - The encrypted data and metadata
+ * @param {string | Buffer} key - Decryption key or passphrase
+ * @param {DecryptionOptions} [options] - Decryption options
+ * @returns {Promise<string | Buffer>} Decrypted data
+ */
+declare function decrypt(encryptedData: EncryptionResult, key: string | Buffer, options?: DecryptionOptions): Promise<string | Buffer>;
+/**
+ * Creates a signed token with an expiration time and payload.
+ *
+ * @param {object} payload - Data to include in the token
+ * @param {string} secret - Secret key for signing
+ * @param {number} [expiresInSeconds=3600] - Token expiration in seconds
+ * @returns {string} Signed token string
+ */
+declare function createSignedToken(payload: Record<string, any>, secret: string, expiresInSeconds?: number): string;
+/**
+ * Verifies and decodes a signed token.
+ *
+ * @param {string} token - The token to verify
+ * @param {string} secret - Secret key for verification
+ * @returns {object | null} Decoded payload if valid, null if invalid
+ */
+declare function verifySignedToken(token: string, secret: string): Record<string, any> | null;
+/**
+ * Derives a cryptographic key using PBKDF2 (SHA-256).
+ *
+ * @param password - Password to derive key from
+ * @param salt - Cryptographic salt (use unique per password)
+ * @param keyLength - Output key length in bytes (default 32)
+ * @param iterations - Number of hashing iterations (default 310000, OWASP recommended)
+ * @returns Derived key as Buffer
+ *
+ * @example
+ * const key = await pbkdf2Hash('myPassword', 'mySalt');
+ */
+declare function pbkdf2Hash(password: string, salt: string | Buffer, keyLength?: number, iterations?: number): Promise<Buffer>;
+/**
+ * Generates a cryptographically secure nonce (number used once).
+ *
+ * @param {number} [byteLength=16] - Length of nonce in bytes.
+ * @param {BinaryToTextEncoding} [encoding='hex'] - Output encoding.
+ * @returns {string} Nonce string.
+ *
+ * @example
+ * const nonce = generateNonce(16, 'base64'); // Random nonce
+ */
+declare function generateNonce(byteLength?: number, encoding?: BinaryToTextEncoding): string;
+/**
+ * Generates a cryptographically secure random integer in a range.
+ *
+ * @param {number} min - Minimum value (inclusive).
+ * @param {number} max - Maximum value (inclusive).
+ * @returns {number} Random integer.
+ *
+ * @example
+ * const random = secureRandomInt(1, 100); // Random number 1-100
+ */
+declare function secureRandomInt(min: number, max: number): number;
+/**
+ * Hashes a password using scrypt (memory-hard function).
+ *
+ * @param {string} password - The password to hash.
+ * @param {number} [saltLength=16] - Length of salt in bytes.
+ * @param {number} [keyLength=32] - Length of derived key.
+ * @returns {Promise<string>} Hash string containing salt and key.
+ *
+ * @example
+ * const hash = await hashPassword('myPassword');
+ * // Returns format: salt:hash (both base64)
+ */
+declare function hashPassword(password: string, saltLength?: number, keyLength?: number): Promise<string>;
+/**
+ * Verifies a password against a scrypt hash.
+ *
+ * @param {string} password - The password to verify.
+ * @param {string} hash - The hash to verify against (from hashPassword).
+ * @returns {Promise<boolean>} True if password matches.
+ *
+ * @example
+ * const isValid = await verifyPassword('myPassword', storedHash);
+ */
+declare function verifyPassword(password: string, hash: string): Promise<boolean>;
+
+export { createSignedToken, decrypt, encrypt, generateApiKey, generateNonce, generateRandomBytes, generateRandomBytesAsString, hash, hashPassword, hmac, md5, pbkdf2Hash, randomString, safeCompare, secureRandomInt, sha1, sha256, sha256Hmac, verifyPassword, verifySignedToken };
+export type { BufferEncoding, DecryptionOptions, EncryptionOptions, EncryptionResult };