imapkit 4.3.1 → 5.0.0

package/dist/cjs/smtp-listener.d.ts

@@ -7,7 +7,8 @@ import type { IMAPServer } from './types.js';
  *
  * @param {Number} smtpPort - port to listen on for SMTP commands
  * @param {Object} imapServer - the ImapKit IMAP server
- * @param {Function} [callback] - function executed when SMTP server is listening
+ * @param {Function} [callback] - function executed when SMTP server is listening, with the port
+ * @param {String} [host] - address to listen on, all addresses if not set
  * @return {SMTPServer} the SMTP server instance, use `close()` to stop it
  */
-export declare function startSMTPServer(smtpPort: number, imapServer: IMAPServer, callback?: (() => void) | null): SMTPServer;
+export declare function startSMTPServer(smtpPort: number, imapServer: IMAPServer, callback?: ((port: number) => void) | null, host?: string): SMTPServer;

package/dist/cjs/smtp-listener.js

@@ -9,10 +9,11 @@ const smtp_server_1 = require("smtp-server");
  *
  * @param {Number} smtpPort - port to listen on for SMTP commands
  * @param {Object} imapServer - the ImapKit IMAP server
- * @param {Function} [callback] - function executed when SMTP server is listening
+ * @param {Function} [callback] - function executed when SMTP server is listening, with the port
+ * @param {String} [host] - address to listen on, all addresses if not set
  * @return {SMTPServer} the SMTP server instance, use `close()` to stop it
  */
-function startSMTPServer(smtpPort, imapServer, callback) {
+function startSMTPServer(smtpPort, imapServer, callback, host) {
     const credentials = imapServer.getCredentials();
     const server = new smtp_server_1.SMTPServer({
         banner: 'ImapKit',
@@ -39,9 +40,12 @@ function startSMTPServer(smtpPort, imapServer, callback) {
             console.error('SMTP server error: %s', err.message);
         }
     });
-    server.listen(smtpPort, () => {
-        console.log('Incoming SMTP server up and running on port %s', server.server.address().port);
-        callback?.();
-    });
+    const onListening = () => callback?.(server.server.address().port);
+    if (host) {
+        server.listen(smtpPort, host, onListening);
+    }
+    else {
+        server.listen(smtpPort, onListening);
+    }
     return server;
 }

package/dist/cjs/storage-schema.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The shape of the `storage` option, which is also the shape of `server.control.snapshot()`: a JSON Schema for
+ * editors and other tools, and the check the server runs on the option, so that a typo in a fixture ("message" for
+ * "messages") fails with a clear error instead of an empty mailbox. Plugins keep their own data on mailboxes and
+ * messages (acl, metadata, MODSEQ ...), so other keys are allowed, only the types of the known keys are checked
+ */
+/** JSON Schema (draft 2020-12) of the `storage` option */
+export declare const storageSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ImapKit storage";
+    readonly description: "Namespaces by prefix (\"INBOX\", \"\", \"INBOX.\", \"#shared/\" ...), INBOX is a mailbox of its own";
+    readonly type: "object";
+    readonly properties: {
+        readonly INBOX: {
+            readonly $ref: "#/$defs/mailbox";
+        };
+    };
+    readonly additionalProperties: {
+        readonly $ref: "#/$defs/namespace";
+    };
+    readonly $defs: {
+        readonly message: {
+            readonly oneOf: readonly [{
+                readonly type: "string";
+                readonly description: "the message source";
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly raw: {
+                        readonly type: "string";
+                        readonly description: "the message source (a Buffer also works in JavaScript)";
+                    };
+                    readonly uid: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    readonly flags: {
+                        readonly oneOf: readonly [{
+                            readonly type: "string";
+                        }, {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        }];
+                    };
+                    readonly internaldate: {
+                        readonly type: "string";
+                        readonly description: "RFC 3501 date-time, e.g. \"14-Sep-2013 21:22:28 -0300\" (a Date also works in JavaScript)";
+                    };
+                    readonly recent: {
+                        readonly type: "boolean";
+                    };
+                };
+            }];
+        };
+        readonly mailbox: {
+            readonly type: "object";
+            readonly properties: {
+                readonly uid: {
+                    readonly type: "integer";
+                };
+                readonly uidvalidity: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                readonly uidnext: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                readonly flags: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                readonly permanentFlags: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                readonly allowPermanentFlags: {
+                    readonly type: "boolean";
+                };
+                readonly subscribed: {
+                    readonly type: "boolean";
+                };
+                readonly knownFlags: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                readonly messages: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/message";
+                    };
+                };
+                readonly folders: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/mailbox";
+                    };
+                };
+            };
+        };
+        readonly namespace: {
+            readonly type: "object";
+            readonly properties: {
+                readonly separator: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 1;
+                };
+                readonly type: {
+                    readonly enum: readonly ["personal", "user", "shared"];
+                };
+                readonly folders: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/mailbox";
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * Checks the `storage` option
+ *
+ * @param {Object} storage Storage
+ * @throws {Error} "Invalid storage at <path>: <problem>"
+ */
+export declare function validateStorage(storage: unknown): void;

package/dist/cjs/storage-schema.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * The shape of the `storage` option, which is also the shape of `server.control.snapshot()`: a JSON Schema for
+ * editors and other tools, and the check the server runs on the option, so that a typo in a fixture ("message" for
+ * "messages") fails with a clear error instead of an empty mailbox. Plugins keep their own data on mailboxes and
+ * messages (acl, metadata, MODSEQ ...), so other keys are allowed, only the types of the known keys are checked
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageSchema = void 0;
+exports.validateStorage = validateStorage;
+const numbers_js_1 = require("./numbers.js");
+// keys of plugins, an unknown key that looks like a typo of a known key is refused unless a plugin uses it
+const PLUGIN_KEYS = [
+    'acl',
+    'metadata',
+    'special-use',
+    'MAILBOXID',
+    'HIGHESTMODSEQ',
+    'qresyncExpunged',
+    'appendLimit',
+    'SAVEDATE',
+    'MODSEQ',
+    'EMAILID',
+    'THREADID',
+    'X-GM-LABELS',
+    'X-GM-MSGID',
+    'X-GM-THRID'
+];
+const flagList = { type: 'array', items: { type: 'string' } };
+const nzNumber = { type: 'integer', minimum: 1, maximum: numbers_js_1.MAX_NUMBER };
+/** JSON Schema (draft 2020-12) of the `storage` option */
+exports.storageSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: 'ImapKit storage',
+    description: 'Namespaces by prefix ("INBOX", "", "INBOX.", "#shared/" ...), INBOX is a mailbox of its own',
+    type: 'object',
+    properties: { INBOX: { $ref: '#/$defs/mailbox' } },
+    additionalProperties: { $ref: '#/$defs/namespace' },
+    $defs: {
+        message: {
+            oneOf: [
+                { type: 'string', description: 'the message source' },
+                {
+                    type: 'object',
+                    properties: {
+                        raw: { type: 'string', description: 'the message source (a Buffer also works in JavaScript)' },
+                        uid: nzNumber,
+                        flags: { oneOf: [{ type: 'string' }, flagList] },
+                        internaldate: {
+                            type: 'string',
+                            description: 'RFC 3501 date-time, e.g. "14-Sep-2013 21:22:28 -0300" (a Date also works in JavaScript)'
+                        },
+                        recent: { type: 'boolean' }
+                    }
+                }
+            ]
+        },
+        mailbox: {
+            type: 'object',
+            properties: {
+                uid: { type: 'integer' },
+                uidvalidity: nzNumber,
+                uidnext: nzNumber,
+                flags: flagList,
+                permanentFlags: flagList,
+                allowPermanentFlags: { type: 'boolean' },
+                subscribed: { type: 'boolean' },
+                knownFlags: flagList,
+                messages: { type: 'array', items: { $ref: '#/$defs/message' } },
+                folders: { type: 'object', additionalProperties: { $ref: '#/$defs/mailbox' } }
+            }
+        },
+        namespace: {
+            type: 'object',
+            properties: {
+                separator: { type: 'string', minLength: 1, maxLength: 1 },
+                type: { enum: ['personal', 'user', 'shared'] },
+                folders: { type: 'object', additionalProperties: { $ref: '#/$defs/mailbox' } }
+            }
+        }
+    }
+};
+// the keys the schema knows, the typo check compares unknown keys with them
+const MAILBOX_KEYS = Object.keys(exports.storageSchema.$defs.mailbox.properties);
+const NAMESPACE_KEYS = ['separator', 'type'];
+const MESSAGE_KEYS = Object.keys(exports.storageSchema.$defs.message.oneOf[1].properties);
+/**
+ * Finds the known key that an unknown key looks like a typo of: the same key in another case, or one edit away
+ *
+ * @param {String} key Unknown key
+ * @param {Array} known Known keys
+ * @return {String|null} the known key, or null
+ */
+function typoOf(key, known) {
+    if (known.includes(key) || PLUGIN_KEYS.includes(key)) {
+        return null;
+    }
+    return known.find(name => name.toLowerCase() === key.toLowerCase() || (key.length > 3 && editDistance(name, key) === 1)) || null;
+}
+/**
+ * Levenshtein distance, only used for short keys
+ */
+function editDistance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let previous = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const current = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+            previous = current;
+        }
+    }
+    return row[b.length];
+}
+const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const isFlagList = (value) => Array.isArray(value) && value.every(flag => typeof flag === 'string');
+const isNz = (value) => Number.isSafeInteger(value) && value >= 1 && value <= numbers_js_1.MAX_NUMBER;
+/**
+ * Checks the `storage` option
+ *
+ * @param {Object} storage Storage
+ * @throws {Error} "Invalid storage at <path>: <problem>"
+ */
+function validateStorage(storage) {
+    const fail = (path, problem) => {
+        throw new Error('Invalid storage at ' + path + ': ' + problem);
+    };
+    const checkKeys = (value, path, known) => {
+        Object.keys(value).forEach(key => {
+            const typo = typoOf(key, known);
+            if (typo) {
+                fail(path, 'unknown key ' + JSON.stringify(key) + ', did you mean ' + JSON.stringify(typo) + '?');
+            }
+        });
+    };
+    const checkMessage = (message, path) => {
+        if (typeof message === 'string' || message instanceof Uint8Array) {
+            return;
+        }
+        if (!isObject(message)) {
+            return fail(path, 'a message is a string or an object');
+        }
+        checkKeys(message, path, MESSAGE_KEYS);
+        if (message.raw !== undefined && typeof message.raw !== 'string' && !(message.raw instanceof Uint8Array)) {
+            fail(path + '.raw', 'must be a string');
+        }
+        if (message.uid !== undefined && !isNz(message.uid)) {
+            fail(path + '.uid', 'must be an integer from 1 to ' + numbers_js_1.MAX_NUMBER);
+        }
+        if (message.flags !== undefined && typeof message.flags !== 'string' && !isFlagList(message.flags)) {
+            fail(path + '.flags', 'must be a flag or a list of flags');
+        }
+        if (message.internaldate !== undefined &&
+            message.internaldate !== false &&
+            typeof message.internaldate !== 'string' &&
+            !(message.internaldate instanceof Date)) {
+            fail(path + '.internaldate', 'must be a date-time string or a Date');
+        }
+        if (message.recent !== undefined && typeof message.recent !== 'boolean') {
+            fail(path + '.recent', 'must be true or false');
+        }
+    };
+    const checkMailbox = (mailbox, path, known) => {
+        if (!isObject(mailbox)) {
+            return fail(path, 'a mailbox is an object');
+        }
+        checkKeys(mailbox, path, known);
+        for (const key of ['uidvalidity', 'uidnext']) {
+            if (mailbox[key] !== undefined && !isNz(mailbox[key])) {
+                fail(path + '.' + key, 'must be an integer from 1 to ' + numbers_js_1.MAX_NUMBER);
+            }
+        }
+        for (const key of ['flags', 'permanentFlags', 'knownFlags']) {
+            if (mailbox[key] !== undefined && !isFlagList(mailbox[key])) {
+                fail(path + '.' + key, 'must be a list of strings');
+            }
+        }
+        for (const key of ['allowPermanentFlags', 'subscribed']) {
+            if (mailbox[key] !== undefined && typeof mailbox[key] !== 'boolean') {
+                fail(path + '.' + key, 'must be true or false');
+            }
+        }
+        if (mailbox.messages !== undefined) {
+            if (!Array.isArray(mailbox.messages)) {
+                fail(path + '.messages', 'must be a list of messages');
+            }
+            mailbox.messages.forEach((message, i) => checkMessage(message, path + '.messages[' + i + ']'));
+        }
+        if (mailbox.folders !== undefined) {
+            if (!isObject(mailbox.folders)) {
+                fail(path + '.folders', 'must be an object of mailboxes by name');
+            }
+            Object.keys(mailbox.folders).forEach(name => checkMailbox(mailbox.folders[name], path + '.folders[' + JSON.stringify(name) + ']', MAILBOX_KEYS));
+        }
+    };
+    if (!isObject(storage)) {
+        fail('the top level', 'storage is an object of namespaces');
+    }
+    Object.keys(storage).forEach(key => {
+        const value = storage[key];
+        const path = JSON.stringify(key);
+        if (key === 'INBOX') {
+            return checkMailbox(value, path, MAILBOX_KEYS.concat('separator'));
+        }
+        checkMailbox(value, path, MAILBOX_KEYS.concat(NAMESPACE_KEYS));
+        const namespace = value;
+        if (namespace.separator !== undefined && (typeof namespace.separator !== 'string' || namespace.separator.length !== 1)) {
+            fail(path + '.separator', 'must be a single character');
+        }
+        if (namespace.type !== undefined && !['personal', 'user', 'shared'].includes(namespace.type)) {
+            fail(path + '.type', 'must be "personal", "user" or "shared"');
+        }
+    });
+}

package/dist/cjs/store-operations.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Changes of the message store that IMAP commands and the control API share: expunge, flag changes, and the
+ * mailbox operations of DELETE, RENAME, SUBSCRIBE and UNSUBSCRIBE. Each one tells the sessions about the change
+ * the way another session's command would (EXISTS, EXPUNGE, unsolicited FETCH, BYE, `mailbox` events). The
+ * session that caused a change is `server.activeConnection` (null for the control API), the commands keep only
+ * what is specific to a session: argument checks, the selected mailbox, read-only state and the responses.
+ */
+import type { IMAPConnection, IMAPServer, Mailbox, Message } from './types.js';
+/** the XOAUTH2 session timeout of the default user, and of a user the control API adds without one */
+declare const DEFAULT_SESSION_TIMEOUT: number;
+/** An error of a failed store operation or control API call, `code` is a RFC 5530 response code or INVALID */
+declare class ImapKitError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Creates an error for a failed operation, with a RFC 5530 response code
+ *
+ * @param {String} message Error message
+ * @param {String} code Response code, e.g. "NONEXISTENT"
+ * @return {Error} Error object
+ */
+declare function storeError(message: string, code: string): ImapKitError;
+interface ExpungeOptions {
+    /** the session that caused the expunge, for the `expunge` event (QRESYNC, NOTIFY), defaults to the active session */
+    origin?: IMAPConnection | null | undefined;
+    /** a session that gets no EXPUNGE and no EXISTS responses (CLOSE) */
+    skip?: IMAPConnection | false | null | undefined;
+    /** a session that gets the EXPUNGE responses but no EXISTS response (EXPUNGE, MOVE) */
+    skipExists?: IMAPConnection | false | null | undefined;
+    /** the EXPUNGE responses go from the highest UID to the lowest (MESSAGELIMIT, RFC 9738 section 3.1) */
+    highestFirst?: boolean | undefined;
+}
+/**
+ * Removes messages from a mailbox and tells the sessions that have it selected with EXPUNGE responses
+ * (VANISHED with QRESYNC) and a new EXISTS. The `expunge` event goes out before the notifications
+ *
+ * @param {Object} server IMAP server
+ * @param {Object} mailbox Mailbox of the messages
+ * @param {Array|Function} messagesOrFilterFunc Messages to remove, or a function that returns true for them
+ * @param {Object} [options] `{ origin, skip, skipExists, highestFirst }`
+ * @return {Array} the removed messages
+ */
+declare function expungeMessages(server: IMAPServer, mailbox: Mailbox, messagesOrFilterFunc: Message[] | ((message: Message) => unknown), options?: ExpungeOptions): Message[];
+/**
+ * Tells the sessions that have a mailbox selected about changed flags, they get an untagged FETCH with the
+ * new flags (RFC 3501 section 5.2)
+ *
+ * @param {Object} server IMAP server
+ * @param {Object} mailbox Mailbox of the messages
+ * @param {Array} messages Messages with changed flags
+ * @param {Object} [ignoreConnection] A session that is not told, e.g. the one whose STORE changed the flags
+ */
+declare function notifyFlagChanges(server: IMAPServer, mailbox: Mailbox, messages: Message[], ignoreConnection?: IMAPConnection | null): void;
+type FlagMode = 'set' | 'add' | 'remove';
+/**
+ * Checks flags the way STORE does: system flags the server knows (never \Recent), valid keywords, and only
+ * permanent flags in a mailbox that does not allow new keywords
+ *
+ * @param {Object} server IMAP server
+ * @param {Object} mailbox Mailbox the flags are for
+ * @param {Array} flags Flags to check
+ * @param {Boolean} stored true if the flags are stored, so they must be permanent flags of the mailbox
+ * @return {Array} the normalized flags without duplicates
+ * @throws {Error} INVALID for a flag that can not be used
+ */
+declare function checkFlags(server: IMAPServer, mailbox: Mailbox, flags: unknown, stored: boolean): string[];
+/**
+ * Changes the flags of messages outside of a STORE command. The flags follow the rules of STORE: system flags
+ * the server knows (never \Recent), valid keywords, and only permanent flags in a mailbox that does not allow
+ * new keywords. Plugins learn about the changed messages from the `flags` event `(mailbox, messages, origin)`
+ * before the sessions are told (CONDSTORE gives them new mod-sequences there)
+ *
+ * @param {Object} server IMAP server
+ * @param {Object} mailbox Mailbox of the messages
+ * @param {Array} messages Messages to change
+ * @param {Array} flags Flags to set, add or remove
+ * @param {String} mode "set", "add" or "remove"
+ * @return {Array} the messages whose flags changed
+ */
+declare function changeFlags(server: IMAPServer, mailbox: Mailbox, messages: Message[], flags: string[], mode: FlagMode): Message[];
+/**
+ * Creates a mailbox (CREATE), with any missing superior hierarchy levels
+ *
+ * @param {Object} server IMAP server
+ * @param {String} path Storage name of the mailbox
+ * @return {Object} the created mailbox
+ * @throws {Error} with a RFC 5530 `code` (ALREADYEXISTS, CANNOT ...)
+ */
+declare function createMailbox(server: IMAPServer, path: string): Mailbox;
+/**
+ * Deletes a mailbox (DELETE). Other sessions that have it selected are disconnected with an untagged BYE
+ * (RFC 2180 section 3.3, RFC 2683 section 3.1.2), as they can not be told about the deletion in any other way
+ *
+ * @param {Object} server IMAP server
+ * @param {String} path Storage name of the mailbox
+ * @throws {Error} with a RFC 5530 `code` (NONEXISTENT, CANNOT, HASCHILDREN ...)
+ */
+declare function deleteMailbox(server: IMAPServer, path: string): void;
+/**
+ * Renames a mailbox (RENAME). Renaming INBOX moves its messages to the new mailbox and leaves INBOX
+ * empty (RFC 3501 section 6.3.5). Everything that can be checked is checked up front, so that a failed
+ * rename never loses the source
+ *
+ * @param {Object} server IMAP server
+ * @param {String} source Storage name of the mailbox
+ * @param {String} destination New storage name
+ * @return {Object} `{ path, mailbox }`: the new name, and the source mailbox object, which is INBOX itself for
+ *   a rename of INBOX
+ * @throws {Error} with a RFC 5530 `code` (NONEXISTENT, ALREADYEXISTS, CANNOT ...)
+ */
+declare function renameMailbox(server: IMAPServer, source: string, destination: string): {
+    path: string;
+    mailbox: Mailbox;
+};
+type UidMode = 'keep' | 'renumber' | 'shuffle' | 'offset';
+interface UidValidityOptions {
+    /** the new UIDVALIDITY, it must be greater than the current one. Default: one above every value in use */
+    uidvalidity?: number | undefined;
+    /** what happens to the UIDs: "keep" (default), "renumber" (1 to n in the current order), "shuffle" (1 to n in a
+     * random order) or "offset" (every UID moves above the old UIDNEXT, plus `offset`) */
+    uids?: UidMode | undefined;
+    /** extra gap for "offset" */
+    offset?: number | undefined;
+    /** seed of the "shuffle" order, for repeatable tests */
+    seed?: number | undefined;
+}
+/**
+ * Gives a mailbox a new UIDVALIDITY, optionally with new UIDs. A UID never changes during a session (RFC 9051
+ * section 2.3.1.1), so the sessions that have the mailbox selected are disconnected with BYE, and the new value
+ * is greater than every earlier one, as UIDs that do not persist require. A client that keeps its cached UIDs
+ * without checking UIDVALIDITY gets other messages ("shuffle") or none ("offset") for them
+ *
+ * @param {Object} server IMAP server
+ * @param {Object} mailbox Mailbox, not \Noselect
+ * @param {Object} [options] `{ uidvalidity, uids, offset, seed }`
+ * @return {Object} `{ uidvalidity, uidnext, uids }`, `uids` maps every old UID to its new one
+ * @throws {Error} INVALID for a UIDVALIDITY that is not greater, or invalid options
+ */
+declare function resetUidValidity(server: IMAPServer, mailbox: Mailbox, options?: UidValidityOptions): {
+    uidvalidity: number;
+    uidnext: number;
+    uids: {
+        uid: number;
+        newUid: number;
+    }[];
+};
+/**
+ * Subscribes a mailbox (SUBSCRIBE), only an existing mailbox can be subscribed
+ *
+ * @param {Object} server IMAP server
+ * @param {String} path Storage name of the mailbox
+ * @return {Boolean} true if the subscription changed
+ * @throws {Error} NONEXISTENT for a name that is not a mailbox
+ */
+declare function subscribeMailbox(server: IMAPServer, path: string): boolean;
+/**
+ * Unsubscribes a name (UNSUBSCRIBE). The subscription list holds names, so a name stays removable after its
+ * mailbox is deleted (RFC 3501 section 6.3.6). Removing a name that is not subscribed is not an error
+ * (RFC 9051 section 6.3.8)
+ *
+ * @param {Object} server IMAP server
+ * @param {String} path Storage name
+ * @return {Boolean} true if the subscription changed
+ */
+declare function unsubscribeMailbox(server: IMAPServer, path: string): boolean;
+export { DEFAULT_SESSION_TIMEOUT, ImapKitError, storeError, expungeMessages, notifyFlagChanges, checkFlags, changeFlags, createMailbox, deleteMailbox, renameMailbox, resetUidValidity, subscribeMailbox, unsubscribeMailbox };
+export type { ExpungeOptions, FlagMode, UidMode, UidValidityOptions };