internxt-crypto 0.0.10-alpha → 0.0.11

package/dist/symmetric-crypto.js

@@ -1,142 +1,10 @@
-'use strict';
-
-var blake3_js = require('@noble/hashes/blake3.js');
-var utils_js = require('@noble/hashes/utils.js');
-var utils_js$1 = require('@noble/post-quantum/utils.js');
-
-// src/constants.ts
-var AES_ALGORITHM = "AES-GCM";
-var AES_KEY_BIT_LENGTH = 256;
-var AUX_LEN = 128;
-var IV_LEN_BYTES = 16;
-var KEY_FORMAT = "raw";
-function getBytesFromString(bytes, value) {
-  return blake3_js.blake3(utils_js.utf8ToBytes(value), { dkLen: bytes });
-}
-
-// src/symmetric-crypto/keys.ts
-async function importSymmetricCryptoKey(keyData) {
-  return crypto.subtle.importKey(
-    KEY_FORMAT,
-    new Uint8Array(keyData),
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-async function exportSymmetricCryptoKey(key) {
-  try {
-    const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);
-    return new Uint8Array(rawKey);
-  } catch (error) {
-    throw new Error("Failed to export symmetric CryptoKey", { cause: error });
-  }
-}
-async function genSymmetricCryptoKey() {
-  return crypto.subtle.generateKey(
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-function genSymmetricKey() {
-  try {
-    const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);
-    crypto.getRandomValues(key);
-    return key;
-  } catch (error) {
-    throw new Error("Failed to generate symmetric key", { cause: error });
-  }
-}
-async function deriveSymmetricCryptoKey(keyMaterial) {
-  try {
-    const hashBuffer = await getBytesFromString(AES_KEY_BIT_LENGTH / 8, keyMaterial);
-    return importSymmetricCryptoKey(hashBuffer);
-  } catch (error) {
-    throw new Error("Failed to derive CryptoKey from the given key material", { cause: error });
-  }
-}
-async function createNISTbasedIV(freeField) {
-  try {
-    if (!freeField) {
-      return utils_js$1.randomBytes(IV_LEN_BYTES);
-    }
-    const iv = new Uint8Array(16);
-    const randFiled = utils_js$1.randomBytes(12);
-    iv.set(randFiled, 0);
-    const freeFiledFixedLength = await getBytesFromString(4, freeField);
-    iv.set(freeFiledFixedLength, 12);
-    return iv;
-  } catch (error) {
-    throw new Error("Failed to create IV", { cause: error });
-  }
-}
-async function makeAuxFixedLength(aux) {
-  return getBytesFromString(AUX_LEN / 8, aux);
-}
-async function encryptMessage(message, encryptionKey, iv, additionalData) {
-  try {
-    const encrypted = await crypto.subtle.encrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      message
-    );
-    return new Uint8Array(encrypted);
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
-  try {
-    const decrypted = await crypto.subtle.decrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      ciphertext
-    );
-    return new Uint8Array(decrypted);
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/symmetric-crypto/aes.ts
-async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
-  try {
-    const iv = await createNISTbasedIV(freeField);
-    const additionalData = await makeAuxFixedLength(aux);
-    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
-    return { ciphertext, iv };
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-  try {
-    const additionalData = await makeAuxFixedLength(aux);
-    const result = await decryptMessage(
-      encryptedMessage.ciphertext,
-      encryptedMessage.iv,
-      encryptionKey,
-      additionalData
-    );
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-exports.decryptSymmetrically = decryptSymmetrically;
-exports.deriveSymmetricCryptoKey = deriveSymmetricCryptoKey;
-exports.encryptSymmetrically = encryptSymmetrically;
-exports.exportSymmetricCryptoKey = exportSymmetricCryptoKey;
-exports.genSymmetricCryptoKey = genSymmetricCryptoKey;
-exports.genSymmetricKey = genSymmetricKey;
-exports.importSymmetricCryptoKey = importSymmetricCryptoKey;
-//# sourceMappingURL=symmetric-crypto.js.map
-//# sourceMappingURL=symmetric-crypto.js.map
+require('./hash-BoqwNkcd.js');
+const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
+
+exports.decryptSymmetrically = require_symmetric_crypto.decryptSymmetrically;
+exports.deriveSymmetricCryptoKey = require_symmetric_crypto.deriveSymmetricCryptoKey;
+exports.encryptSymmetrically = require_symmetric_crypto.encryptSymmetrically;
+exports.exportSymmetricCryptoKey = require_symmetric_crypto.exportSymmetricCryptoKey;
+exports.genSymmetricCryptoKey = require_symmetric_crypto.genSymmetricCryptoKey;
+exports.genSymmetricKey = require_symmetric_crypto.genSymmetricKey;
+exports.importSymmetricCryptoKey = require_symmetric_crypto.importSymmetricCryptoKey;

package/dist/symmetric-crypto.mjs

@@ -1,134 +1,4 @@
-import { blake3 } from '@noble/hashes/blake3.js';
-import { utf8ToBytes } from '@noble/hashes/utils.js';
-import { randomBytes } from '@noble/post-quantum/utils.js';
+import "./hash-CXeGAwai.mjs";
+import { a as exportSymmetricCryptoKey, c as importSymmetricCryptoKey, i as deriveSymmetricCryptoKey, n as decryptSymmetrically, o as genSymmetricCryptoKey, r as encryptSymmetrically, s as genSymmetricKey } from "./symmetric-crypto-CrdS1Che.mjs";
 
-// src/constants.ts
-var AES_ALGORITHM = "AES-GCM";
-var AES_KEY_BIT_LENGTH = 256;
-var AUX_LEN = 128;
-var IV_LEN_BYTES = 16;
-var KEY_FORMAT = "raw";
-function getBytesFromString(bytes, value) {
-  return blake3(utf8ToBytes(value), { dkLen: bytes });
-}
-
-// src/symmetric-crypto/keys.ts
-async function importSymmetricCryptoKey(keyData) {
-  return crypto.subtle.importKey(
-    KEY_FORMAT,
-    new Uint8Array(keyData),
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-async function exportSymmetricCryptoKey(key) {
-  try {
-    const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);
-    return new Uint8Array(rawKey);
-  } catch (error) {
-    throw new Error("Failed to export symmetric CryptoKey", { cause: error });
-  }
-}
-async function genSymmetricCryptoKey() {
-  return crypto.subtle.generateKey(
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-function genSymmetricKey() {
-  try {
-    const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);
-    crypto.getRandomValues(key);
-    return key;
-  } catch (error) {
-    throw new Error("Failed to generate symmetric key", { cause: error });
-  }
-}
-async function deriveSymmetricCryptoKey(keyMaterial) {
-  try {
-    const hashBuffer = await getBytesFromString(AES_KEY_BIT_LENGTH / 8, keyMaterial);
-    return importSymmetricCryptoKey(hashBuffer);
-  } catch (error) {
-    throw new Error("Failed to derive CryptoKey from the given key material", { cause: error });
-  }
-}
-async function createNISTbasedIV(freeField) {
-  try {
-    if (!freeField) {
-      return randomBytes(IV_LEN_BYTES);
-    }
-    const iv = new Uint8Array(16);
-    const randFiled = randomBytes(12);
-    iv.set(randFiled, 0);
-    const freeFiledFixedLength = await getBytesFromString(4, freeField);
-    iv.set(freeFiledFixedLength, 12);
-    return iv;
-  } catch (error) {
-    throw new Error("Failed to create IV", { cause: error });
-  }
-}
-async function makeAuxFixedLength(aux) {
-  return getBytesFromString(AUX_LEN / 8, aux);
-}
-async function encryptMessage(message, encryptionKey, iv, additionalData) {
-  try {
-    const encrypted = await crypto.subtle.encrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      message
-    );
-    return new Uint8Array(encrypted);
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
-  try {
-    const decrypted = await crypto.subtle.decrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      ciphertext
-    );
-    return new Uint8Array(decrypted);
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/symmetric-crypto/aes.ts
-async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
-  try {
-    const iv = await createNISTbasedIV(freeField);
-    const additionalData = await makeAuxFixedLength(aux);
-    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
-    return { ciphertext, iv };
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-  try {
-    const additionalData = await makeAuxFixedLength(aux);
-    const result = await decryptMessage(
-      encryptedMessage.ciphertext,
-      encryptedMessage.iv,
-      encryptionKey,
-      additionalData
-    );
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };
-//# sourceMappingURL=symmetric-crypto.mjs.map
-//# sourceMappingURL=symmetric-crypto.mjs.map
+export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };

package/dist/types-52g887Zi.js

@@ -0,0 +1,16 @@
+
+//#region src/types.ts
+let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
+	KeystoreType["ENCRYPTION"] = "Encryption";
+	KeystoreType["RECOVERY"] = "Recovery";
+	return KeystoreType;
+}({});
+
+//#endregion
+Object.defineProperty(exports, 'KeystoreType', {
+  enumerable: true,
+  get: function () {
+    return KeystoreType;
+  }
+});
+//# sourceMappingURL=types-52g887Zi.js.map

package/dist/types-52g887Zi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-52g887Zi.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;AAmHA,IAAY,sDAAL;AACL;AACA"}

package/dist/types-BiEoleqw.mjs

@@ -0,0 +1,10 @@
+//#region src/types.ts
+let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
+	KeystoreType["ENCRYPTION"] = "Encryption";
+	KeystoreType["RECOVERY"] = "Recovery";
+	return KeystoreType;
+}({});
+
+//#endregion
+export { KeystoreType as t };
+//# sourceMappingURL=types-BiEoleqw.mjs.map

package/dist/types-BiEoleqw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BiEoleqw.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAmHA,IAAY,sDAAL;AACL;AACA"}

package/dist/types-Ds3ivE9W.d.ts

@@ -0,0 +1,104 @@
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  encryptedKeys: EmailKeysEncrypted;
+};
+type User = {
+  email: string;
+  name: string;
+};
+type UserWithPublicKeys = User & {
+  publicKeys: PublicKeys;
+};
+type PublicKeys = {
+  eccPublicKey: CryptoKey;
+  kyberPublicKey: Uint8Array;
+};
+type PublicKeysBase64 = {
+  eccPublicKeyBase64: string;
+  kyberPublicKeyBase64: string;
+};
+type PrivateKeys = {
+  eccPrivateKey: CryptoKey;
+  kyberPrivateKey: Uint8Array;
+};
+type PrivateKeysEncrypted = {
+  eccPrivateKeyBase64: string;
+  kyberPrivateKeyBase64: string;
+};
+type EmailKeys = {
+  publicKeys: PublicKeys;
+  privateKeys: PrivateKeys;
+};
+type EmailKeysEncrypted = {
+  publicKeys: PublicKeysBase64;
+  privateKeys: PrivateKeysEncrypted;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  enc: EmailBodyEncrypted;
+  recipientEmail: string;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  enc: EmailBodyEncrypted;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type StoredEmail = {
+  params: EmailPublicParameters;
+  enc: EmailBodyEncrypted;
+  id: string;
+};
+type HybridEncKey = {
+  kyberCiphertext: string;
+  encryptedKey: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailBodyEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailBody = {
+  text: string;
+  attachments?: string[];
+};
+type EmailPublicParameters = {
+  subject: string;
+  createdAt: string;
+  sender: User;
+  recipient: User;
+  recipients?: User[];
+  replyToEmailID?: string;
+  labels?: string[];
+};
+type Email = {
+  id: string;
+  body: EmailBody;
+  params: EmailPublicParameters;
+};
+interface MailCache<Email> {
+  esCache: Map<string, Email>;
+  cacheSize: number;
+  isCacheLimited: boolean;
+  isCacheReady: boolean;
+}
+interface EmailSearchResult {
+  email: Email;
+  score?: number;
+}
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { PwdProtectedEmail as _, EmailKeysEncrypted as a, User as b, EncryptedKeystore as c, KeystoreType as d, MailCache as f, PublicKeysBase64 as g, PublicKeys as h, EmailKeys as i, HybridEncKey as l, PrivateKeysEncrypted as m, EmailBody as n, EmailPublicParameters as o, PrivateKeys as p, EmailBodyEncrypted as r, EmailSearchResult as s, Email as t, HybridEncryptedEmail as u, PwdProtectedKey as v, UserWithPublicKeys as x, StoredEmail as y };
+//# sourceMappingURL=types-Ds3ivE9W.d.ts.map

package/dist/types-DwQJtrTx.d.mts

@@ -0,0 +1,104 @@
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  encryptedKeys: EmailKeysEncrypted;
+};
+type User = {
+  email: string;
+  name: string;
+};
+type UserWithPublicKeys = User & {
+  publicKeys: PublicKeys;
+};
+type PublicKeys = {
+  eccPublicKey: CryptoKey;
+  kyberPublicKey: Uint8Array;
+};
+type PublicKeysBase64 = {
+  eccPublicKeyBase64: string;
+  kyberPublicKeyBase64: string;
+};
+type PrivateKeys = {
+  eccPrivateKey: CryptoKey;
+  kyberPrivateKey: Uint8Array;
+};
+type PrivateKeysEncrypted = {
+  eccPrivateKeyBase64: string;
+  kyberPrivateKeyBase64: string;
+};
+type EmailKeys = {
+  publicKeys: PublicKeys;
+  privateKeys: PrivateKeys;
+};
+type EmailKeysEncrypted = {
+  publicKeys: PublicKeysBase64;
+  privateKeys: PrivateKeysEncrypted;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  enc: EmailBodyEncrypted;
+  recipientEmail: string;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  enc: EmailBodyEncrypted;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type StoredEmail = {
+  params: EmailPublicParameters;
+  enc: EmailBodyEncrypted;
+  id: string;
+};
+type HybridEncKey = {
+  kyberCiphertext: string;
+  encryptedKey: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailBodyEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailBody = {
+  text: string;
+  attachments?: string[];
+};
+type EmailPublicParameters = {
+  subject: string;
+  createdAt: string;
+  sender: User;
+  recipient: User;
+  recipients?: User[];
+  replyToEmailID?: string;
+  labels?: string[];
+};
+type Email = {
+  id: string;
+  body: EmailBody;
+  params: EmailPublicParameters;
+};
+interface MailCache<Email> {
+  esCache: Map<string, Email>;
+  cacheSize: number;
+  isCacheLimited: boolean;
+  isCacheReady: boolean;
+}
+interface EmailSearchResult {
+  email: Email;
+  score?: number;
+}
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { PwdProtectedEmail as _, EmailKeysEncrypted as a, User as b, EncryptedKeystore as c, KeystoreType as d, MailCache as f, PublicKeysBase64 as g, PublicKeys as h, EmailKeys as i, HybridEncKey as l, PrivateKeysEncrypted as m, EmailBody as n, EmailPublicParameters as o, PrivateKeys as p, EmailBodyEncrypted as r, EmailSearchResult as s, Email as t, HybridEncryptedEmail as u, PwdProtectedKey as v, UserWithPublicKeys as x, StoredEmail as y };
+//# sourceMappingURL=types-DwQJtrTx.d.mts.map

package/dist/types.d.mts

@@ -1,102 +1,2 @@
-declare enum KeystoreType {
-    IDENTITY = "identity",
-    ENCRYPTION = "encryption",
-    RECOVERY = "recovery",
-    INDEX = "index"
-}
-type EncryptedKeystore = {
-    userID: string;
-    type: KeystoreType;
-    encryptedKeys: SymmetricCiphertext;
-};
-type User = {
-    email: string;
-    name: string;
-};
-type UserWithPublicKeys = User & {
-    publicKeys: PublicKeys;
-};
-type PublicKeys = {
-    eccPublicKey: CryptoKey;
-    kyberPublicKey: Uint8Array;
-};
-type MediaKeys = {
-    olmKey: Uint8Array;
-    pqKey: Uint8Array;
-    index: number;
-    userID: string;
-};
-type PrivateKeys = {
-    eccPrivateKey: CryptoKey;
-    kyberPrivateKey: Uint8Array;
-};
-type IdentityKeys = {
-    userPublicKey: CryptoKey;
-    userPrivateKey: CryptoKey;
-};
-type EncryptionKeys = {
-    userPublicKey: CryptoKey;
-    userPrivateKey: CryptoKey;
-    userPublicKyberKey: Uint8Array;
-    userPrivateKyberKey: Uint8Array;
-};
-type HybridEncryptedEmail = {
-    encryptedKey: HybridEncKey;
-    enc: SymmetricCiphertext;
-    recipientEmail: string;
-    params: EmailPublicParameters;
-    id: string;
-};
-type PwdProtectedEmail = {
-    encryptedKey: PwdProtectedKey;
-    enc: SymmetricCiphertext;
-    params: EmailPublicParameters;
-    id: string;
-};
-type SymmetricCiphertext = {
-    ciphertext: Uint8Array;
-    iv: Uint8Array;
-};
-type StoredEmail = {
-    params: EmailPublicParameters;
-    content: SymmetricCiphertext;
-    id: string;
-};
-type HybridEncKey = {
-    kyberCiphertext: Uint8Array;
-    encryptedKey: Uint8Array;
-};
-type PwdProtectedKey = {
-    encryptedKey: Uint8Array;
-    salt: Uint8Array;
-};
-type EmailBody = {
-    text: string;
-    attachments?: string[];
-};
-type EmailPublicParameters = {
-    subject: string;
-    createdAt: string;
-    sender: User;
-    recipient: User;
-    recipients?: User[];
-    replyToEmailID?: number;
-    labels?: string[];
-};
-type Email = {
-    id: string;
-    body: EmailBody;
-    params: EmailPublicParameters;
-};
-interface MailCache<Email> {
-    esCache: Map<string, Email>;
-    cacheSize: number;
-    isCacheLimited: boolean;
-    isCacheReady: boolean;
-}
-interface EmailSearchResult {
-    email: Email;
-    score?: number;
-}
-
-export { type Email, type EmailBody, type EmailPublicParameters, type EmailSearchResult, type EncryptedKeystore, type EncryptionKeys, type HybridEncKey, type HybridEncryptedEmail, type IdentityKeys, KeystoreType, type MailCache, type MediaKeys, type PrivateKeys, type PublicKeys, type PwdProtectedEmail, type PwdProtectedKey, type StoredEmail, type SymmetricCiphertext, type User, type UserWithPublicKeys };
+import { _ as PwdProtectedEmail, a as EmailKeysEncrypted, b as User, c as EncryptedKeystore, d as KeystoreType, f as MailCache, g as PublicKeysBase64, h as PublicKeys, i as EmailKeys, l as HybridEncKey, m as PrivateKeysEncrypted, n as EmailBody, o as EmailPublicParameters, p as PrivateKeys, r as EmailBodyEncrypted, s as EmailSearchResult, t as Email, u as HybridEncryptedEmail, v as PwdProtectedKey, x as UserWithPublicKeys, y as StoredEmail } from "./types-DwQJtrTx.mjs";
+export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };