cipher-kit 2.1.3 → 3.0.0

package/dist/export-FYHgb-8E.d.cts

@@ -1,572 +0,0 @@
-import { R as Result, e as CreateSecretKeyOptions, W as WebSecretKey, f as EncryptOptions, g as DecryptOptions, H as HashOptions, h as HashPasswordOptions, V as VerifyPasswordOptions, c as Encoding } from './validate-lkJAHCeJ.cjs';
-
-/**
- * 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` promise containing the derived `SecretKey` or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = await tryCreateSecretKey("my-secret");
- *
- * if (success) console.log(result); // SecretKey object
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryCreateSecretKey(secret: string, options?: CreateSecretKeyOptions): Promise<Result<{
-    result: WebSecretKey;
-}>>;
-/**
- * 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 A promise of the derived `SecretKey`.
- * @throws {Error} If key derivation fails.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret"); // SecretKey object
- * ```
- */
-declare function createSecretKey(secret: string, options?: CreateSecretKeyOptions): Promise<WebSecretKey>;
-/**
- * Safely encrypts a UTF-8 string using the provided `SecretKey` (non-throwing).
- *
- * Output format: "iv.cipherWithTag."
- *
- * ### 🍼 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` promise containing the encrypted string in the specified format or an error.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret");
- * const {result, error, success} = await tryEncrypt("Hello, World!", secretKey);
- *
- * if (success) console.log(result); // "iv.cipherWithTag." (Encrypted string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryEncrypt(data: string, secretKey: WebSecretKey, options?: EncryptOptions): Promise<Result<string>>;
-/**
- * Encrypts a UTF-8 string using the provided `SecretKey` (throwing).
- *
- * Output format: "iv.cipherWithTag."
- *
- * ### 🍼 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 promise with 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 = await createSecretKey("my-secret");
- * const encrypted = await encrypt("Hello, World!", secretKey); // "iv.cipherWithTag." (Encrypted string)
- * ```
- */
-declare function encrypt(data: string, secretKey: WebSecretKey, options?: EncryptOptions): Promise<string>;
-/**
- * Safely decrypts the input string using the provided `SecretKey` (non-throwing).
- *
- * Expects input in the format "iv.cipherWithTag." 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.cipherWithTag.".
- * @param secretKey - The `SecretKey` object used for decryption.
- * @param options.inputEncoding - The encoding format for the input ciphertext (default: `'base64url'`).
- * @returns A `Result` promise containing the decrypted UTF-8 string or an error.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret");
- * const encrypted = await encrypt("Hello, World!", secretKey);
- * const {result, error, success} = await tryDecrypt(encrypted, secretKey);
- *
- * if (success) console.log(result); // "Hello, World!"
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryDecrypt(encrypted: string, secretKey: WebSecretKey, options?: DecryptOptions): Promise<Result<string>>;
-/**
- * Decrypts the input string using the provided `SecretKey` (throwing).
- *
- * Expects input in the format "iv.cipherWithTag." 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.cipherWithTag.".
- * @param secretKey - The `SecretKey` object used for decryption.
- * @param options.inputEncoding - The encoding format for the input ciphertext (default: `'base64url'`).
- * @returns A promise with the decrypted UTF-8 string.
- * @throws {Error} If the input data or key is invalid, or if decryption fails.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret");
- * const encrypted = await encrypt("Hello, World!", secretKey);
- * const decrypted = await decrypt(encrypted, secretKey); // "Hello, World!"
- * ```
- */
-declare function decrypt(encrypted: string, secretKey: WebSecretKey, options?: DecryptOptions): Promise<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.cipherWithTag."
- *
- * ### 🍼 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` promise containing the encrypted string in the specified format or an error.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret");
- * const {result, error, success} = await tryEncryptObj({ a: 1 }, secretKey);
- *
- * if (success) console.log(result); // "iv.cipherWithTag." (Encrypted string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryEncryptObj<T extends object = Record<string, unknown>>(obj: T, secretKey: WebSecretKey, options?: EncryptOptions): Promise<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.cipherWithTag."
- *
- * ### 🍼 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 promise with 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 = await createSecretKey("my-secret");
- * const encrypted = await encryptObj({ a: 1 }, secretKey); // "iv.cipherWithTag." (Encrypted string)
- * ```
- */
-declare function encryptObj<T extends object = Record<string, unknown>>(obj: T, secretKey: WebSecretKey, options?: EncryptOptions): Promise<string>;
-/**
- * Safely decrypts an encrypted JSON string into a plain object (non-throwing).
- *
- * Expects input in the format `"iv.cipherWithTag."` 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.cipherWithTag."`).
- * @param secretKey - The `SecretKey` used for decryption.
- * @param options.inputEncoding - Input ciphertext encoding (default: `'base64url'`).
- * @returns A `Result` promise with the decrypted object on success, or an error.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret");
- * const encrypted = await encryptObj({ a: 1 }, secretKey);
- * const {result, error, success} = await tryDecryptObj<{ a: number }>(encrypted, secretKey);
- *
- * if (success) console.log(result); // { a: 1 }
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryDecryptObj<T extends object = Record<string, unknown>>(encrypted: string, secretKey: WebSecretKey, options?: DecryptOptions): Promise<Result<{
-    result: T;
-}>>;
-/**
- * Decrypts an encrypted JSON string into a plain object (throwing).
- *
- * Expects input in the format `"iv.cipherWithTag."` 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.cipherWithTag."`).
- * @param secretKey - The `SecretKey` used for decryption.
- * @param options.inputEncoding - Input ciphertext encoding (default: `'base64url'`).
- * @returns A promise with the decrypted object.
- * @throws {Error} If decryption or JSON parsing fails.
- *
- * @example
- * ```ts
- * const secretKey = await createSecretKey("my-secret");
- * const encrypted = await encryptObj({ a: 1 }, secretKey);
- * const obj = await decryptObj<{ a: number }>(encrypted, secretKey); // obj.a === 1
- * ```
- */
-declare function decryptObj<T extends object = Record<string, unknown>>(encrypted: string, secretKey: WebSecretKey, options?: DecryptOptions): Promise<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` promise with the hash string or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = await tryHash("my data");
- *
- * if (success) console.log(result); // "..." (Hashed string)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryHash(data: string, options?: HashOptions): Promise<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 A promise of the hashed string.
- * @throws {Error} If input is invalid or hashing fails.
- *
- * @example
- * ```ts
- * const hashed = await hash("my data"); // "..." (Hashed string)
- * ```
- */
-declare function hash(data: string, options?: HashOptions): Promise<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` promise with `{ result, salt }` or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = await tryHashPassword("my-password");
- *
- * if (success) console.log(result, salt); // "..." (hashed password), "..." (salt)
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryHashPassword(password: string, options?: HashPasswordOptions): Promise<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 A promise with `{ result, salt }` for storage.
- * @throws {Error} If inputs are invalid or hashing fails.
- *
- * @example
- * ```ts
- * const {result, salt} = await hashPassword("my-password"); // "..." (hashed password), "..." (salt)
- * ```
- */
-declare function hashPassword(password: string, options?: HashPasswordOptions): Promise<{
-    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 A promise of boolean, `true` if the password matches, otherwise `false`.
- *
- * @example
- * ```ts
- * const {result, salt} = await hashPassword("my-password");
- *
- * await verifyPassword("my-password", result, salt); // true
- * await verifyPassword("wrong-password", result, salt); // false
- * ```
- */
-declare function verifyPassword(password: string, hashedPassword: string, salt: string, options?: VerifyPasswordOptions): Promise<boolean>;
-/**
- * Safely converts a string to a `Uint8Array` 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: Uint8Array }` or an error.
- *
- * @example
- * ```ts
- * const {result, error, success} = tryConvertStrToBytes("Hello", "utf8");
- *
- * if (success) console.log(result); // Uint8Array([...])
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryConvertStrToBytes(data: string, inputEncoding?: Encoding): Result<{
-    result: Uint8Array<ArrayBuffer>;
-}>;
-/**
- * Converts a string to a `Uint8Array` 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 `Uint8Array` containing the bytes.
- * @throws {Error} If input is invalid or conversion fails.
- *
- * @example
- * ```ts
- * const bytes = convertStrToBytes("Hello", "utf8"); // Uint8Array([...])
- * ```
- */
-declare function convertStrToBytes(data: string, inputEncoding?: Encoding): Uint8Array<ArrayBuffer>;
-/**
- * Safely converts a `Uint8Array` or `ArrayBuffer` 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 `Uint8Array` or `ArrayBuffer` 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"); // Uint8Array([...])
- * const {result, error, success} = tryConvertBytesToStr(bytes, "utf8");
- *
- * if (success) console.log(result); // "Hello"
- * else console.error(error); // { message: "...", description: "..." }
- * ```
- */
-declare function tryConvertBytesToStr(data: Uint8Array | ArrayBuffer, outputEncoding?: Encoding): Result<string>;
-/**
- * Converts a `Uint8Array` or `ArrayBuffer` 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 `Uint8Array` or `ArrayBuffer` 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"); // Uint8Array([...])
- * const str = convertBytesToStr(bytes, "utf8"); // "Hello"
- * ```
- */
-declare function convertBytesToStr(data: Uint8Array | ArrayBuffer, 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 base64url = convertEncoding("Hello", "utf8", "base64url"); // "..." (Base64url encoded string)
- * ```
- */
-declare function convertEncoding(data: string, from: Encoding, to: Encoding): string;
-
-declare const webCryptoKit_convertBytesToStr: typeof convertBytesToStr;
-declare const webCryptoKit_convertEncoding: typeof convertEncoding;
-declare const webCryptoKit_convertStrToBytes: typeof convertStrToBytes;
-declare const webCryptoKit_createSecretKey: typeof createSecretKey;
-declare const webCryptoKit_decrypt: typeof decrypt;
-declare const webCryptoKit_decryptObj: typeof decryptObj;
-declare const webCryptoKit_encrypt: typeof encrypt;
-declare const webCryptoKit_encryptObj: typeof encryptObj;
-declare const webCryptoKit_generateUuid: typeof generateUuid;
-declare const webCryptoKit_hash: typeof hash;
-declare const webCryptoKit_hashPassword: typeof hashPassword;
-declare const webCryptoKit_tryConvertBytesToStr: typeof tryConvertBytesToStr;
-declare const webCryptoKit_tryConvertEncoding: typeof tryConvertEncoding;
-declare const webCryptoKit_tryConvertStrToBytes: typeof tryConvertStrToBytes;
-declare const webCryptoKit_tryCreateSecretKey: typeof tryCreateSecretKey;
-declare const webCryptoKit_tryDecrypt: typeof tryDecrypt;
-declare const webCryptoKit_tryDecryptObj: typeof tryDecryptObj;
-declare const webCryptoKit_tryEncrypt: typeof tryEncrypt;
-declare const webCryptoKit_tryEncryptObj: typeof tryEncryptObj;
-declare const webCryptoKit_tryGenerateUuid: typeof tryGenerateUuid;
-declare const webCryptoKit_tryHash: typeof tryHash;
-declare const webCryptoKit_tryHashPassword: typeof tryHashPassword;
-declare const webCryptoKit_verifyPassword: typeof verifyPassword;
-declare namespace webCryptoKit {
-  export { webCryptoKit_convertBytesToStr as convertBytesToStr, webCryptoKit_convertEncoding as convertEncoding, webCryptoKit_convertStrToBytes as convertStrToBytes, webCryptoKit_createSecretKey as createSecretKey, webCryptoKit_decrypt as decrypt, webCryptoKit_decryptObj as decryptObj, webCryptoKit_encrypt as encrypt, webCryptoKit_encryptObj as encryptObj, webCryptoKit_generateUuid as generateUuid, webCryptoKit_hash as hash, webCryptoKit_hashPassword as hashPassword, webCryptoKit_tryConvertBytesToStr as tryConvertBytesToStr, webCryptoKit_tryConvertEncoding as tryConvertEncoding, webCryptoKit_tryConvertStrToBytes as tryConvertStrToBytes, webCryptoKit_tryCreateSecretKey as tryCreateSecretKey, webCryptoKit_tryDecrypt as tryDecrypt, webCryptoKit_tryDecryptObj as tryDecryptObj, webCryptoKit_tryEncrypt as tryEncrypt, webCryptoKit_tryEncryptObj as tryEncryptObj, webCryptoKit_tryGenerateUuid as tryGenerateUuid, webCryptoKit_tryHash as tryHash, webCryptoKit_tryHashPassword as tryHashPassword, webCryptoKit_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, tryHashPassword as n, hashPassword as o, tryConvertStrToBytes as p, convertStrToBytes as q, tryConvertBytesToStr as r, convertBytesToStr as s, tryGenerateUuid as t, tryConvertEncoding as u, verifyPassword as v, webCryptoKit as w, convertEncoding as x };