cipher-kit 2.1.3 → 3.0.0

package/dist/export-BaM_OTFk.d.ts

@@ -1,573 +0,0 @@
-import { R as Result, e as CreateSecretKeyOptions, N as NodeSecretKey, f as EncryptOptions, g as DecryptOptions, H as HashOptions, h as HashPasswordOptions, V as VerifyPasswordOptions, c as Encoding } from './validate-lkJAHCeJ.js';
-import { Buffer } from 'node:buffer';
-
-/**
- * Safely generates a UUID (v4) (non-throwing).
- *
- * ### 🍼 Explain Like I'm Five
- * It's like giving your pet a name tag with a super random name made of numbers and letters.
- * The chance of two pets getting the same name tag is practically zero, and it's very hard to guess!
- *
- * @returns A `Result` containing the UUID string or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = tryGenerateUuid();
- *
- * if (success) console.log(result); // "..." (a UUID string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryGenerateUuid(): Result<string>;
-/**
- * Generates a UUID (v4) (throwing).
- *
- * ### 🍼 Explain Like I'm Five
- * It's like giving your pet a name tag with a super random name made of numbers and letters.
- * The chance of two pets getting the same name tag is practically zero, and it's very hard to guess!
- *
- * @returns A UUID string.
- * @throws {Error} If UUID generation fails.
- *
- * @example
- * ```ts
- * const uuid = generateUuid(); // "..." (a UUID string)
- * ```
- */
-declare function generateUuid(): string;
-/**
- * Safely derives a `SecretKey` from the provided string for encryption/decryption (non-throwing).
- *
- * Uses HKDF to derive a key from the input string.
- *
- * ### 🍼 Explain Like I'm Five
- * Imagine you want to create a special key for future use to lock your treasure box (data).
- * So, you stir in some secret ingredients (like salt and info) to make sure your key is one-of-a-kind.
- *
- * @param secret - The input string to derive the `SecretKey` from, must be at least 8 characters.
- * @param options.algorithm - The encryption algorithm to use (default: `'aes256gcm'`).
- * @param options.digest - The hash algorithm for HKDF (default: `'sha256'`).
- * @param options.salt - A salt string (default: `'cipher-kit-salt'`, must be ≥ 8 chars).
- * @param options.info - An info string (default: `'cipher-kit'`).
- * @returns A `Result` containing the derived `SecretKey` or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = tryCreateSecretKey("my-secret");
- *
- * if (success) console.log(result); // SecretKey object
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryCreateSecretKey(secret: string, options?: CreateSecretKeyOptions): Result<{
-    result: NodeSecretKey;
-}>;
-/**
- * Derives a `SecretKey` from the provided string for encryption/decryption (throwing).
- *
- * Uses HKDF to derive a key from the input string.
- *
- * ### 🍼 Explain Like I'm Five
- * Imagine you want to create a special key for future use to lock your treasure box (data).
- * So, you stir in some secret ingredients (like salt and info) to make sure your key is one-of-a-kind.
- *
- * @param secret - The input string to derive the `SecretKey` from, must be at least 8 characters.
- * @param options.algorithm - The encryption algorithm to use (default: `'aes256gcm'`).
- * @param options.digest - The hash algorithm for HKDF (default: `'sha256'`).
- * @param options.salt - A salt string (default: `'cipher-kit-salt'`, must be ≥ 8 chars).
- * @param options.info - An info string (default: `'cipher-kit'`).
- * @returns The derived `SecretKey`.
- * @throws {Error} If key derivation fails.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret"); // SecretKey object
- * ```
- */
-declare function createSecretKey(secret: string, options?: CreateSecretKeyOptions): NodeSecretKey;
-/**
- * Safely encrypts a UTF-8 string using the provided `SecretKey` (non-throwing).
- *
- * Output format: "iv.cipher.tag."
- *
- * ### 🍼 Explain Like I'm Five
- * You scramble a secret message with your special key,
- * creating a jumbled code that only someone with the right key can read.
- *
- * @param data - A UTF-8 string to encrypt.
- * @param secretKey - The `SecretKey` object used for encryption.
- * @param options.outputEncoding - The encoding format for the output ciphertext (default: `'base64url'`).
- * @returns A `Result` containing the encrypted string in the specified format or an error.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const {result, error, success} = tryEncrypt("Hello, World!", secretKey);
- *
- * if (success) console.log(result); // "iv.cipher.tag." (Encrypted string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryEncrypt(data: string, secretKey: NodeSecretKey, options?: EncryptOptions): Result<string>;
-/**
- * Encrypts a UTF-8 string using the provided `SecretKey` (throwing).
- *
- * Output format: "iv.cipher.tag."
- *
- * ### 🍼 Explain Like I'm Five
- * You scramble a secret message with your special key,
- * creating a jumbled code that only someone with the right key can read.
- *
- * @param data - A UTF-8 string to encrypt.
- * @param secretKey - The `SecretKey` object used for encryption.
- * @param options.outputEncoding - The encoding format for the output ciphertext (default: `'base64url'`).
- * @returns The encrypted string in the specified format.
- * @throws {Error} If the input data or key is invalid, or if encryption fails.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const encrypted = encrypt("Hello, World!", secretKey); // "iv.cipher.tag." (Encrypted string)
- * ```
- */
-declare function encrypt(data: string, secretKey: NodeSecretKey, options?: EncryptOptions): string;
-/**
- * Safely decrypts the input string using the provided `SecretKey` (non-throwing).
- *
- * Expects input in the format "iv.cipher.tag." and returns the decrypted UTF-8 string.
- *
- * ### 🍼 Explain Like I'm Five
- * You take a scrambled secret message and use your special key to unscramble it,
- * revealing the original message inside.
- *
- * @param encrypted - The input string to decrypt, in the format "iv.cipher.tag.".
- * @param secretKey - The `SecretKey` object used for decryption.
- * @param options.inputEncoding - The encoding format for the input ciphertext (default: `'base64url'`).
- * @returns A `Result` containing the decrypted UTF-8 string or an error.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const encrypted = encrypt("Hello, World!", secretKey);
- * const {result, error, success} = tryDecrypt(encrypted, secretKey);
- *
- * if (success) console.log(result); // "Hello, World!" (Decrypted string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryDecrypt(encrypted: string, secretKey: NodeSecretKey, options?: DecryptOptions): Result<string>;
-/**
- * Decrypts the input string using the provided `SecretKey` (throwing).
- *
- * Expects input in the format "iv.cipher.tag." and returns the decrypted UTF-8 string.
- *
- * ### 🍼 Explain Like I'm Five
- * You take a scrambled secret message and use your special key to unscramble it,
- * revealing the original message inside.
- *
- * @param encrypted - The input string to decrypt, in the format "iv.cipher.tag.".
- * @param secretKey - The `SecretKey` object used for decryption.
- * @param options.inputEncoding - The encoding format for the input ciphertext (default: `'base64url'`).
- * @returns The decrypted UTF-8 string.
- * @throws {Error} If the input data or key is invalid, or if decryption fails.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const encrypted = encrypt("Hello, World!", secretKey);
- * const decrypted = decrypt(encrypted, secretKey); // "Hello, World!" (Decrypted string)
- * ```
- */
-declare function decrypt(encrypted: string, secretKey: NodeSecretKey, options?: DecryptOptions): string;
-/**
- * Safely encrypts a plain object using the provided `SecretKey` (non-throwing).
- *
- * Only plain objects (POJOs) are accepted. Class instances, Maps, Sets, etc. are rejected.
- *
- * Output format: "iv.cipher.tag."
- *
- * ### 🍼 Explain Like I'm Five
- * Imagine you have a toy box (an object) that you want to keep secret.
- * So, you take a picture of your toy box (convert it to JSON), and scramble that with
- * your special key, creating a jumbled code that only someone with the right key can read.
- *
- * @template T - The type of the plain object to encrypt.
- * @param obj - A plain object to encrypt.
- * @param secretKey - The `SecretKey` object used for encryption.
- * @param options.outputEncoding - The encoding format for the output ciphertext (default: `'base64url'`).
- * @returns A `Result` containing the encrypted string in the specified format or an error.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const {result, error, success} = tryEncryptObj({ a: 1 }, secretKey);
- *
- * if (success) console.log(result); // "iv.cipher.tag." (Encrypted string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryEncryptObj<T extends object = Record<string, unknown>>(obj: T, secretKey: NodeSecretKey, options?: EncryptOptions): Result<string>;
-/**
- * Encrypts a plain object using the provided `SecretKey` (throwing).
- *
- * Only plain objects (POJOs) are accepted. Class instances, Maps, Sets, etc. are rejected.
- *
- * Output format: "iv.cipher.tag."
- *
- * ### 🍼 Explain Like I'm Five
- * Imagine you have a toy box (an object) that you want to keep secret.
- * So, you take a picture of your toy box (convert it to JSON), and scramble that with
- * your special key, creating a jumbled code that only someone with the right key can read.
- *
- * @template T - The type of the plain object to encrypt.
- * @param obj - A plain object to encrypt.
- * @param secretKey - The `SecretKey` object used for encryption.
- * @param options.outputEncoding - The encoding format for the output ciphertext (default: `'base64url'`).
- * @returns The encrypted string in the specified format.
- * @throws {Error} If the input data or key is invalid, or if encryption fails.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const encrypted = encryptObj({ a: 1 }, secretKey); // "iv.cipher.tag." (Encrypted string)
- * ```
- */
-declare function encryptObj<T extends object = Record<string, unknown>>(obj: T, secretKey: NodeSecretKey, options?: EncryptOptions): string;
-/**
- * Safely decrypts an encrypted JSON string into a plain object (non-throwing).
- *
- * Expects input in the format `"iv.cipher.tag."` and returns a plain object.
- *
- * ### 🍼 Explain Like I'm Five
- * You rebuild your toy box (an object) by unscrambling the jumbled code (encrypted text),
- * using your special key to open it.
- *
- * @template T - The expected shape of the decrypted object.
- * @param encrypted - The encrypted string (format: `"iv.cipher.tag."`).
- * @param secretKey - The `SecretKey` used for decryption.
- * @param options.inputEncoding - Input ciphertext encoding (default: `'base64url'`).
- * @returns A `Result` with the decrypted object on success, or an error.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const encrypted = encryptObj({ a: 1 }, secretKey);
- * const {result, error, success} = tryDecryptObj<{ a: number }>(encrypted, secretKey);
- *
- * if (success) console.log(result); // { a: 1 } (Decrypted object)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryDecryptObj<T extends object = Record<string, unknown>>(encrypted: string, secretKey: NodeSecretKey, options?: DecryptOptions): Result<{
-    result: T;
-}>;
-/**
- * Decrypts an encrypted JSON string into a plain object (throwing).
- *
- * Expects input in the format `"iv.cipher.tag."` and returns a plain object.
- *
- * ### 🍼 Explain Like I'm Five
- * You rebuild your toy box (an object) by unscrambling the jumbled code (encrypted text),
- * using your special key to open it.
- *
- * @template T - The expected shape of the decrypted object.
- * @param encrypted - The encrypted string (format: `"iv.cipher.tag."`).
- * @param secretKey - The `SecretKey` used for decryption.
- * @param options.inputEncoding - Input ciphertext encoding (default: `'base64url'`).
- * @returns The decrypted object.
- * @throws {Error} If decryption or JSON parsing fails.
- *
- * @example
- * ```ts
- * const secretKey = createSecretKey("my-secret");
- * const encrypted = encryptObj({ a: 1 }, secretKey);
- * const obj = decryptObj<{ a: number }>(encrypted, secretKey); // obj.a === 1
- * ```
- */
-declare function decryptObj<T extends object = Record<string, unknown>>(encrypted: string, secretKey: NodeSecretKey, options?: DecryptOptions): T;
-/**
- * Safely hashes a UTF-8 string (non-throwing).
- *
- * Uses the selected digest (default: `'sha256'`) and returns the hash
- * in the chosen encoding (default: `'base64url'`).
- *
- * ### 🍼 Explain Like I'm Five
- * Like putting something in a blender and getting a smoothie, you can’t get the original ingredients back,
- * but the smoothie is always the same if you use the same ingredients.
- *
- * @param data - The input string to hash.
- * @param options.digest - Hash algorithm (`'sha256' | 'sha384' | 'sha512'`, default: `'sha256'`).
- * @param options.outputEncoding - Output encoding (`'base64' | 'base64url' | 'hex'`, default: `'base64url'`).
- * @returns A `Result` with the hash string or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = tryHash("my data");
- *
- * if (success) console.log(result); // "..." (Hashed string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryHash(data: string, options?: HashOptions): Result<string>;
-/**
- * Hashes a UTF-8 string (throwing).
- *
- * Uses the selected digest (default: `'sha256'`) and returns the hash
- * in the chosen encoding (default: `'base64url'`).
- *
- * ### 🍼 Explain Like I'm Five
- * Like putting something in a blender and getting a smoothie, you can’t get the original ingredients back,
- * but the smoothie is always the same if you use the same ingredients.
- *
- * @param data - The input string to hash.
- * @param options.digest - Hash algorithm (`'sha256' | 'sha384' | 'sha512'`; default: `'sha256'`).
- * @param options.outputEncoding - Output encoding (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`).
- * @returns The hashed string.
- * @throws {Error} If input is invalid or hashing fails.
- *
- * @example
- * ```ts
- * const hash = hash("my data"); // "..." (Hashed string)
- * ```
- */
-declare function hash(data: string, options?: HashOptions): string;
-/**
- * Safely hashes a password using PBKDF2 (non-throwing).
- *
- * Uses strong defaults (`sha512`, 320k iterations, 64-byte key, 16-byte salt) and
- * returns `{ hash, salt }` encoded (default: `'base64url'`).
- *
- * ### 🍼 Explain Like I'm Five
- * We take your password, mix in some random salt, and stir many times.
- * The result is a super-secret soup that’s hard to copy.
- *
- * @param password - The password to hash.
- * @param options.digest - Hash algorithm (`'sha256' | 'sha384' | 'sha512'`; default: `'sha512'`).
- * @param options.outputEncoding - Output encoding (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`).
- * @param options.saltLength - Length of the random salt in bytes (default: `16` bytes, min: `8` bytes).
- * @param options.iterations - Number of iterations (default: `320000`, min: `1000`).
- * @param options.keyLength - Length of the derived key in bytes (default: `64` bytes, min: `16` bytes).
- * @returns A `Result` with `{ result, salt }` or an error.
- *
- * @example
- * ```ts
- * const {result, salt, error, success} = tryHashPassword("my-password");
- *
- * if (success) console.log(result, salt); // "..." (Hashed password string), "..." (salt)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryHashPassword(password: string, options?: HashPasswordOptions): Result<{
-    result: string;
-    salt: string;
-}>;
-/**
- * Hashes a password using PBKDF2 (throwing).
- *
- * Uses strong defaults (`sha512`, 320k iterations, 64-byte key, 16-byte salt) and
- * returns `{ hash, salt }` encoded (default: `'base64url'`).
- *
- * ### 🍼 Explain Like I'm Five
- * We take your password, mix in some random salt, and stir many times.
- * The result is a super-secret soup that’s hard to copy.
- *
- * @param password - The password to hash.
- * @param options.digest - Hash algorithm (`'sha256' | 'sha384' | 'sha512'`; default: `'sha512'`).
- * @param options.outputEncoding - Output encoding (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`).
- * @param options.saltLength - Length of the random salt in bytes (default: `16` bytes, min: `8` bytes).
- * @param options.iterations - Number of iterations (default: `320000`, min: `1000`).
- * @param options.keyLength - Length of the derived key in bytes (default: `64` bytes, min: `16` bytes).
- * @returns `{ result, salt }` for storage.
- * @throws {Error} If inputs are invalid or hashing fails.
- *
- * @example
- * ```ts
- * const { result, salt } = hashPassword("my-password"); // "..." (Hashed password string), "..." (salt)
- * ```
- */
-declare function hashPassword(password: string, options?: HashPasswordOptions): {
-    result: string;
-    salt: string;
-};
-/**
- * Verifies a password against a stored PBKDF2 hash (non-throwing).
- *
- * Re-derives the key using the same parameters and compares in constant time, to prevent timing attacks.
- *
- * ### 🍼 Explain Like I'm Five
- * We follow the same recipe as when we made the secret.
- * If the new soup tastes exactly the same, the password is correct.
- *
- * @param password - The plain password to verify.
- * @param hashedPassword - The stored hash (encoded).
- * @param salt - The stored salt (encoded).
- * @param options.digest - Hash algorithm used during hashing (`'sha256' | 'sha384' | 'sha512'`; default: `'sha512'`).
- * @param options.inputEncoding - Encoding of the stored hash and salt (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`).
- * @param options.iterations - Number of iterations used during hashing (default: `320000`).
- * @param options.keyLength - Length of the derived key in bytes used during hashing (default: `64` bytes).
- * @returns `true` if the password matches, otherwise `false`.
- *
- * @example
- * ```ts
- * const { result, salt } = hashPassword("my-password");
- *
- * verifyPassword("my-password", result, salt); // true
- * verifyPassword("wrong-password", result, salt); // false
- * ```
- */
-declare function verifyPassword(password: string, hashedPassword: string, salt: string, options?: VerifyPasswordOptions): boolean;
-/**
- * Safely converts a string to a Node.js `Buffer` using the specified encoding (non-throwing).
- *
- * Supported encodings: `'base64' | 'base64url' | 'hex' | 'utf8' | 'latin1'` (default: `'utf8'`).
- *
- * ### 🍼 Explain Like I'm Five
- * This turns your words into tiny computer building blocks (bytes) so computers can work with them.
- *
- * @param data - The input string to convert.
- * @param inputEncoding - The encoding of the input string (default: `'utf8'`).
- * @returns A `Result` with `{ result: Buffer }` or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = tryConvertStrToBytes("Hello", "utf8");
- *
- * if (success) console.log(result); // <Buffer ...>
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryConvertStrToBytes(data: string, inputEncoding?: Encoding): Result<{
-    result: Buffer;
-}>;
-/**
- * Converts a string to a Node.js `Buffer` using the specified encoding (throwing).
- *
- * Supported encodings: `'base64' | 'base64url' | 'hex' | 'utf8' | 'latin1'` (default: `'utf8'`).
- *
- * ### 🍼 Explain Like I'm Five
- * This turns your words into tiny computer building blocks (bytes) so computers can work with them.
- *
- * @param data - The input string to convert.
- * @param inputEncoding - The encoding of the input string (default: `'utf8'`).
- * @returns A `Buffer` containing the bytes.
- * @throws {Error} If input is invalid or conversion fails.
- *
- * @example
- * ```ts
- * const bytes = convertStrToBytes("Hello", "utf8"); // <Buffer ...>
- * ```
- */
-declare function convertStrToBytes(data: string, inputEncoding?: Encoding): Buffer;
-/**
- * Safely converts a Node.js `Buffer` to a string using the specified encoding (non-throwing).
- *
- * Supported encodings: `'base64' | 'base64url' | 'hex' | 'utf8' | 'latin1'` (default: `'utf8'`).
- *
- * ### 🍼 Explain Like I'm Five
- * This turns the tiny computer building blocks (bytes) back into a readable sentence.
- *
- * @param data - The `Buffer` to convert.
- * @param outputEncoding - The output encoding (default: `'utf8'`).
- * @returns A `Result` with the string or an error.
- *
- * @example
- * ```ts
- * const bytes = convertStrToBytes("Hello", "utf8"); // <Buffer ...>
- * const {result, error, success} = tryConvertBytesToStr(bytes, "utf8");
- *
- * if (success) console.log(result); // "Hello"
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryConvertBytesToStr(data: Buffer, outputEncoding?: Encoding): Result<string>;
-/**
- * Converts a Node.js `Buffer` to a string using the specified encoding (throwing).
- *
- * Supported encodings: `'base64' | 'base64url' | 'hex' | 'utf8' | 'latin1'` (default: `'utf8'`).
- *
- * ### 🍼 Explain Like I'm Five
- * This turns the tiny computer building blocks (bytes) back into a readable sentence.
- *
- * @param data - The `Buffer` to convert.
- * @param outputEncoding - The output encoding (default: `'utf8'`).
- * @returns The encoded string.
- * @throws {Error} If input is invalid or conversion fails.
- *
- * @example
- * ```ts
- * const bytes = convertStrToBytes("Hello", "utf8"); // <Buffer ...>
- * const str = convertBytesToStr(bytes, "utf8"); // "Hello"
- * ```
- */
-declare function convertBytesToStr(data: Buffer, outputEncoding?: Encoding): string;
-/**
- * Safely converts text between encodings (non-throwing).
- *
- * Example: convert `'utf8'` text to `'base64url'`, or `'hex'` to `'utf8'`.
- *
- * ### 🍼 Explain Like I'm Five
- * It’s like translating your sentence from one alphabet to another.
- *
- * @param data - The input string to convert.
- * @param from - The current encoding of `data`.
- * @param to - The target encoding for `data`.
- * @returns A `Result` with a string or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = tryConvertEncoding("Hello", "utf8", "base64url");
- *
- * if (success) console.log(result); // "..." (Base64url encoded string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryConvertEncoding(data: string, from: Encoding, to: Encoding): Result<string>;
-/**
- * Converts text between encodings (throwing).
- *
- * Example: convert `'utf8'` text to `'base64url'`, or `'hex'` to `'utf8'`.
- *
- * ### 🍼 Explain Like I'm Five
- * It’s like translating your sentence from one alphabet to another.
- *
- * @param data - The input string to convert.
- * @param from - The current encoding of `data`.
- * @param to - The target encoding for `data`.
- * @returns The converted string.
- * @throws {Error} If encodings are invalid or conversion fails.
- *
- * @example
- * ```ts
- * const encoded = convertEncoding("Hello", "utf8", "base64url"); // "..." (Base64url encoded string)
- * ```
- */
-declare function convertEncoding(data: string, from: Encoding, to: Encoding): string;
-
-declare const nodeCryptoKit_convertBytesToStr: typeof convertBytesToStr;
-declare const nodeCryptoKit_convertEncoding: typeof convertEncoding;
-declare const nodeCryptoKit_convertStrToBytes: typeof convertStrToBytes;
-declare const nodeCryptoKit_createSecretKey: typeof createSecretKey;
-declare const nodeCryptoKit_decrypt: typeof decrypt;
-declare const nodeCryptoKit_decryptObj: typeof decryptObj;
-declare const nodeCryptoKit_encrypt: typeof encrypt;
-declare const nodeCryptoKit_encryptObj: typeof encryptObj;
-declare const nodeCryptoKit_generateUuid: typeof generateUuid;
-declare const nodeCryptoKit_hash: typeof hash;
-declare const nodeCryptoKit_hashPassword: typeof hashPassword;
-declare const nodeCryptoKit_tryConvertBytesToStr: typeof tryConvertBytesToStr;
-declare const nodeCryptoKit_tryConvertEncoding: typeof tryConvertEncoding;
-declare const nodeCryptoKit_tryConvertStrToBytes: typeof tryConvertStrToBytes;
-declare const nodeCryptoKit_tryCreateSecretKey: typeof tryCreateSecretKey;
-declare const nodeCryptoKit_tryDecrypt: typeof tryDecrypt;
-declare const nodeCryptoKit_tryDecryptObj: typeof tryDecryptObj;
-declare const nodeCryptoKit_tryEncrypt: typeof tryEncrypt;
-declare const nodeCryptoKit_tryEncryptObj: typeof tryEncryptObj;
-declare const nodeCryptoKit_tryGenerateUuid: typeof tryGenerateUuid;
-declare const nodeCryptoKit_tryHash: typeof tryHash;
-declare const nodeCryptoKit_tryHashPassword: typeof tryHashPassword;
-declare const nodeCryptoKit_verifyPassword: typeof verifyPassword;
-declare namespace nodeCryptoKit {
-  export { nodeCryptoKit_convertBytesToStr as convertBytesToStr, nodeCryptoKit_convertEncoding as convertEncoding, nodeCryptoKit_convertStrToBytes as convertStrToBytes, nodeCryptoKit_createSecretKey as createSecretKey, nodeCryptoKit_decrypt as decrypt, nodeCryptoKit_decryptObj as decryptObj, nodeCryptoKit_encrypt as encrypt, nodeCryptoKit_encryptObj as encryptObj, nodeCryptoKit_generateUuid as generateUuid, nodeCryptoKit_hash as hash, nodeCryptoKit_hashPassword as hashPassword, nodeCryptoKit_tryConvertBytesToStr as tryConvertBytesToStr, nodeCryptoKit_tryConvertEncoding as tryConvertEncoding, nodeCryptoKit_tryConvertStrToBytes as tryConvertStrToBytes, nodeCryptoKit_tryCreateSecretKey as tryCreateSecretKey, nodeCryptoKit_tryDecrypt as tryDecrypt, nodeCryptoKit_tryDecryptObj as tryDecryptObj, nodeCryptoKit_tryEncrypt as tryEncrypt, nodeCryptoKit_tryEncryptObj as tryEncryptObj, nodeCryptoKit_tryGenerateUuid as tryGenerateUuid, nodeCryptoKit_tryHash as tryHash, nodeCryptoKit_tryHashPassword as tryHashPassword, nodeCryptoKit_verifyPassword as verifyPassword };
-}
-
-export { tryCreateSecretKey as a, tryEncrypt as b, createSecretKey as c, tryDecrypt as d, encrypt as e, decrypt as f, generateUuid as g, tryEncryptObj as h, encryptObj as i, tryDecryptObj as j, decryptObj as k, tryHash as l, hash as m, nodeCryptoKit as n, tryHashPassword as o, hashPassword as p, tryConvertStrToBytes as q, convertStrToBytes as r, tryConvertBytesToStr as s, tryGenerateUuid as t, convertBytesToStr as u, verifyPassword as v, tryConvertEncoding as w, convertEncoding as x };