imapkit 4.0.2 → 4.1.0

package/dist/cjs/server.d.ts

@@ -0,0 +1,876 @@
+import { Stream } from 'node:stream';
+import net from 'node:net';
+import tls from 'node:tls';
+import type { CompilerOptions, ParserOptions } from 'imap-handler';
+import type { ResolvedCommandOptions } from './command-states.js';
+import type { AppendCheck, AppendCheckOptions, AppendDataHandler, AppendMessage, CapabilityCheck, CheckResult, ClosedCheck, CommandCheck, CommandContext, CommandOptions, CommandHandler, ConnectionHandler, ConnectionState, CopyHandler, FetchHandler, IMAPResponse, IMAPServerOptions, ListedMailbox, LiteralFilter, Mailbox, MailboxHandler, MailboxStatus, Message, MessageFilter, MessageHandler, MessageRange, Namespace, Notification, NotifyEvent, NotifyFilter, OutputHandler, ParsedCommand, RangeLimit, Refusal, SearchAccessCheck, SearchHandler, SearchLimit, ServerStorage, StatusHandler, StorageMailbox, StorageMessage, StoreHandler, SubscriptionStandIn, Transport, UrlAccessCheck, UserData } from './types.js';
+declare const TAG_REGEX: RegExp;
+/**
+ * Creates a new IMAP server, call `listen()` on it to start accepting connections
+ *
+ * @param options Server options, the mailbox tree comes from `options.storage`
+ * @return Server instance
+ */
+export default function server(options?: IMAPServerOptions): IMAPServer;
+declare class IMAPServer extends Stream {
+    [key: string]: any;
+    options: IMAPServerOptions;
+    server: net.Server | tls.Server;
+    connections: Set<IMAPConnection>;
+    connectionHandlers: ConnectionHandler[];
+    resetHandlers: ConnectionHandler[];
+    outputHandlers: OutputHandler[];
+    messageHandlers: MessageHandler[];
+    fetchHandlers: Record<string, FetchHandler>;
+    fetchFilters: MessageFilter[];
+    searchHandlers: Record<string, SearchHandler>;
+    storeHandlers: Record<string, StoreHandler>;
+    storeFilters: MessageFilter[];
+    notifyFilters: NotifyFilter[];
+    mailboxHandlers: MailboxHandler[];
+    appendChecks: AppendCheck[];
+    copyHandlers: CopyHandler[];
+    appendDataHandlers: Record<string, AppendDataHandler>;
+    literalFilters: LiteralFilter[];
+    urlAccessChecks: UrlAccessCheck[];
+    searchAccessChecks: SearchAccessCheck[];
+    commandChecks: CommandCheck[];
+    rangeLimits: RangeLimit[];
+    searchLimits: SearchLimit[];
+    closedChecks: ClosedCheck[];
+    multiAppend: boolean;
+    /** set by BINARY (RFC 3516 section 4.4), converts the octets of an APPEND literal8 to the stored message source */
+    appendLiteral8?: ((raw: string) => string) | undefined;
+    commandHandlers: Record<string, CommandHandler>;
+    commandOptions: Record<string, ResolvedCommandOptions>;
+    capabilities: Record<string, CapabilityCheck>;
+    allowedStatus: string[];
+    statusHandlers: Record<string, StatusHandler>;
+    literalPlus: boolean;
+    nonSyncLiteralLimit: number;
+    parserOptions: ParserOptions;
+    /** the personal namespace that an empty LIST reference stands for, set by indexFolders() */
+    referenceNamespace: string | false;
+    activeConnection: IMAPConnection | null;
+    users: Record<string, UserData>;
+    systemFlags: string[];
+    storage: ServerStorage;
+    uidvalidityCounter: number;
+    subscriptions: Set<string>;
+    folderCache: Record<string, Mailbox>;
+    constructor(options?: IMAPServerOptions);
+    /**
+     * Starts accepting connections, takes the arguments of `net.Server#listen()`
+     */
+    listen(port?: number, listeningListener?: () => void): void;
+    listen(port: number, hostname: string, listeningListener?: () => void): void;
+    listen(options: net.ListenOptions, listeningListener?: () => void): void;
+    close(callback?: (err?: Error) => void): void;
+    /**
+     * Returns TLS key and certificate. Without credentials in the options the
+     * bundled self-signed certificate for localhost is used.
+     *
+     * @return {Object} TLS options
+     */
+    getCredentials(): {
+        key: string | Buffer;
+        cert: string | Buffer;
+    };
+    address(): ReturnType<net.Server['address']>;
+    createClient(socket: net.Socket): void;
+    registerCapability(keyword: string, handler?: CapabilityCheck | null): void;
+    /**
+     * Sets the handler of a command
+     *
+     * @param {String} command Command name, e.g. "UID MOVE"
+     * @param {Function} handler Command handler `(connection, parsed, data, callback)`
+     * @param {Object|Array} [options] `{ states, noArguments, mailboxArguments, astringArguments, searchCriteria, sequenceSet,
+     *   noExpunge, literal8, noPipelining }`: the connection states the command is valid in (any state if not set), if it takes
+     *   no arguments, the positions of its mailbox name arguments and of its other astring arguments, the position where its search criteria start, the position of its argument
+     *   with message sequence numbers, if EXPUNGE responses
+     *   are not allowed while it runs, if it accepts literal8 arguments (true, or the name of the capability that
+     *   allows them), and if it is refused when the client sent more input after it. A list is read as the states.
+     *   Without options, a command keeps its earlier settings
+     */
+    setCommandHandler(command: string, handler: CommandHandler, options?: CommandOptions | string[] | null): void;
+    /**
+     * Returns the options of a command, see setCommandHandler
+     *
+     * @param {String} command Command name
+     * @return {Object} the command options, see setCommandHandler, states is false if any state is fine
+     */
+    getCommandOptions(command: string | null | undefined): ResolvedCommandOptions;
+    /**
+     * Returns the connection states a command may be used in. Public API for custom plugins (see README), the server
+     * itself reads getCommandOptions
+     *
+     * @param {String} command Command name
+     * @return {Array|Boolean} List of states, or false if any state is fine
+     */
+    getCommandStates(command: string): string[] | false;
+    /**
+     * Returns a user account
+     *
+     * @param {String} username User name
+     * @return {Object|false} User data or false if there is no such user
+     */
+    getUser(username: unknown): UserData | false;
+    /**
+     * Returns a mailbox object from folderCache
+     *
+     * @param {String} path Pathname for the mailbox
+     * @return {Object} mailbox object or undefined
+     */
+    getMailbox(path: string): Mailbox | undefined;
+    /**
+     * Schedules a notifying message
+     *
+     * @param {Object} command An object of untagged response message
+     * @param {Object|String} mailbox Mailbox the message is related to
+     * @param {Object} ignoreConnection if set the selected connection ignores this notification
+     * @param {Function} [filter] if set, only connections for which `filter(connection)` is true get the notification
+     */
+    notify(command: Notification, mailbox: Mailbox | string | false | null | undefined, ignoreConnection?: IMAPConnection | false | null, filter?: ((connection: IMAPConnection) => boolean) | false | null): void;
+    /**
+     * Tells plugins that a mailbox was created, deleted, renamed, subscribed or unsubscribed, with a
+     * `mailbox` event: `{ type, path, oldPath, mailbox, origin }`. `type` is "create", "delete", "rename",
+     * "subscribe" or "unsubscribe", `origin` is the session that made the change
+     *
+     * @param {String} type Kind of change
+     * @param {String} path Storage name of the mailbox
+     * @param {Object} [details] `{ oldPath, mailbox }`: the earlier name of a renamed mailbox, the mailbox
+     *   object that a DELETE removed
+     */
+    mailboxChanged(type: string, path: string, details?: {
+        oldPath?: string | undefined;
+        mailbox?: Mailbox | undefined;
+    }): void;
+    /**
+     * Retrieves the handler of an IMAP command
+     *
+     * @param {String} command Command name
+     * @return {Function} handler for the specified command
+     */
+    getCommandHandler(command: string | null | undefined): CommandHandler | false;
+    /**
+     * Returns some useful information about a mailbox that can be used with STATUS, SELECT and EXAMINE
+     *
+     * @param {Object|String} mailbox Mailbox object or path
+     */
+    getStatus(path: Mailbox | string): MailboxStatus | false;
+    /**
+     * Validates a date value. Useful for validating APPEND dates
+     *
+     * @param {String} date Date value to be validated
+     * @return {Boolean} Returns true if the date string is in IMAP date-time format
+     */
+    validateInternalDate(date: unknown): boolean;
+    /**
+     * Converts a date object to a valid date-time string format
+     *
+     * @param {Object} date Date object to be converted
+     * @return {String} Returns a valid date-time formatted string
+     */
+    formatInternalDate(date: Date): string;
+    /**
+     * Creates a mailbox with specified path
+     *
+     * @param {String} path Pathname for the mailbox
+     * @param {Object} [defaultMailbox] use this object as the mailbox to add instead of empty'
+     * @return {Object} the created mailbox
+     */
+    createMailbox(path: string, defaultMailbox?: StorageMailbox | null): Mailbox;
+    /**
+     * Deletes a mailbox with specified path
+     *
+     * @param {String} path Pathname for the mailbox
+     * @param {boolean} keepContents If true do not delete messages
+     */
+    deleteMailbox(path: string, keepContents?: boolean): void;
+    /**
+     * Finds the personal namespace that a new or existing mailbox name belongs to, for CREATE and DELETE
+     *
+     * @param {String} path Mailbox path
+     * @return {Object} `{ namespace, storage }`, the namespace key and its storage object
+     * @throws {Error} CANNOT for a namespace prefix or a name in no namespace, NOPERM outside personal namespaces
+     */
+    getPersonalNamespace(path: string): {
+        namespace: string;
+        storage: Namespace;
+    };
+    /**
+     * Removes a trailing hierarchy separator from a mailbox name, "foo/" names the mailbox "foo"
+     *
+     * @param {String} path Mailbox path
+     * @param {String} separator Hierarchy separator
+     * @return {String} path without the separator at the end
+     */
+    stripSeparator(path: string, separator: string): string;
+    /**
+     * Checks if the personal namespace is below INBOX (e.g. "INBOX."), then the mailboxes of that namespace are
+     * the children of INBOX
+     *
+     * @return {Boolean} true if the reference namespace is INBOX followed by the separator
+     */
+    inboxHoldsNamespace(): boolean;
+    /**
+     * Rebuilds folderCache and the path, namespace and flags of every mailbox from storage.
+     * INBOX has its own namespace
+     *
+     * @param {Boolean} [processMessages] If true, messages are prepared as well. Only needed for
+     *   messages from the initial storage, as message handlers must not run twice for a message
+     */
+    indexFolders(processMessages?: boolean): void;
+    /**
+     * Ensures uid, flags and internaldate for every message of a mailbox and
+     * keeps the message list ordered by UID
+     *
+     * @param {Object} mailbox Mailbox object
+     */
+    processMessages(mailbox: Mailbox): void;
+    /**
+     * Sets the path, namespace, flags and counters of a mailbox from storage or a new one, and runs the
+     * mailbox handlers of plugins on it
+     *
+     * @param path Mailbox path
+     * @param mailbox Mailbox object, completed in place
+     * @param namespace Namespace key of the mailbox
+     */
+    processMailbox(path: string, mailbox: StorageMailbox, namespace: string): asserts mailbox is Mailbox;
+    /**
+     * Makes `mailbox.subscribed` read and change the subscription of the mailbox name in
+     * `server.subscriptions`, so that the subscription stays with the name when the mailbox is deleted
+     * or renamed (RFC 3501 section 6.3.6, RFC 9051 section 6.3.6). A `subscribed` value the mailbox
+     * already has (from storage) is moved over to the subscription list.
+     *
+     * @param {Object} mailbox Mailbox object, its `path` is read whenever the subscription is used
+     * @param {Boolean} [defaultValue] Subscription of a mailbox without a `subscribed` value. If not
+     *   set, the subscription list is left as it is
+     */
+    trackSubscription(mailbox: StorageMailbox, defaultValue?: boolean): void;
+    /**
+     * Sets the stored children attribute of a mailbox (RFC 3348 section 3). A \Noinferiors mailbox gets
+     * neither, \Noinferiors already implies \HasNoChildren (RFC 5258 section 3.4)
+     *
+     * @param {Object} mailbox Mailbox object
+     * @param {Boolean} hasChildren true if the mailbox has child mailboxes
+     */
+    setChildrenFlags(mailbox: Mailbox, hasChildren: boolean): void;
+    /**
+     * Ensures that a list of flags includes selected flag
+     *
+     * @param {Array} flags An array of flags to check
+     * @param {String} flag If the flag is missing, add it
+     */
+    ensureFlag(flags: string[], flag: string): void;
+    /**
+     * Removes a flag from a list of flags
+     *
+     * @param {Array} flags An array of flags to check
+     * @param {String} flag If the flag is in the list, remove it
+     */
+    removeFlag(flags: string[], flag: string): void;
+    /**
+     * Remembers the flags of a message as flags of the mailbox. A keyword stays in the FLAGS and
+     * PERMANENTFLAGS of the mailbox after the last message with it is expunged or loses it, like a
+     * keyword a client defined (RFC 3501 section 2.3.2, FLAGS lists the flags applicable for the
+     * mailbox, section 7.2.6)
+     *
+     * @param {Object} mailbox Mailbox object
+     * @param {Array} flags Flags of a message
+     */
+    rememberFlags(mailbox: Mailbox, flags: string[]): void;
+    /**
+     * Converts a date-time value from storage or a client to the form it is sent in
+     *
+     * @param {Date|String} value Date object or date-time string
+     * @return {String|*} date-time string, other values are returned as they are
+     */
+    normalizeDateTime(value: string | Date): string;
+    normalizeDateTime(value: unknown): unknown;
+    /**
+     * Sets the UID, flags, internal date and source of a message from storage or a new one, and runs the
+     * message handlers of plugins on it
+     *
+     * @param message Message object, completed in place
+     * @param mailbox Mailbox of the message
+     */
+    processMessage(message: StorageMessage, mailbox: Mailbox): asserts message is Message;
+    /**
+     * Appends a message to a mailbox
+     *
+     * @param {Object|String} mailbox Mailbox to append to
+     * @param {Array} flags Flags for the message
+     * @param {String|Date} internaldate Receive date-time for the message
+     * @param {String} raw Message source
+     * @param {Object} [ignoreConnection] To not advertise new message to selected connection
+     * @param {Object} [properties] More properties of the new message, set before message handlers run
+     * @return An object of the form { mailbox, message }
+     */
+    appendMessage(path: Mailbox | string, flags: string[], internaldate: string | Date | false | null | undefined, raw: string, ignoreConnection?: IMAPConnection | false | null, properties?: Record<string, any>): {
+        mailbox: Mailbox;
+        message: Message;
+    };
+    /**
+     * Copies a message to a mailbox (COPY, MOVE, RENAME INBOX). The copy is a new message that
+     * keeps the flags, internal date and content of the source. `copyHandlers` can carry over more
+     * properties of the source, they run before the message handlers see the copy
+     *
+     * @param {Object} mailbox Target mailbox
+     * @param {Object} source Message to copy
+     * @return An object of the form { mailbox, message }
+     */
+    copyMessage(mailbox: Mailbox, source: Message): {
+        mailbox: Mailbox;
+        message: Message;
+    };
+    /**
+     * Returns the namespace a mailbox path belongs to by its prefix, INBOX not included
+     *
+     * @param {String} path Mailbox path, it does not have to exist
+     * @return {String|Boolean} the longest matching namespace key, or false
+     */
+    getNamespace(path: string): string | false;
+    /**
+     * Checks if messages can be added to a mailbox (APPEND, COPY, MOVE). TRYCREATE tells the client that CREATE would
+     * help (RFC 3501 sections 6.3.11 and 6.4.7), also for a \\Noselect name, which CREATE turns into a mailbox (RFC 9051
+     * sections 6.3.12 and 6.4.7: unless it is certain that the target can not be created)
+     *
+     * @param {String} path Storage name of the target mailbox
+     * @return {Object|Boolean} `{ command, code, text }` of the refusal, or false if the mailbox can take messages
+     */
+    targetRefusal(path: string): Refusal | false;
+    /**
+     * Returns the namespace of a mailbox name: "INBOX" for INBOX, the namespace of the mailbox if it
+     * exists (the children of INBOX belong to the personal namespace), otherwise the one of its prefix
+     *
+     * @param {String|Object} path Mailbox path, it does not have to exist, or a mailbox object
+     * @return {String|Boolean} namespace key, or false if the name is in no namespace
+     */
+    getMailboxNamespace(path: string | {
+        namespace: string | false;
+    }): string | false;
+    /**
+     * Checks if a mailbox name is in a personal namespace, INBOX included
+     *
+     * @param {String|Object} path Mailbox path, it does not have to exist, or a mailbox object
+     * @return {Boolean} true for a personal mailbox
+     */
+    isPersonal(path: string | {
+        namespace: string | false;
+    }): boolean;
+    /**
+     * Returns the hierarchy separator of a mailbox name, from its namespace
+     *
+     * @param {String|Object} path Mailbox path, it does not have to exist, or a mailbox object
+     * @return {String} separator
+     */
+    getSeparator(path: string | {
+        namespace: string | false;
+    }): string;
+    /**
+     * Returns the name one hierarchy level up from a mailbox name. A trailing separator is ignored, the
+     * prefix of a namespace (e.g. "#shared" of "#shared/") is not a mailbox name
+     *
+     * @param {String} path Mailbox path, it does not have to exist
+     * @return {String|Boolean} parent name, "INBOX" for the children of INBOX, or false at the top level
+     */
+    getParentPath(path: string): string | false;
+    /**
+     * Returns the mailboxes below a mailbox name, at any depth
+     *
+     * @param {String} path Mailbox path
+     * @param {Object} [folders] Mailboxes to choose from by path, defaults to all mailboxes (folderCache)
+     * @return {Array} mailbox objects
+     */
+    getDescendants(path: string): Mailbox[];
+    getDescendants<T extends ListedMailbox>(path: string, folders: Record<string, T> | null | undefined): T[];
+    /**
+     * Checks if any mailbox below a mailbox name passes a test, stops at the first one that does
+     *
+     * @param {String} path Mailbox path
+     * @param {Function} predicate `(mailbox)` returns true for a match
+     * @return {Boolean} true if a mailbox below the name matches
+     */
+    hasDescendant(path: string, predicate: (mailbox: Mailbox) => unknown): boolean;
+    /**
+     * Returns the mailbox attributes of a LIST response with computed children attributes (RFC 3348, RFC 5258
+     * section 4), for extended and unsolicited LIST responses. The stored \HasChildren and \HasNoChildren are
+     * replaced, a name that does not exist is \NonExistent (RFC 5258 section 3, it implies \Noselect)
+     *
+     * @param {Object} [mailbox] Mailbox object, can be left out for a name that does not exist
+     * @param {Object} options `{ exists, subscribed, hasChildren, extra }`: false `exists` lists the name as
+     *   \NonExistent, `subscribed` adds \Subscribed, `extra` lists more attributes (e.g. \NoAccess)
+     * @return {Array} attribute names
+     */
+    listAttributes(mailbox: {
+        flags?: string[] | undefined;
+    } | null | undefined, options: {
+        exists?: boolean | undefined;
+        subscribed?: boolean | undefined;
+        hasChildren?: boolean | undefined;
+        extra?: string[] | undefined;
+    }): string[];
+    /**
+     * Lists the mailboxes that match a LIST or LSUB reference and pattern (RFC 3501 section 6.3.8)
+     *
+     * @param {String} reference Reference name
+     * @param {String} match Mailbox name with possible wildcards
+     * @param {Function} [exportName] Converts storage names to the form the client uses, so that the
+     *   wildcards match whole characters, see IMAPConnection#exportMailboxName
+     * @param {Object} [folders] Mailboxes to choose from by path, defaults to all mailboxes (folderCache)
+     * @return {Array} Matching mailbox objects
+     */
+    matchFolders(reference: string | null | undefined, match: string, exportName?: ((name: string) => string) | null): Mailbox[];
+    matchFolders<T extends ListedMailbox>(reference: string | null | undefined, match: string, exportName: ((name: string) => string) | null | undefined, folders: Record<string, T> | null | undefined): T[];
+    /**
+     * Returns the subscribed names with their superior hierarchy levels, for LSUB and LIST (SUBSCRIBED).
+     * Names that are not mailboxes get a stand-in object with \Noselect, which LIST-EXTENDED reports as
+     * \NonExistent (RFC 5258 section 3), and `subscribed` false for a level that is only listed because
+     * of a subscribed name below it
+     *
+     * @return {Object} path to mailbox object or stand-in, usable as the `folders` of matchFolders
+     */
+    getSubscriptionTree(): Record<string, Mailbox | SubscriptionStandIn>;
+    /**
+     * Retrieves an array of messages that fit in the specified range criteria
+     *
+     * @param {Object|String} mailbox Mailbox to look for the messages
+     * @param {String} range Message range (eg. "*:4,5,7:9")
+     * @param {Boolean} isUid If true, use UID values, not sequence indexes for comparison
+     * @return {Array} An array of messages in the form of [[seqIndex, message]]
+     */
+    getMessageRange(source: Mailbox | Message[] | string, sequence: string | number | null | undefined, isUid: boolean): MessageRange;
+}
+/** A queued client command */
+interface QueuedCommand {
+    parsed: ParsedCommand;
+    data: string;
+}
+declare class IMAPConnection {
+    [key: string]: any;
+    server: IMAPServer;
+    socket: net.Socket | null;
+    options: IMAPServerOptions;
+    state: ConnectionState;
+    /** the authenticated user, set by LOGIN and the AUTHENTICATE plugins */
+    username: string | false | undefined;
+    selectedMailbox: Mailbox | false | undefined;
+    readOnly: boolean | undefined;
+    /** messages that are \Recent in this session, while a mailbox is selected */
+    recent: Set<Message> | null | undefined;
+    everSelected: boolean | undefined;
+    secureConnection: boolean;
+    upgrading: boolean | undefined;
+    /** takes over raw input lines from the command parser (IDLE, AUTHENTICATE) */
+    inputHandler: ((line: string) => void) | false;
+    transport: Transport | null;
+    parserOptions: ParserOptions;
+    compilerOptions: CompilerOptions;
+    messageGlobal: boolean;
+    /** notifications are sent right away instead of before the next tagged response (IDLE) */
+    directNotifications: boolean;
+    notificationQueue: Notification[];
+    _remainder: string;
+    _command: string;
+    _literalRemaining: number;
+    _commandQueue: QueuedCommand[];
+    _processing: boolean;
+    _runningCommand: QueuedCommand | null | undefined;
+    _notificationCallback: (event: NotifyEvent) => void;
+    _closing: boolean | undefined;
+    _readCount: number | undefined;
+    _unsafeCompletedRead: number | undefined;
+    _discardLine: string | false | undefined;
+    _skipCommand: boolean | undefined;
+    _earlyLiteral: boolean | undefined;
+    _pipelinedAfter: {
+        command: string;
+        read: number | undefined;
+    } | undefined;
+    constructor(server: IMAPServer, socket: net.Socket);
+    /**
+     * Writes protocol output to the client, through the transport layer if there is one
+     *
+     * @param {Buffer|String} data Data to send, a string is sent as a binary string
+     */
+    write(data: Buffer | string): void;
+    /**
+     * Writes data to the socket, below the transport layer
+     *
+     * @param {Buffer} data Data to send
+     */
+    writeRaw(data: Buffer | string): void;
+    /**
+     * Handles data from the socket, through the transport layer if there is one
+     *
+     * @param {Buffer} chunk Received data
+     */
+    receive(chunk: Buffer): void;
+    /**
+     * Closes the connection once everything sent so far, including data a transport layer still
+     * holds, is written out
+     */
+    end(): void;
+    /**
+     * Sends an untagged BYE, drops unprocessed input and closes the connection (RFC 3501 section 7.1.5)
+     *
+     * @param {String} text Human readable explanation
+     * @param {String} [description] Description for output handlers
+     */
+    bye(text: string, description?: string): void;
+    /**
+     * Checks if the client sent anything after the command that is running, that is not processed yet
+     *
+     * @return {Boolean} true if there is unprocessed input or a queued command
+     */
+    hasPendingInput(): boolean;
+    /**
+     * Checks if a command is running or waiting, for checks that must not run ahead of earlier commands
+     *
+     * @return {Boolean} true if a command is running or queued
+     */
+    isBusy(): boolean;
+    /**
+     * Checks if a command was sent together with a command that was refused for the noPipelining option (STARTTLS,
+     * COMPRESS): it arrived in the same read, before the client could see the refusal
+     *
+     * @return {Boolean} true if the command must be refused
+     */
+    isPipelinedAfterRefusal(): boolean;
+    /**
+     * Refuses a command that was pipelined after a refused noPipelining command, without running it
+     *
+     * @param {Object} parsed Parsed command
+     * @param {String} data Raw command
+     */
+    refusePipelined(parsed: CommandContext, data: string): void;
+    /**
+     * Drops input that is not processed yet, including queued commands
+     */
+    discardInput(): void;
+    /**
+     * Returns the connection to the Not Authenticated state and resets everything but the TLS
+     * layer (RFC 8437 section 3): the selected mailbox is closed without EXPUNGE responses, and the
+     * plugins clear their session state (ENABLEd extensions, CONDSTORE, COMPRESS, ...) with
+     * server.resetHandlers. Call it after the response that ends the session was sent.
+     */
+    resetSession(): void;
+    /**
+     * Closes the selected mailbox, if there is one, and returns to the Authenticated state (CLOSE, UNSELECT, a failed
+     * SELECT or EXAMINE, RFC 3501 section 6.3.1). The read-only mode, the \Recent set of the session and the
+     * notifications that were not sent yet are dropped. Sends nothing, the caller answers the command
+     */
+    closeMailbox(): void;
+    onClose(): void;
+    onError(err: Error): void;
+    onData(chunk: Buffer): void;
+    /**
+     * Reads literal data that the current command is waiting for. The data of a command that was
+     * refused is dropped.
+     *
+     * @param {String} str Received data
+     * @return {String} the data that follows the literal
+     */
+    readLiteral(str: string): string;
+    /**
+     * Sends a BAD response to input that did not make it to a command handler
+     *
+     * @param {String} tag Tag to answer with, "*" for an untagged response
+     * @param {String} text Human readable text
+     * @param {String} description Description for output handlers
+     * @param {String} [data] Raw input
+     */
+    sendBad(tag: string, text: string, description: string, data?: string): void;
+    /**
+     * Checks if a literal may be accepted for the command line received so far. Literals are
+     * refused before they are read when they are too large, or when the command is unknown or
+     * not allowed in the current state, so the client does not get a continuation request for
+     * a command that is going to fail anyway.
+     *
+     * @param {String} line The command received so far (with earlier literals), up to the literal size marker
+     * @param {Number} literalSize Size of the literal in octets
+     * @param {Boolean} [synchronizing] true if the literal can still be refused without reading it
+     * @param {Boolean} [literal8] The literal is a literal8 `~{n}`
+     * @return {Object|Boolean} `{ command, code, text }` for the response that refuses the literal, or false.
+     *   Responses from `server.literalFilters` have the same form
+     */
+    checkLiteral(line: string, literalSize: number, synchronizing?: boolean, literal8?: boolean): Refusal | false;
+    /**
+     * Returns the largest literal the client may send in its current state. Before
+     * authentication only small literals (user names, passwords) make sense.
+     *
+     * @return {Number} Size in bytes
+     */
+    getMaxLiteralSize(): number;
+    /**
+     * Returns the message list of the selected mailbox as this session currently
+     * sees it. When another session has expunged messages that this session has
+     * not been told about yet, sequence numbers must still refer to the old list.
+     *
+     * @return {Array} List of messages
+     */
+    getSessionMessages(): Message[];
+    /**
+     * Resolves the sequence set argument of a command to messages of the selected mailbox, as this
+     * session sees it. Plugins can replace it per connection to support other forms of sequence sets
+     * (e.g. "$" of SEARCHRES)
+     *
+     * @param {String} range Sequence set
+     * @param {Boolean} isUid If true, the set lists UIDs instead of sequence numbers
+     * @return {Array} An array of messages in the form of [[seqIndex, message]]
+     */
+    getMessageRange(range: string | number | null | undefined, isUid: boolean): MessageRange;
+    /**
+     * Lets `server.rangeLimits` cut the messages a command operates on, after its sequence set argument was resolved.
+     * A limit that returns the messages from the highest UID down sets `parsed.highestFirst`, then MOVE and UID EXPUNGE
+     * send their EXPUNGE responses in that order too
+     *
+     * @param {Object} parsed Parsed command
+     * @param {Array} range Messages of the sequence set, in the form of [[seqIndex, message]]
+     * @return {Array} the messages to operate on, in the same form
+     */
+    limitRange(parsed: ParsedCommand, range: MessageRange): MessageRange;
+    /**
+     * Resolves the sequence set argument of a command like getMessageRange, but refuses message sequence
+     * numbers past the end of the selected mailbox, as this session sees it. RFC 3501 and RFC 9051 section 9
+     * (seq-number): "The server should respond with a tagged BAD response to a command that uses a message
+     * sequence number greater than the number of messages in the selected mailbox. This includes "*" if the
+     * selected mailbox is empty." For the sequence set argument of FETCH, STORE, COPY and MOVE, SEARCH keys
+     * use getMessageRange
+     *
+     * @param {String} range Sequence set
+     * @param {Boolean} isUid If true, the set lists UIDs, these can point past the end
+     * @return {Array} An array of messages in the form of [[seqIndex, message]], see getMessageRange
+     * @throws {Error} BAD error if a sequence number is out of range
+     */
+    getCommandRange(range: string | number | null | undefined, isUid: boolean): MessageRange;
+    /**
+     * Checks if this session has EXPUNGE notifications that it has not been told about yet
+     *
+     * @return {Boolean} true if an EXPUNGE response is pending
+     */
+    hasPendingExpunge(): boolean;
+    /**
+     * Tells the other sessions that have the selected mailbox open about changed flags, they get
+     * an untagged FETCH with the new flags (RFC 3501 section 5.2)
+     *
+     * @param {Array} messages Messages with changed flags
+     */
+    notifyFlagChanges(messages: Message[]): void;
+    /**
+     * Sends unsolicited FETCH responses with the flags another session changed. The UID is always
+     * included, RFC 9051 section 6.3.13 requires it for unsolicited FETCH responses and it is valid
+     * in IMAP4rev1 as well.
+     *
+     * @param {Array} messages Messages with changed flags
+     * @param {Map} sequence Message to the sequence number this session knows it by
+     * @param {Set} [reported] Messages already reported, these are skipped and the sent ones are added
+     */
+    sendFlagUpdate(messages: Message[], sequence: Map<Message, number>, reported?: Set<Message>): void;
+    /**
+     * Checks if a message has the \Recent flag in this session
+     *
+     * @param {Object} message Message object
+     * @return {Boolean} true if the message is recent for this session
+     */
+    isRecent(message: Message): boolean;
+    /**
+     * Returns the flags of a message as seen by this session, including \Recent
+     *
+     * @param {Object} message Message object
+     * @return {Array} List of flags
+     */
+    getFlags(message: Message): string[];
+    /**
+     * Checks if FETCH may set the \Seen flag in the selected mailbox (RFC 3501 section 6.4.5).
+     * Plugins can override it for a connection, e.g. ACL without the "s" right
+     *
+     * @return {Boolean} true if \Seen may be set
+     */
+    canSetSeen(): boolean;
+    /**
+     * The refusal of a command that would change a mailbox selected read-only (EXAMINE, or SELECT answered with
+     * [READ-ONLY], RFC 3501 sections 6.3.1 and 6.3.2): STORE, EXPUNGE, UID EXPUNGE, MOVE and REPLACE. RFC 5530 section 3:
+     * CLIENTBUG, the client was told that the mailbox is read-only
+     *
+     * @return {Object|Boolean} `{ command, code, text }` if the selected mailbox is read-only, otherwise false
+     */
+    readOnlyRefusal(): Refusal | false;
+    /**
+     * Sends the refusal of readOnlyRefusal() if the selected mailbox is read-only
+     *
+     * @param {Object} parsed Parsed command
+     * @param {String} data Raw command
+     * @param {String} description Description for output handlers
+     * @return {Boolean} true if the command was refused
+     */
+    refuseReadOnly(parsed: ParsedCommand, data: string, description?: string): boolean;
+    /**
+     * Checks if CLOSE may expunge the selected mailbox (RFC 3501 section 6.4.2). Plugins can
+     * override it for a connection, e.g. ACL without the "e" right
+     *
+     * @return {Boolean} true if messages may be expunged
+     */
+    canExpunge(): boolean;
+    onNotify(notification: NotifyEvent): void;
+    /**
+     * Queues a notification for this session, it is sent before the next tagged response that allows it, or
+     * right away while notifications are direct (IDLE). Plugins can replace it per connection to drop
+     * notifications or send them at other times (e.g. NOTIFY)
+     *
+     * @param {Object} command Untagged response
+     * @param {Object} notification The `notify` event, `{ command, mailbox, ignoreConnection, filter, origin }`
+     */
+    queueNotification(command: Notification, notification?: NotifyEvent): void;
+    upgradeConnection(callback: () => void): void;
+    /**
+     * Turns the queued notifications into the responses to send. Plugins can replace it per connection
+     * to report changes in another form (e.g. VANISHED instead of EXPUNGE with QRESYNC)
+     *
+     * @param {Array} queue Queued notifications
+     * @return {Array} Notifications to send
+     */
+    prepareNotifications(queue: Notification[]): Notification[];
+    processNotifications(data?: CommandContext | null): void;
+    /**
+     * Compile a command object to a response string and write it to socket.
+     * If the command object has a skipResponse property, the command is
+     * ignored
+     *
+     * @param {Object} response Response IMAP command object to be compiled.
+     * @param {String} description
+     *   An upper-case string uniquely identifying the response for the benefit of
+     *   output handlers that wish to augment/replace the given response.
+     * @param {Object} parsed
+     *   Original parsed IMAP command that this is in response to.
+     * @param {String} data
+     *   Original raw IMAP command as a binary string.
+     * @param {Object} extra
+     *   Response-specific payload, usually the subject of the response.  For
+     *   example, the STORE command will pass the impacted message for each updated
+     *   FETCH result.  (This may have other names when used, like "affected".)
+     */
+    send(response: IMAPResponse, description?: string, parsed?: CommandContext | null, data?: string | null, ...extra: any[]): void;
+    /**
+     * Sends a tagged status response to a command
+     *
+     * @param {Object} parsed Parsed command
+     * @param {String} data Raw command
+     * @param {String} command Response type: OK, NO or BAD
+     * @param {String} text Human readable text
+     * @param {String|Array} [code] Response code, eg. "TRYCREATE", sent as [TRYCREATE], or a list of
+     *   atoms like ["METADATA", "MAXSIZE", 1024], sent as [METADATA MAXSIZE 1024]
+     * @param {String} [description] Description for output handlers, defaults to the command name,
+     *   with " FAILED" appended for NO and BAD
+     */
+    sendStatus(parsed: CommandContext, data: string | null | undefined, command: string, text: string, code?: string | number | (string | number)[] | false | null, description?: string | null): void;
+    /**
+     * Checks if a command was sent without waiting for an earlier command in a way that RFC 3501
+     * section 5.5 forbids: after any command other than FETCH, STORE or SEARCH (or another command with
+     * the noExpunge option, like SORT and THREAD from RFC 5256) the client must
+     * wait for the completion result before it sends a command with message sequence numbers,
+     * because an EXPUNGE response could change what the numbers refer to. A command was sent
+     * without waiting if such a command is still queued or running, or if it completed in the
+     * same read as this command arrived in.
+     *
+     * @param {Object} parsed Parsed command
+     * @return {Boolean} true if the command is ambiguous
+     */
+    isAmbiguous(parsed: ParsedCommand): boolean;
+    /**
+     * Checks if a command refers to messages by sequence number (RFC 3501 section 5.5)
+     *
+     * @param {Object} parsed Parsed command
+     * @return {Boolean} true if the command uses message sequence numbers
+     */
+    usesSequenceNumbers(parsed: CommandContext): boolean;
+    /**
+     * Decodes a SASL client response. It must be valid base64 by the RFC 3501 section 9 grammar,
+     * "=" stands for an empty initial response (RFC 4959 section 3).
+     *
+     * @param {String} str Client response
+     * @return {Buffer|Boolean} Decoded value, or false if the input is not valid base64
+     */
+    decodeSaslResponse(str: unknown): Buffer | false;
+    /**
+     * Returns the target mailbox of APPEND, COPY or MOVE. If messages can not be added
+     * to it, a tagged NO is sent and false is returned
+     *
+     * @param {String} path Mailbox path
+     * @param {Object} parsed Parsed command
+     * @param {String} data Raw command
+     * @param {String} description Description for the failure response
+     * @return {Object|false} Mailbox object
+     */
+    getTargetMailbox(path: string, parsed: ParsedCommand, data: string, description?: string): Mailbox | false;
+    /**
+     * Runs the checks of `server.appendChecks` before messages are added to a mailbox. A check
+     * returns nothing if the messages may be added, or `{ code, text, soft }`: a hard failure is
+     * sent as a tagged NO with the response code and false is returned, a soft one (`soft: true`)
+     * only as an untagged NO warning, e.g. `* NO [OVERQUOTA] ...` (RFC 9208 section 4.3.1).
+     *
+     * @param {Object} mailbox Target mailbox
+     * @param {Array} messages Messages to add, objects with the message source as `raw`
+     * @param {Object} parsed Parsed command
+     * @param {String} data Raw command
+     * @param {String} description Description for the failure response
+     * @param {Object} [options] `{ move, source }`, set for MOVE with the source mailbox, or `{ command, replaced }`
+     *   for APPEND like commands (APPEND, REPLACE), `replaced` is the message that REPLACE removes
+     * @return {Boolean} true if the messages may be added
+     */
+    checkAppend(mailbox: Mailbox, messages: AppendMessage[], parsed: ParsedCommand, data: string, description?: string, options?: AppendCheckOptions | null): boolean;
+    /**
+     * Reports the results of checks like `server.appendChecks`: the first hard failure as a tagged
+     * NO, or soft ones as untagged NO warnings
+     *
+     * @param {Array} results Check results, `{ code, text, soft }` or nothing
+     * @param {Object} parsed Parsed command
+     * @param {String} data Raw command
+     * @param {String} description Description for the failure response
+     * @return {Boolean} false if the command failed
+     */
+    applyChecks(results: (CheckResult | false | null | undefined | void)[], parsed: ParsedCommand, data: string, description?: string): boolean;
+    /**
+     * Converts a mailbox name from a command to the name used in storage, which is modified UTF-7
+     * (RFC 3501 section 5.1.3). A plugin can replace this per connection, e.g. UTF8=ACCEPT.
+     *
+     * @param {String} name Mailbox name as a binary string
+     * @return {String} Storage name
+     * @throws {Error} BAD error if the name is not valid
+     */
+    importMailboxName(name: string): string;
+    /**
+     * Converts a mailbox name from storage to the form sent to the client. Every response that
+     * includes a mailbox name must use this. A plugin can replace this per connection.
+     *
+     * @param {String} path Storage name
+     * @return {String} Mailbox name as a binary string
+     */
+    exportMailboxName(path: string): string;
+    scheduleCommand(data: string): void;
+    processQueue(force?: boolean): void;
+    /**
+     * Removes messages with \Deleted flag
+     *
+     * @param {Object} mailbox Mailbox to check for
+     * @param {Boolean} [ignoreSelf] If set to true, does not send any notices to itself
+     * @param {Boolean} [ignoreSelf] If set to true, does not send EXISTS notice to itself
+     */
+    expungeDeleted(mailbox: Mailbox, ignoreSelf?: boolean, ignoreExists?: boolean): void;
+    /**
+     * Given a set of messages in a mailbox (possibly via getMessageRange), remove
+     * them from the mailbox and generate EXPUNGE notifications.
+     *
+     * @param {Object} mailbox Mailbox to check for
+     * @param {Function|Array} messagesOrFilterFunc An Array of messages in the
+     *     folder that should be removed or a filtering function that indicates
+     *     messages to be removed by returning true.
+     * @param {Boolean} [ignoreSelf] If set to true, does not send any notices to itself
+     * @param {Boolean} [ignoreSelf] If set to true, does not send EXISTS notice to itself
+     * @param {Boolean} [highestFirst] If set to true, the EXPUNGE responses go from the highest UID to the lowest
+     *     (MESSAGELIMIT, RFC 9738 section 3.1), otherwise from the lowest
+     */
+    expungeSpecificMessages(mailbox: Mailbox, messagesOrFilterFunc: Message[] | ((message: Message) => unknown), ignoreSelf?: boolean, ignoreExists?: boolean, highestFirst?: boolean): void;
+}
+export { TAG_REGEX, IMAPServer, IMAPConnection };