@internxt/sdk 1.15.6 → 1.15.8

package/dist/mail/api.d.ts

@@ -0,0 +1,61 @@
+import { ApiSecurity, ApiUrl, AppDetails } from '../shared';
+import { EncryptedKeystore, KeystoreType, HybridEncryptedEmail, PwdProtectedEmail, RecipientWithPublicKey, EmailPublicParameters } from 'internxt-crypto';
+import { MailboxResponse, EmailListResponse, EmailResponse, EmailCreatedResponse, SendEmailRequest, DraftEmailRequest, UpdateEmailRequest, ListEmailsQuery } from './types';
+export declare class MailApi {
+    private readonly client;
+    private readonly appDetails;
+    private readonly apiSecurity;
+    private readonly apiUrl;
+    static client(apiUrl: ApiUrl, appDetails: AppDetails, apiSecurity: ApiSecurity): MailApi;
+    private constructor();
+    /**
+     * Uploads encrypted keystore to the server
+     *
+     * @param keystore - The encrypted keystore
+     * @returns Server response
+     */
+    uploadKeystore(keystore: EncryptedKeystore): Promise<void>;
+    /**
+     * Requests encrypted keystore from the server
+     *
+     * @param userEmail - The email of the user
+     * @param keystoreType - The type of the keystore
+     * @returns The encrypted keystore
+     */
+    downloadKeystore(userEmail: string, keystoreType: KeystoreType): Promise<EncryptedKeystore>;
+    /**
+     * Requests users with corresponding public keys from the server
+     *
+     * @param emails - The emails of the users
+     * @returns Users with corresponding public keys
+     */
+    getUsersWithPublicKeys(emails: string[]): Promise<RecipientWithPublicKey[]>;
+    /**
+     * Sends the encrypted emails to the server
+     *
+     * @param emails - The encrypted emails
+     * @param params - The public parameters of the email
+     * @returns Server response
+     */
+    sendE2EEmails(emails: HybridEncryptedEmail[], params: EmailPublicParameters): Promise<void>;
+    /**
+     * Sends the password-protected email to the server
+     *
+     * @param email - The password-protected email
+     * @param params - The public parameters of the email
+     * @returns Server response
+     */
+    sendE2EPasswordProtectedEmail(email: PwdProtectedEmail, params: EmailPublicParameters): Promise<void>;
+    getMailboxes(): Promise<MailboxResponse[]>;
+    listEmails(query?: ListEmailsQuery): Promise<EmailListResponse>;
+    getEmail(id: string): Promise<EmailResponse>;
+    deleteEmail(id: string): Promise<void>;
+    updateEmail(id: string, body: UpdateEmailRequest): Promise<void>;
+    sendEmail(body: SendEmailRequest): Promise<EmailCreatedResponse>;
+    saveDraft(body: DraftEmailRequest): Promise<EmailCreatedResponse>;
+    /**
+     * Returns the needed headers for the module requests
+     * @private
+     */
+    private headers;
+}

package/dist/mail/api.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailApi = void 0;
+var headers_1 = require("../shared/headers");
+var client_1 = require("../shared/http/client");
+var internxt_crypto_1 = require("internxt-crypto");
+var MailApi = /** @class */ (function () {
+    function MailApi(apiUrl, appDetails, apiSecurity) {
+        this.client = client_1.HttpClient.create(apiUrl, apiSecurity.unauthorizedCallback);
+        this.appDetails = appDetails;
+        this.apiSecurity = apiSecurity;
+        this.apiUrl = apiUrl;
+    }
+    MailApi.client = function (apiUrl, appDetails, apiSecurity) {
+        return new MailApi(apiUrl, appDetails, apiSecurity);
+    };
+    /**
+     * Uploads encrypted keystore to the server
+     *
+     * @param keystore - The encrypted keystore
+     * @returns Server response
+     */
+    MailApi.prototype.uploadKeystore = function (keystore) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.post("".concat(this.apiUrl, "/keystore"), { encryptedKeystore: keystore }, this.headers())];
+            });
+        });
+    };
+    /**
+     * Requests encrypted keystore from the server
+     *
+     * @param userEmail - The email of the user
+     * @param keystoreType - The type of the keystore
+     * @returns The encrypted keystore
+     */
+    MailApi.prototype.downloadKeystore = function (userEmail, keystoreType) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.getWithParams("".concat(this.apiUrl, "/user/keystore"), { userEmail: userEmail, keystoreType: keystoreType }, this.headers())];
+            });
+        });
+    };
+    /**
+     * Requests users with corresponding public keys from the server
+     *
+     * @param emails - The emails of the users
+     * @returns Users with corresponding public keys
+     */
+    MailApi.prototype.getUsersWithPublicKeys = function (emails) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.post("".concat(this.apiUrl, "/users/public-keys"), { emails: emails }, this.headers())];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, Promise.all(response.map(function (item) { return __awaiter(_this, void 0, void 0, function () {
+                                var publicHybridKey;
+                                return __generator(this, function (_a) {
+                                    publicHybridKey = (0, internxt_crypto_1.base64ToUint8Array)(item.publicKey);
+                                    return [2 /*return*/, { email: item.email, publicHybridKey: publicHybridKey }];
+                                });
+                            }); }))];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * Sends the encrypted emails to the server
+     *
+     * @param emails - The encrypted emails
+     * @param params - The public parameters of the email
+     * @returns Server response
+     */
+    MailApi.prototype.sendE2EEmails = function (emails, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.post("".concat(this.apiUrl, "/emails"), { emails: emails, params: params }, this.headers())];
+            });
+        });
+    };
+    /**
+     * Sends the password-protected email to the server
+     *
+     * @param email - The password-protected email
+     * @param params - The public parameters of the email
+     * @returns Server response
+     */
+    MailApi.prototype.sendE2EPasswordProtectedEmail = function (email, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.post("".concat(this.apiUrl, "/emails"), { email: email, params: params }, this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.getMailboxes = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.get("".concat(this.apiUrl, "/email/mailboxes"), this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.listEmails = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.getWithParams("".concat(this.apiUrl, "/email"), query !== null && query !== void 0 ? query : {}, this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.getEmail = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.get("".concat(this.apiUrl, "/email/").concat(id), this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.deleteEmail = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.delete("".concat(this.apiUrl, "/email/").concat(id), this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.updateEmail = function (id, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.patch("".concat(this.apiUrl, "/email/").concat(id), body, this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.sendEmail = function (body) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.post("".concat(this.apiUrl, "/email/send"), body, this.headers())];
+            });
+        });
+    };
+    MailApi.prototype.saveDraft = function (body) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.post("".concat(this.apiUrl, "/email/drafts"), body, this.headers())];
+            });
+        });
+    };
+    /**
+     * Returns the needed headers for the module requests
+     * @private
+     */
+    MailApi.prototype.headers = function () {
+        return (0, headers_1.headersWithToken)({
+            clientName: this.appDetails.clientName,
+            clientVersion: this.appDetails.clientVersion,
+            token: this.apiSecurity.token,
+            desktopToken: this.appDetails.desktopHeader,
+            customHeaders: this.appDetails.customHeaders,
+        });
+    };
+    return MailApi;
+}());
+exports.MailApi = MailApi;

package/dist/mail/crypto.d.ts

@@ -0,0 +1,66 @@
+import { EncryptedKeystore, HybridEncryptedEmail, PwdProtectedEmail, HybridKeyPair, Email, EmailBody, RecipientWithPublicKey } from 'internxt-crypto';
+/**
+ * Creates recovery and encryption keystores for a user
+ *
+ * @param userEmail - The email of the user
+ * @param baseKey - The secret key of the user
+ * @returns The created keystores, keys and recovery codes for opening recovery keystore
+ */
+export declare function createKeystores(userEmail: string, baseKey: Uint8Array): Promise<{
+    encryptionKeystore: EncryptedKeystore;
+    recoveryKeystore: EncryptedKeystore;
+    recoveryCodes: string;
+    keys: HybridKeyPair;
+}>;
+/**
+ * Opens user's keystore and returns the keys
+ *
+ * @param keystore - The encrypted keystore
+ * @param baseKey - The secret key of the user
+ * @returns The keys of the user
+ */
+export declare function openKeystore(keystore: EncryptedKeystore, baseKey: Uint8Array): Promise<HybridKeyPair>;
+/**
+ * Recovery of user's keys using recovery keystore
+ *
+ * @param keystore - The recovery keystore
+ * @param recoveryCodes - The recovery codes of the user
+ * @returns The keys of the user
+ */
+export declare function recoverKeys(keystore: EncryptedKeystore, recoveryCodes: string): Promise<HybridKeyPair>;
+/**
+ * Encrypts the email
+ *
+ * @param email - The email to encrypt
+ * @param recipients - The recipients of the email
+ * @param aux - The optional auxilary data to encrypt together with the email (e.g. email sender)
+ * @returns The encrypted emails for each recipient
+ */
+export declare function encryptEmail(email: Email, recipients: RecipientWithPublicKey[], aux?: string): Promise<HybridEncryptedEmail[]>;
+/**
+ * Password-protects the email
+ *
+ * @param email - The email to password-protect
+ * @param pwd - The password to protect the email with
+ * @param aux - The optional auxilary data to encrypt together with the email (e.g. email sender)
+ * @returns The password-protected email
+ */
+export declare function passwordProtectAndSendEmail(email: Email, pwd: string, aux?: string): Promise<PwdProtectedEmail>;
+/**
+ * Opens the password-protected email
+ *
+ * @param email - The password-protected email
+ * @param pwd - The shared password
+ * @param aux - The optional auxilary data that was encrypted together with the email (e.g. email sender)
+ * @returns The decrypted email body
+ */
+export declare function openPasswordProtectedEmail(email: PwdProtectedEmail, pwd: string, aux?: string): Promise<EmailBody>;
+/**
+ * Decrypt the email
+ *
+ * @param email - The encrypted email
+ * @param recipientPrivateKeys - The private keys of the email recipient
+ * @param aux - The optional auxilary data that was encrypted together with the email (e.g. email sender)
+ * @returns The decrypted email body
+ */
+export declare function decryptEmail(email: HybridEncryptedEmail, recipientPrivateKeys: Uint8Array, aux?: string): Promise<EmailBody>;

package/dist/mail/crypto.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeystores = createKeystores;
+exports.openKeystore = openKeystore;
+exports.recoverKeys = recoverKeys;
+exports.encryptEmail = encryptEmail;
+exports.passwordProtectAndSendEmail = passwordProtectAndSendEmail;
+exports.openPasswordProtectedEmail = openPasswordProtectedEmail;
+exports.decryptEmail = decryptEmail;
+var internxt_crypto_1 = require("internxt-crypto");
+/**
+ * Creates recovery and encryption keystores for a user
+ *
+ * @param userEmail - The email of the user
+ * @param baseKey - The secret key of the user
+ * @returns The created keystores, keys and recovery codes for opening recovery keystore
+ */
+function createKeystores(userEmail, baseKey) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, (0, internxt_crypto_1.createEncryptionAndRecoveryKeystores)(userEmail, baseKey)];
+        });
+    });
+}
+/**
+ * Opens user's keystore and returns the keys
+ *
+ * @param keystore - The encrypted keystore
+ * @param baseKey - The secret key of the user
+ * @returns The keys of the user
+ */
+function openKeystore(keystore, baseKey) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, (0, internxt_crypto_1.openEncryptionKeystore)(keystore, baseKey)];
+        });
+    });
+}
+/**
+ * Recovery of user's keys using recovery keystore
+ *
+ * @param keystore - The recovery keystore
+ * @param recoveryCodes - The recovery codes of the user
+ * @returns The keys of the user
+ */
+function recoverKeys(keystore, recoveryCodes) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, (0, internxt_crypto_1.openRecoveryKeystore)(recoveryCodes, keystore)];
+        });
+    });
+}
+/**
+ * Encrypts the email
+ *
+ * @param email - The email to encrypt
+ * @param recipients - The recipients of the email
+ * @param aux - The optional auxilary data to encrypt together with the email (e.g. email sender)
+ * @returns The encrypted emails for each recipient
+ */
+function encryptEmail(email, recipients, aux) {
+    return __awaiter(this, void 0, void 0, function () {
+        var auxArray;
+        return __generator(this, function (_a) {
+            auxArray = aux ? (0, internxt_crypto_1.UTF8ToUint8)(aux) : new Uint8Array();
+            return [2 /*return*/, (0, internxt_crypto_1.encryptEmailHybridForMultipleRecipients)(email.body, recipients, auxArray)];
+        });
+    });
+}
+/**
+ * Password-protects the email
+ *
+ * @param email - The email to password-protect
+ * @param pwd - The password to protect the email with
+ * @param aux - The optional auxilary data to encrypt together with the email (e.g. email sender)
+ * @returns The password-protected email
+ */
+function passwordProtectAndSendEmail(email, pwd, aux) {
+    return __awaiter(this, void 0, void 0, function () {
+        var auxArray;
+        return __generator(this, function (_a) {
+            auxArray = aux ? (0, internxt_crypto_1.UTF8ToUint8)(aux) : new Uint8Array();
+            return [2 /*return*/, (0, internxt_crypto_1.createPwdProtectedEmail)(email.body, pwd, auxArray)];
+        });
+    });
+}
+/**
+ * Opens the password-protected email
+ *
+ * @param email - The password-protected email
+ * @param pwd - The shared password
+ * @param aux - The optional auxilary data that was encrypted together with the email (e.g. email sender)
+ * @returns The decrypted email body
+ */
+function openPasswordProtectedEmail(email, pwd, aux) {
+    return __awaiter(this, void 0, void 0, function () {
+        var auxArray;
+        return __generator(this, function (_a) {
+            auxArray = aux ? (0, internxt_crypto_1.UTF8ToUint8)(aux) : new Uint8Array();
+            return [2 /*return*/, (0, internxt_crypto_1.decryptPwdProtectedEmail)(email, pwd, auxArray)];
+        });
+    });
+}
+/**
+ * Decrypt the email
+ *
+ * @param email - The encrypted email
+ * @param recipientPrivateKeys - The private keys of the email recipient
+ * @param aux - The optional auxilary data that was encrypted together with the email (e.g. email sender)
+ * @returns The decrypted email body
+ */
+function decryptEmail(email, recipientPrivateKeys, aux) {
+    return __awaiter(this, void 0, void 0, function () {
+        var auxArray;
+        return __generator(this, function (_a) {
+            auxArray = aux ? (0, internxt_crypto_1.UTF8ToUint8)(aux) : new Uint8Array();
+            return [2 /*return*/, (0, internxt_crypto_1.decryptEmailHybrid)(email, recipientPrivateKeys, auxArray)];
+        });
+    });
+}

package/dist/mail/index.d.ts

@@ -1,132 +1,2 @@
-import { ApiSecurity, ApiUrl, AppDetails } from '../shared';
-import { EncryptedKeystore, KeystoreType, PrivateKeys, HybridEncryptedEmail, PwdProtectedEmail, EmailKeys, Email, UserWithPublicKeys } from 'internxt-crypto';
-export declare class Mail {
-    private readonly client;
-    private readonly appDetails;
-    private readonly apiSecurity;
-    private readonly apiUrl;
-    static client(apiUrl: ApiUrl, appDetails: AppDetails, apiSecurity: ApiSecurity): Mail;
-    private constructor();
-    /**
-     * Uploads encrypted keystore to the server
-     *
-     * @param encryptedKeystore - The encrypted keystore
-     * @returns Server response
-     */
-    uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<void>;
-    /**
-     * Creates recovery and encryption keystores and uploads them to the server
-     *
-     * @param userEmail - The email of the user
-     * @param baseKey - The secret key of the user
-     * @returns The recovery codes for opening recovery keystore
-     */
-    createAndUploadKeystores(userEmail: string, baseKey: Uint8Array): Promise<string>;
-    /**
-     * Requests encrypted keystore from the server
-     *
-     * @param userEmail - The email of the user
-     * @param keystoreType - The type of the keystore
-     * @returns The encrypted keystore
-     */
-    downloadKeystoreFromServer(userEmail: string, keystoreType: KeystoreType): Promise<EncryptedKeystore>;
-    /**
-     * Requests encrypted keystore from the server and opens it
-     *
-     * @param userEmail - The email of the user
-     * @param baseKey - The secret key of the user
-     * @returns The email keys of the user
-     */
-    getUserEmailKeys(userEmail: string, baseKey: Uint8Array): Promise<EmailKeys>;
-    /**
-     * Requests recovery keystore from the server and opens it
-     *
-     * @param userEmail - The email of the user
-     * @param recoveryCodes - The recovery codes of the user
-     * @returns The email keys of the user
-     */
-    recoverUserEmailKeys(userEmail: string, recoveryCodes: string): Promise<EmailKeys>;
-    /**
-     * Request user with corresponding public keys from the server
-     *
-     * @param userEmail - The email of the user
-     * @returns User with corresponding public keys
-     */
-    getUserWithPublicKeys(userEmail: string): Promise<UserWithPublicKeys>;
-    /**
-     * Request users with corresponding public keys from the server
-     *
-     * @param emails - The emails of the users
-     * @returns Users with corresponding public keys
-     */
-    getSeveralUsersWithPublicKeys(emails: string[]): Promise<UserWithPublicKeys[]>;
-    /**
-     * Sends the encrypted email to the server
-     *
-     * @param email - The encrypted email
-     * @returns Server response
-     */
-    sendEncryptedEmail(email: HybridEncryptedEmail): Promise<void>;
-    /**
-     * Encrypts email and sends it to the server
-     *
-     * @param email - The message to encrypt
-     * @param senderPrivateKeys - The private keys of the sender
-     * @param isSubjectEncrypted - Indicates if the subject field should be encrypted
-     * @returns Server response
-     */
-    encryptAndSendEmail(email: Email, senderPrivateKeys: PrivateKeys, isSubjectEncrypted?: boolean): Promise<void>;
-    /**
-     * Sends the encrypted emails for multiple recipients to the server
-     *
-     * @param emails - The encrypted emails
-     * @returns Server response
-     */
-    sendEncryptedEmailToMultipleRecipients(emails: HybridEncryptedEmail[]): Promise<void>;
-    /**
-     * Encrypts emails for multiple recipients and sends emails to the server
-     *
-     * @param email - The message to encrypt
-     * @param senderPrivateKeys - The private keys of the sender
-     * @param isSubjectEncrypted - Indicates if the subject field should be encrypted
-     * @returns Server response
-     */
-    encryptAndSendEmailToMultipleRecipients(email: Email, senderPrivateKeys: PrivateKeys, isSubjectEncrypted?: boolean): Promise<void>;
-    /**
-     * Sends the password-protected email to the server
-     *
-     * @param email - The password-protected email
-     * @returns Server response
-     */
-    sendPasswordProtectedEmail(email: PwdProtectedEmail): Promise<void>;
-    /**
-     * Creates the password-protected email and sends it to the server
-     *
-     * @param email - The email
-     * @param pwd - The password
-     * @param isSubjectEncrypted - Indicates if the subject field should be encrypted
-     * @returns Server response
-     */
-    passwordProtectAndSendEmail(email: Email, pwd: string, isSubjectEncrypted?: boolean): Promise<void>;
-    /**
-     * Opens the password-protected email
-     *
-     * @param email - The password-protected email
-     * @param pwd - The shared password
-     * @returns The decrypted email
-     */
-    openPasswordProtectedEmail(email: PwdProtectedEmail, pwd: string): Promise<Email>;
-    /**
-     * Decrypt the email
-     *
-     * @param email - The encrypted email
-     * @param recipientPrivateKeys - The private keys of the email recipient
-     * @returns The decrypted email
-     */
-    decryptEmail(email: HybridEncryptedEmail, recipientPrivateKeys: PrivateKeys): Promise<Email>;
-    /**
-     * Returns the needed headers for the module requests
-     * @private
-     */
-    private headers;
-}
+export * from './types';
+export * from './mail';