internxt-crypto 0.0.13 → 1.0.0

package/dist/email-crypto.d.mts

@@ -1,35 +1,33 @@
-import { Email, EmailKeys, EmailPublicParameters, HybridEncryptedEmail, PrivateKeys, PublicKeys, PwdProtectedEmail, User, UserWithPublicKeys } from "./types.mjs";
+import { EmailBody, HybridEncryptedEmail, HybridKeyPair, PwdProtectedEmail, RecipientWithPublicKey } from "./types.mjs";
 
 //#region src/email-crypto/hybridEncyptedEmail.d.ts
 /**
- * Encrypts the email using hybrid encryption.
+ * Encrypts the email body using hybrid encryption.
  *
- * @param email - The email to encrypt.
+ * @param body - The email body to encrypt.
  * @param recipientPublicKeys - The public keys of the recipient.
- * @param senderPrivateKey - The private key of the sender.
- * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
- * @returns The encrypted email
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The encrypted email body
  */
-declare function encryptEmailHybrid(email: Email, recipient: UserWithPublicKeys, senderPrivateKey: PrivateKeys, isSubjectEncrypted?: boolean): Promise<HybridEncryptedEmail>;
+declare function encryptEmailHybrid(body: EmailBody, recipient: RecipientWithPublicKey, aux?: Uint8Array): Promise<HybridEncryptedEmail>;
 /**
- * Encrypts the email using hybrid encryption for multiple recipients.
+ * Encrypts the email body using hybrid encryption for multiple recipients.
  *
- * @param email - The email to encrypt.
+ * @param body - The email body to encrypt for multiple recipients.
  * @param recipients - The recipients with corresponding public keys.
- * @param senderPrivateKey - The private key of the sender.
- * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
- * @returns The set of encrypted email
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The set of encrypted email bodies
  */
-declare function encryptEmailHybridForMultipleRecipients(email: Email, recipients: UserWithPublicKeys[], senderPrivateKey: PrivateKeys, isSubjectEncrypted?: boolean): Promise<HybridEncryptedEmail[]>;
+declare function encryptEmailHybridForMultipleRecipients(body: EmailBody, recipients: RecipientWithPublicKey[], aux?: Uint8Array): Promise<HybridEncryptedEmail[]>;
 /**
  * Decrypts the email using hybrid encryption.
  *
- * @param encryptedEmail - The encrypted email.
- * @param senderPublicKeys - The public key of the sender.
- * @param recipientPrivateKeys - The private key of the recipient.
- * @returns The decrypted email
+ * @param encEmailBody - The encrypted email.
+ * @param recipientPrivateHybridKeys - The private key of the recipient.
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The decrypted email body
  */
-declare function decryptEmailHybrid(encryptedEmail: HybridEncryptedEmail, senderPublicKeys: PublicKeys, recipientPrivateKeys: PrivateKeys): Promise<Email>;
+declare function decryptEmailHybrid(encEmailBody: HybridEncryptedEmail, recipientPrivateHybridKeys: Uint8Array, aux?: Uint8Array): Promise<EmailBody>;
 //#endregion
 //#region src/email-crypto/pwdProtectedEmail.d.ts
 /**
@@ -37,47 +35,27 @@ declare function decryptEmailHybrid(encryptedEmail: HybridEncryptedEmail, sender
  *
  * @param email - The email to password-protect
  * @param password - The secret password shared among recipients
- * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
  * @returns The password-protected email
  */
-declare function createPwdProtectedEmail(email: Email, password: string, isSubjectEncrypted?: boolean): Promise<PwdProtectedEmail>;
+declare function createPwdProtectedEmail(emailBody: EmailBody, password: string, aux?: Uint8Array): Promise<PwdProtectedEmail>;
 /**
  * Opens a password-protected email.
  *
  * @param encryptedEmail - The encrypted email
  * @param password - The secret password shared among recipients.
- * @returns The decrypted email
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The decrypted email body
  */
-declare function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string): Promise<Email>;
-//#endregion
-//#region src/email-crypto/converters.d.ts
-declare function userToBytes(user: User): Uint8Array;
-declare function recipientsToBytes(recipients: User[]): Uint8Array;
-/**
- * Converts an Email type into a Uint8Array array.
- *
- * @param email - The email.
- * @returns The Uint8Array array representation of the Email type.
- */
-declare function emailToBinary(email: Email): Uint8Array;
+declare function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string, aux?: Uint8Array): Promise<EmailBody>;
 //#endregion
 //#region src/email-crypto/emailKeys.d.ts
 /**
- * Generates public and private keys for email service.
+ * Generates public and private keys for email encryption.
  *
  * @returns The user's private and public keys
  */
-declare function generateEmailKeys(): Promise<EmailKeys>;
-//#endregion
-//#region src/email-crypto/utils.d.ts
-/**
- * Creates an auxiliary string from public fields of the email.
- *
- * @param params - The email public parameters.
- * @param isSubjectEncrypted - Indicates if the email subject field should be encrypted
- * @returns The resulting auxiliary string
- */
-declare function getAux(params: EmailPublicParameters, isSubjectEncrypted: boolean): Uint8Array;
+declare function generateEmailKeys(): Promise<HybridKeyPair>;
 //#endregion
-export { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, emailToBinary, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys, getAux, recipientsToBytes, userToBytes };
+export { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys };
 //# sourceMappingURL=email-crypto.d.mts.map

package/dist/email-crypto.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"email-crypto.d.mts","names":[],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/converters.ts","../src/email-crypto/emailKeys.ts","../src/email-crypto/utils.ts"],"mappings":";;;;;AAYA;;;;;;;iBAAsB,kBAAA,CACpB,KAAA,EAAO,KAAA,EACP,SAAA,EAAW,kBAAA,EACX,gBAAA,EAAkB,WAAA,EAClB,kBAAA,aACC,OAAA,CAAQ,oBAAA;;;;;;;;;;iBAmBW,uCAAA,CACpB,KAAA,EAAO,KAAA,EACP,UAAA,EAAY,kBAAA,IACZ,gBAAA,EAAkB,WAAA,EAClB,kBAAA,aACC,OAAA,CAAQ,oBAAA;;;;AALX;;;;;iBAmCsB,kBAAA,CACpB,cAAA,EAAgB,oBAAA,EAChB,gBAAA,EAAkB,UAAA,EAClB,oBAAA,EAAsB,WAAA,GACrB,OAAA,CAAQ,KAAA;;;;;AA/DX;;;;;;iBCDsB,uBAAA,CACpB,KAAA,EAAO,KAAA,EACP,QAAA,UACA,kBAAA,aACC,OAAA,CAAQ,iBAAA;;;;;;;;iBAqBW,wBAAA,CAAyB,cAAA,EAAgB,iBAAA,EAAmB,QAAA,WAAmB,OAAA,CAAQ,KAAA;;;iBChC7F,WAAA,CAAY,IAAA,EAAM,IAAA,GAAO,UAAA;AAAA,iBASzB,iBAAA,CAAkB,UAAA,EAAY,IAAA,KAAS,UAAA;AFDvD;;;;;;AAAA,iBEgBgB,aAAA,CAAc,KAAA,EAAO,KAAA,GAAQ,UAAA;;;;;AFhB7C;;;iBGHsB,iBAAA,CAAA,GAAqB,OAAA,CAAQ,SAAA;;;;;AHGnD;;;;;iBIAgB,MAAA,CAAO,MAAA,EAAQ,qBAAA,EAAuB,kBAAA,YAA8B,UAAA"}
+{"version":3,"file":"email-crypto.d.mts","names":[],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"mappings":";;;;;AAWA;;;;;;iBAAsB,kBAAA,CACpB,IAAA,EAAM,SAAA,EACN,SAAA,EAAW,sBAAA,EACX,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,oBAAA;;;;;;;;;iBAkBW,uCAAA,CACpB,IAAA,EAAM,SAAA,EACN,UAAA,EAAY,sBAAA,IACZ,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,oBAAA;;;;;AAJX;;;;iBA8BsB,kBAAA,CACpB,YAAA,EAAc,oBAAA,EACd,0BAAA,EAA4B,UAAA,EAC5B,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,SAAA;;;;;AAxDX;;;;;;iBCAsB,uBAAA,CACpB,SAAA,EAAW,SAAA,EACX,QAAA,UACA,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,iBAAA;;;;;;;;;iBAmBW,wBAAA,CACpB,cAAA,EAAgB,iBAAA,EAChB,QAAA,UACA,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,SAAA;;;;;AD3BX;;;iBEHsB,iBAAA,CAAA,GAAqB,OAAA,CAAQ,aAAA"}

package/dist/email-crypto.d.ts

@@ -1,35 +1,33 @@
-import { Email, EmailKeys, EmailPublicParameters, HybridEncryptedEmail, PrivateKeys, PublicKeys, PwdProtectedEmail, User, UserWithPublicKeys } from "./types.js";
+import { EmailBody, HybridEncryptedEmail, HybridKeyPair, PwdProtectedEmail, RecipientWithPublicKey } from "./types.js";
 
 //#region src/email-crypto/hybridEncyptedEmail.d.ts
 /**
- * Encrypts the email using hybrid encryption.
+ * Encrypts the email body using hybrid encryption.
  *
- * @param email - The email to encrypt.
+ * @param body - The email body to encrypt.
  * @param recipientPublicKeys - The public keys of the recipient.
- * @param senderPrivateKey - The private key of the sender.
- * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
- * @returns The encrypted email
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The encrypted email body
  */
-declare function encryptEmailHybrid(email: Email, recipient: UserWithPublicKeys, senderPrivateKey: PrivateKeys, isSubjectEncrypted?: boolean): Promise<HybridEncryptedEmail>;
+declare function encryptEmailHybrid(body: EmailBody, recipient: RecipientWithPublicKey, aux?: Uint8Array): Promise<HybridEncryptedEmail>;
 /**
- * Encrypts the email using hybrid encryption for multiple recipients.
+ * Encrypts the email body using hybrid encryption for multiple recipients.
  *
- * @param email - The email to encrypt.
+ * @param body - The email body to encrypt for multiple recipients.
  * @param recipients - The recipients with corresponding public keys.
- * @param senderPrivateKey - The private key of the sender.
- * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
- * @returns The set of encrypted email
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The set of encrypted email bodies
  */
-declare function encryptEmailHybridForMultipleRecipients(email: Email, recipients: UserWithPublicKeys[], senderPrivateKey: PrivateKeys, isSubjectEncrypted?: boolean): Promise<HybridEncryptedEmail[]>;
+declare function encryptEmailHybridForMultipleRecipients(body: EmailBody, recipients: RecipientWithPublicKey[], aux?: Uint8Array): Promise<HybridEncryptedEmail[]>;
 /**
  * Decrypts the email using hybrid encryption.
  *
- * @param encryptedEmail - The encrypted email.
- * @param senderPublicKeys - The public key of the sender.
- * @param recipientPrivateKeys - The private key of the recipient.
- * @returns The decrypted email
+ * @param encEmailBody - The encrypted email.
+ * @param recipientPrivateHybridKeys - The private key of the recipient.
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The decrypted email body
  */
-declare function decryptEmailHybrid(encryptedEmail: HybridEncryptedEmail, senderPublicKeys: PublicKeys, recipientPrivateKeys: PrivateKeys): Promise<Email>;
+declare function decryptEmailHybrid(encEmailBody: HybridEncryptedEmail, recipientPrivateHybridKeys: Uint8Array, aux?: Uint8Array): Promise<EmailBody>;
 //#endregion
 //#region src/email-crypto/pwdProtectedEmail.d.ts
 /**
@@ -37,47 +35,27 @@ declare function decryptEmailHybrid(encryptedEmail: HybridEncryptedEmail, sender
  *
  * @param email - The email to password-protect
  * @param password - The secret password shared among recipients
- * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
  * @returns The password-protected email
  */
-declare function createPwdProtectedEmail(email: Email, password: string, isSubjectEncrypted?: boolean): Promise<PwdProtectedEmail>;
+declare function createPwdProtectedEmail(emailBody: EmailBody, password: string, aux?: Uint8Array): Promise<PwdProtectedEmail>;
 /**
  * Opens a password-protected email.
  *
  * @param encryptedEmail - The encrypted email
  * @param password - The secret password shared among recipients.
- * @returns The decrypted email
+ * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+ * @returns The decrypted email body
  */
-declare function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string): Promise<Email>;
-//#endregion
-//#region src/email-crypto/converters.d.ts
-declare function userToBytes(user: User): Uint8Array;
-declare function recipientsToBytes(recipients: User[]): Uint8Array;
-/**
- * Converts an Email type into a Uint8Array array.
- *
- * @param email - The email.
- * @returns The Uint8Array array representation of the Email type.
- */
-declare function emailToBinary(email: Email): Uint8Array;
+declare function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string, aux?: Uint8Array): Promise<EmailBody>;
 //#endregion
 //#region src/email-crypto/emailKeys.d.ts
 /**
- * Generates public and private keys for email service.
+ * Generates public and private keys for email encryption.
  *
  * @returns The user's private and public keys
  */
-declare function generateEmailKeys(): Promise<EmailKeys>;
-//#endregion
-//#region src/email-crypto/utils.d.ts
-/**
- * Creates an auxiliary string from public fields of the email.
- *
- * @param params - The email public parameters.
- * @param isSubjectEncrypted - Indicates if the email subject field should be encrypted
- * @returns The resulting auxiliary string
- */
-declare function getAux(params: EmailPublicParameters, isSubjectEncrypted: boolean): Uint8Array;
+declare function generateEmailKeys(): Promise<HybridKeyPair>;
 //#endregion
-export { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, emailToBinary, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys, getAux, recipientsToBytes, userToBytes };
+export { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys };
 //# sourceMappingURL=email-crypto.d.ts.map

package/dist/email-crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"email-crypto.d.ts","names":[],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/converters.ts","../src/email-crypto/emailKeys.ts","../src/email-crypto/utils.ts"],"mappings":";;;;;AAYA;;;;;;;iBAAsB,kBAAA,CACpB,KAAA,EAAO,KAAA,EACP,SAAA,EAAW,kBAAA,EACX,gBAAA,EAAkB,WAAA,EAClB,kBAAA,aACC,OAAA,CAAQ,oBAAA;;;;;;;;;;iBAmBW,uCAAA,CACpB,KAAA,EAAO,KAAA,EACP,UAAA,EAAY,kBAAA,IACZ,gBAAA,EAAkB,WAAA,EAClB,kBAAA,aACC,OAAA,CAAQ,oBAAA;;;;AALX;;;;;iBAmCsB,kBAAA,CACpB,cAAA,EAAgB,oBAAA,EAChB,gBAAA,EAAkB,UAAA,EAClB,oBAAA,EAAsB,WAAA,GACrB,OAAA,CAAQ,KAAA;;;;;AA/DX;;;;;;iBCDsB,uBAAA,CACpB,KAAA,EAAO,KAAA,EACP,QAAA,UACA,kBAAA,aACC,OAAA,CAAQ,iBAAA;;;;;;;;iBAqBW,wBAAA,CAAyB,cAAA,EAAgB,iBAAA,EAAmB,QAAA,WAAmB,OAAA,CAAQ,KAAA;;;iBChC7F,WAAA,CAAY,IAAA,EAAM,IAAA,GAAO,UAAA;AAAA,iBASzB,iBAAA,CAAkB,UAAA,EAAY,IAAA,KAAS,UAAA;AFDvD;;;;;;AAAA,iBEgBgB,aAAA,CAAc,KAAA,EAAO,KAAA,GAAQ,UAAA;;;;;AFhB7C;;;iBGHsB,iBAAA,CAAA,GAAqB,OAAA,CAAQ,SAAA;;;;;AHGnD;;;;;iBIAgB,MAAA,CAAO,MAAA,EAAQ,qBAAA,EAAuB,kBAAA,YAA8B,UAAA"}
+{"version":3,"file":"email-crypto.d.ts","names":[],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"mappings":";;;;;AAWA;;;;;;iBAAsB,kBAAA,CACpB,IAAA,EAAM,SAAA,EACN,SAAA,EAAW,sBAAA,EACX,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,oBAAA;;;;;;;;;iBAkBW,uCAAA,CACpB,IAAA,EAAM,SAAA,EACN,UAAA,EAAY,sBAAA,IACZ,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,oBAAA;;;;;AAJX;;;;iBA8BsB,kBAAA,CACpB,YAAA,EAAc,oBAAA,EACd,0BAAA,EAA4B,UAAA,EAC5B,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,SAAA;;;;;AAxDX;;;;;;iBCAsB,uBAAA,CACpB,SAAA,EAAW,SAAA,EACX,QAAA,UACA,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,iBAAA;;;;;;;;;iBAmBW,wBAAA,CACpB,cAAA,EAAgB,iBAAA,EAChB,QAAA,UACA,GAAA,GAAM,UAAA,GACL,OAAA,CAAQ,SAAA;;;;;AD3BX;;;iBEHsB,iBAAA,CAAA,GAAqB,OAAA,CAAQ,aAAA"}

package/dist/email-crypto.js

@@ -1,13 +1,122 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_emailKeys = require('./emailKeys-BJGdkLrg.js');
-
-exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
-exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
-exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
-exports.emailToBinary = require_emailKeys.emailToBinary;
-exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
-exports.encryptEmailHybridForMultipleRecipients = require_emailKeys.encryptEmailHybridForMultipleRecipients;
-exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
-exports.getAux = require_emailKeys.getAux;
-exports.recipientsToBytes = require_emailKeys.recipientsToBytes;
-exports.userToBytes = require_emailKeys.userToBytes;
+const require_xwing = require('./xwing-iRWVRtNE.js');
+const require_core = require('./core-Bj26rNdA.js');
+
+//#region src/email-crypto/hybridEncyptedEmail.ts
+/**
+* Encrypts the email body using hybrid encryption.
+*
+* @param body - The email body to encrypt.
+* @param recipientPublicKeys - The public keys of the recipient.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The encrypted email body
+*/
+async function encryptEmailHybrid(body, recipient, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await require_core.encryptEmailBody(body, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await require_core.encryptKeysHybrid(encryptionKey, recipient)
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email body with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Encrypts the email body using hybrid encryption for multiple recipients.
+*
+* @param body - The email body to encrypt for multiple recipients.
+* @param recipients - The recipients with corresponding public keys.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The set of encrypted email bodies
+*/
+async function encryptEmailHybridForMultipleRecipients(body, recipients, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await require_core.encryptEmailBody(body, aux);
+		const encryptedEmails = [];
+		for (const recipient of recipients) {
+			const encryptedKey = await require_core.encryptKeysHybrid(encryptionKey, recipient);
+			encryptedEmails.push({
+				encEmailBody,
+				encryptedKey
+			});
+		}
+		return encryptedEmails;
+	} catch (error) {
+		throw new Error("Failed to encrypt email to multiple recipients with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Decrypts the email using hybrid encryption.
+*
+* @param encEmailBody - The encrypted email.
+* @param recipientPrivateHybridKeys - The private key of the recipient.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The decrypted email body
+*/
+async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux) {
+	try {
+		const encryptionKey = await require_core.decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);
+		return await require_core.decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt email with hybrid encryption", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/pwdProtectedEmail.ts
+/**
+* Creates a password-protected email.
+*
+* @param email - The email to password-protect
+* @param password - The secret password shared among recipients
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The password-protected email
+*/
+async function createPwdProtectedEmail(emailBody, password, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await require_core.encryptEmailBody(emailBody, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await require_core.passwordProtectKey(encryptionKey, password)
+		};
+	} catch (error) {
+		throw new Error("Failed to password-protect email", { cause: error });
+	}
+}
+/**
+* Opens a password-protected email.
+*
+* @param encryptedEmail - The encrypted email
+* @param password - The secret password shared among recipients.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The decrypted email body
+*/
+async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
+	try {
+		const encryptionKey = await require_core.removePasswordProtection(encryptedEmail.encryptedKey, password);
+		return await require_core.decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt password-protect email", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/emailKeys.ts
+/**
+* Generates public and private keys for email encryption.
+*
+* @returns The user's private and public keys
+*/
+async function generateEmailKeys() {
+	return require_xwing.genHybridKeys();
+}
+
+//#endregion
+exports.createPwdProtectedEmail = createPwdProtectedEmail;
+exports.decryptEmailHybrid = decryptEmailHybrid;
+exports.decryptPwdProtectedEmail = decryptPwdProtectedEmail;
+exports.encryptEmailHybrid = encryptEmailHybrid;
+exports.encryptEmailHybridForMultipleRecipients = encryptEmailHybridForMultipleRecipients;
+exports.generateEmailKeys = generateEmailKeys;
+//# sourceMappingURL=email-crypto.js.map

package/dist/email-crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-crypto.js","names":["encryptEmailBody","encryptKeysHybrid","decryptKeysHybrid","decryptEmailBody","encryptEmailBody","passwordProtectKey","removePasswordProtection","decryptEmailBody","genHybridKeys"],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n"],"mappings":";;;;;;;;;;;;;AAWA,eAAsB,mBACpB,MACA,WACA,KAC+B;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAMA,8BAAiB,MAAM,IAAI;AAEzE,SAAO;GAAE;GAAc,cADF,MAAMC,+BAAkB,eAAe,UAAU;GACjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,wCACpB,MACA,YACA,KACiC;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAMD,8BAAiB,MAAM,IAAI;EAEzE,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAMC,+BAAkB,eAAe,UAAU;AACtE,mBAAgB,KAAK;IACL;IACd;IACD,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,cACA,4BACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAMC,+BAAkB,aAAa,cAAc,2BAA2B;AAEpG,SADa,MAAMC,8BAAiB,aAAa,cAAc,eAAe,IAAI;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC9DvF,eAAsB,wBACpB,WACA,UACA,KAC4B;AAC5B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAMC,8BAAiB,WAAW,IAAI;AAG9E,SAAO;GAAE;GAAc,cAFF,MAAMC,gCAAmB,eAAe,SAAS;GAEjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYzE,eAAsB,yBACpB,gBACA,UACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAMC,sCAAyB,eAAe,cAAc,SAAS;AAE3F,SADa,MAAMC,8BAAiB,eAAe,cAAc,eAAe,IAAI;UAE7E,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACpCjF,eAAsB,oBAA4C;AAChE,QAAOC,6BAAe"}

package/dist/email-crypto.mjs

@@ -1,3 +1,116 @@
-import { a as encryptEmailHybrid, d as recipientsToBytes, f as userToBytes, i as decryptEmailHybrid, l as getAux, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, r as decryptPwdProtectedEmail, t as generateEmailKeys, u as emailToBinary } from "./emailKeys-Fp9WR3wl.mjs";
+import { r as genHybridKeys } from "./xwing-CQmQX6hn.mjs";
+import { a as encryptKeysHybrid, n as decryptKeysHybrid, o as passwordProtectKey, r as encryptEmailBody, s as removePasswordProtection, t as decryptEmailBody } from "./core-pEGygy6S.mjs";
 
-export { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, emailToBinary, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys, getAux, recipientsToBytes, userToBytes };
+//#region src/email-crypto/hybridEncyptedEmail.ts
+/**
+* Encrypts the email body using hybrid encryption.
+*
+* @param body - The email body to encrypt.
+* @param recipientPublicKeys - The public keys of the recipient.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The encrypted email body
+*/
+async function encryptEmailHybrid(body, recipient, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email body with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Encrypts the email body using hybrid encryption for multiple recipients.
+*
+* @param body - The email body to encrypt for multiple recipients.
+* @param recipients - The recipients with corresponding public keys.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The set of encrypted email bodies
+*/
+async function encryptEmailHybridForMultipleRecipients(body, recipients, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
+		const encryptedEmails = [];
+		for (const recipient of recipients) {
+			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
+			encryptedEmails.push({
+				encEmailBody,
+				encryptedKey
+			});
+		}
+		return encryptedEmails;
+	} catch (error) {
+		throw new Error("Failed to encrypt email to multiple recipients with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Decrypts the email using hybrid encryption.
+*
+* @param encEmailBody - The encrypted email.
+* @param recipientPrivateHybridKeys - The private key of the recipient.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The decrypted email body
+*/
+async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux) {
+	try {
+		const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);
+		return await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt email with hybrid encryption", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/pwdProtectedEmail.ts
+/**
+* Creates a password-protected email.
+*
+* @param email - The email to password-protect
+* @param password - The secret password shared among recipients
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The password-protected email
+*/
+async function createPwdProtectedEmail(emailBody, password, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await passwordProtectKey(encryptionKey, password)
+		};
+	} catch (error) {
+		throw new Error("Failed to password-protect email", { cause: error });
+	}
+}
+/**
+* Opens a password-protected email.
+*
+* @param encryptedEmail - The encrypted email
+* @param password - The secret password shared among recipients.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The decrypted email body
+*/
+async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
+	try {
+		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
+		return await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt password-protect email", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/emailKeys.ts
+/**
+* Generates public and private keys for email encryption.
+*
+* @returns The user's private and public keys
+*/
+async function generateEmailKeys() {
+	return genHybridKeys();
+}
+
+//#endregion
+export { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys };
+//# sourceMappingURL=email-crypto.mjs.map

package/dist/email-crypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-crypto.mjs","names":[],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n"],"mappings":";;;;;;;;;;;;AAWA,eAAsB,mBACpB,MACA,WACA,KAC+B;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;AAEzE,SAAO;GAAE;GAAc,cADF,MAAM,kBAAkB,eAAe,UAAU;GACjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,wCACpB,MACA,YACA,KACiC;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;EAEzE,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAM,kBAAkB,eAAe,UAAU;AACtE,mBAAgB,KAAK;IACL;IACd;IACD,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,cACA,4BACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,kBAAkB,aAAa,cAAc,2BAA2B;AAEpG,SADa,MAAM,iBAAiB,aAAa,cAAc,eAAe,IAAI;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC9DvF,eAAsB,wBACpB,WACA,UACA,KAC4B;AAC5B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,WAAW,IAAI;AAG9E,SAAO;GAAE;GAAc,cAFF,MAAM,mBAAmB,eAAe,SAAS;GAEjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYzE,eAAsB,yBACpB,gBACA,UACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,yBAAyB,eAAe,cAAc,SAAS;AAE3F,SADa,MAAM,iBAAiB,eAAe,cAAc,eAAe,IAAI;UAE7E,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACpCjF,eAAsB,oBAA4C;AAChE,QAAO,eAAe"}

package/dist/email-search.d.mts

@@ -37,42 +37,42 @@ declare const deleteDatabase: (userID: string) => Promise<void>;
  * Derives database encryption key for the given user
  *
  * @param userID - The user ID
- * @returns The symmetric CryptoKey for protecting database
+ * @returns The symmetric key for protecting database
  */
-declare const deriveIndexKey: (baseKey: Uint8Array) => Promise<CryptoKey>;
+declare const deriveIndexKey: (baseKey: Uint8Array) => Promise<Uint8Array>;
 /**
  * Encrypts the given email and stores it in the IndexedDB database
  *
  * @param newEmailToStore - The email for storing
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key for protecting database
  * @param esDB - The database
  */
-declare const encryptAndStoreEmail: (newEmailToStore: Email, indexKey: CryptoKey, esDB: MailDB) => Promise<void>;
+declare const encryptAndStoreEmail: (newEmailToStore: Email, indexKey: Uint8Array, esDB: MailDB) => Promise<void>;
 /**
  * Encrypts the given set of emails and stores it in the IndexedDB database
  *
  * @param newEmailsToStore - The set of emails for storing
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key key for protecting database
  * @param esDB - The database
  */
-declare const encryptAndStoreManyEmail: (newEmailsToStore: Email[], indexKey: CryptoKey, esDB: MailDB) => Promise<void>;
+declare const encryptAndStoreManyEmail: (newEmailsToStore: Email[], indexKey: Uint8Array, esDB: MailDB) => Promise<void>;
 /**
  * Fetches the email from the database and decrypts it
  *
  * @param emailID - The email identifier
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key key for protecting database
  * @param encryptedEmail - The encrypted email
  * @returns The decrypted email
  */
-declare const getAndDecryptEmail: (emailID: string, indexKey: CryptoKey, esDB: MailDB) => Promise<Email>;
+declare const getAndDecryptEmail: (emailID: string, indexKey: Uint8Array, esDB: MailDB) => Promise<Email>;
 /**
  * Fetches all email from the database and decrypts them
  *
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key key for protecting database
  * @param esDB - The database
  * @returns The decrypted emails
  */
-declare const getAndDecryptAllEmails: (indexKey: CryptoKey, esDB: MailDB) => Promise<Email[]>;
+declare const getAndDecryptAllEmails: (indexKey: Uint8Array, esDB: MailDB) => Promise<Email[]>;
 /**
  * Deletes the email from the database
  *
@@ -105,28 +105,28 @@ declare const enforceMaxEmailNumber: (esDB: MailDB, max: number) => Promise<void
  * Fetches all emails from the database, decrypts them and sortes the results based on the creation time (newest first)
  *
  * @param esDB - The database
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric Uint8Array key for protecting database
  * @returns The number of stored emails
  */
-declare const getAllEmailsSortedNewestFirst: (esDB: MailDB, indexKey: CryptoKey) => Promise<Email[]>;
+declare const getAllEmailsSortedNewestFirst: (esDB: MailDB, indexKey: Uint8Array) => Promise<Email[]>;
 /**
  * Fetches all emails from the database, decrypts them and sortes the results based on the creation time (oldest first)
  *
  * @param esDB - The database
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key for protecting database
  * @returns The number of stored emails
  */
-declare const getAllEmailsSortedOldestFirst: (esDB: MailDB, indexKey: CryptoKey) => Promise<Email[]>;
+declare const getAllEmailsSortedOldestFirst: (esDB: MailDB, indexKey: Uint8Array) => Promise<Email[]>;
 /**
  * Fetches a batch of emails from the database, decrypts them and sortes the results based on the creation time (newest first)
  *
  * @param esDB - The database
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key for protecting database
  * @param batchSize - The size of the batch
  * @param startCursor - The starting point (optional). If not given, starts from the beginning
  * @returns The number of stored emails
  */
-declare const getEmailBatch: (esDB: MailDB, indexKey: CryptoKey, batchSize: number, startCursor?: IDBValidKey) => Promise<{
+declare const getEmailBatch: (esDB: MailDB, indexKey: Uint8Array, batchSize: number, startCursor?: IDBValidKey) => Promise<{
   emails: Email[];
   nextCursor?: IDBValidKey;
 }>;
@@ -135,11 +135,11 @@ declare const getEmailBatch: (esDB: MailDB, indexKey: CryptoKey, batchSize: numb
 /**
  * Fetches all emails from the database in batches and cahces them
  *
- * @param indexKey - The symmetric CryptoKey key for protecting database
+ * @param indexKey - The symmetric key for protecting database
  * @param esCache - The cache to add emails too
  * @param esDB - The database
  */
-declare const createCacheFromDB: (indexKey: CryptoKey, esDB: MailDB) => Promise<MailCache<Email>>;
+declare const createCacheFromDB: (indexKey: Uint8Array, esDB: MailDB) => Promise<MailCache<Email>>;
 /**
  * Gets an email from the cache
  *