imapkit 4.0.3 → 4.1.1

package/{lib → dist/esm}/threading.js

@@ -1,18 +1,13 @@
-'use strict';
-
 // THREAD and UID THREAD (RFC 5256 section 3) and the ORDEREDSUBJECT and REFERENCES algorithms
-
-const { states } = require('./command-states');
-const { getMessageData } = require('./mimeparser');
-const { collationKey, baseSubject, sentTime, parseMessageIds, searchMessages } = require('./sorting');
-
+import { states } from './command-states.js';
+import { getMessageData } from './mimeparser.js';
+import { collationKey, baseSubject, sentTime, parseMessageIds, searchMessages } from './sorting.js';
 /**
  * Creates a thread tree node. A node without a message is a dummy
  */
 function createNode(entry) {
     return { entry: entry || null, parent: null, children: [] };
 }
-
 // Sent date order with the sequence number as tie-breaker (RFC 5256 section 2.2). A dummy is
 // ordered by its first child
 function compareNodes(a, b) {
@@ -22,9 +17,9 @@ function compareNodes(a, b) {
     while (!b.entry && b.children.length) {
         b = b.children[0];
     }
+    // pruning leaves no dummy without children, so both have an entry here
     return a.entry.date - b.entry.date || a.entry.seq - b.entry.seq;
 }
-
 /**
  * Lists the nodes of trees in pre-order (parents before their children). Iterative, as message
  * references can make a thread as deep as the mailbox is large.
@@ -44,7 +39,6 @@ function preOrder(nodes) {
     }
     return list;
 }
-
 /**
  * Serializes thread nodes (RFC 5256 section 5): every thread is a thread-list, a node is followed by its
  * only child, or by one thread-list per child when it has more. A dummy has no number of its own.
@@ -57,7 +51,7 @@ function formatThreads(roots, isUid) {
     const output = [];
     // strings to write and nodes to expand, the next one is at the end
     const stack = [];
-    const pushLists = nodes => {
+    const pushLists = (nodes) => {
         for (let i = nodes.length - 1; i >= 0; i--) {
             stack.push(')', nodes[i], '(');
         }
@@ -72,7 +66,8 @@ function formatThreads(roots, isUid) {
         const children = item.children;
         if (children.length === 1) {
             stack.push(children[0]);
-        } else {
+        }
+        else {
             pushLists(children);
         }
         if (item.entry) {
@@ -84,7 +79,6 @@ function formatThreads(roots, isUid) {
     }
     return output.join('');
 }
-
 /**
  * ORDEREDSUBJECT (RFC 5256 section 3): messages grouped by base subject, every thread is its first
  * message with the others as children, threads ordered by the sent date of their first message
@@ -100,14 +94,14 @@ function orderedSubject(entries) {
     for (const entry of sorted) {
         if (current && current.entry.subject.id === entry.subject.id) {
             current.children.push(createNode(entry));
-        } else {
+        }
+        else {
             current = createNode(entry);
             threads.push(current);
         }
     }
     return threads.sort(compareNodes);
 }
-
 /**
  * REFERENCES (RFC 5256 section 3), steps 1 to 6
  *
@@ -117,8 +111,7 @@ function orderedSubject(entries) {
 function references(entries) {
     const byId = new Map();
     const all = [];
-
-    const getNode = id => {
+    const getNode = (id) => {
         if (!byId.has(id)) {
             const node = createNode();
             byId.set(id, node);
@@ -126,7 +119,6 @@ function references(entries) {
         }
         return byId.get(id);
     };
-
     const isDescendant = (node, ancestor) => {
         for (let current = node; current; current = current.parent) {
             if (current === ancestor) {
@@ -135,14 +127,12 @@ function references(entries) {
         }
         return false;
     };
-
-    const unlink = node => {
+    const unlink = (node) => {
         if (node.parent) {
             node.parent.children.splice(node.parent.children.indexOf(node), 1);
             node.parent = null;
         }
     };
-
     // links a parent and a child, unless that would introduce a loop. Only a node with children can have
     // the parent as a descendant, so the walk up from the parent is skipped for the others
     const link = (parent, child) => {
@@ -151,11 +141,9 @@ function references(entries) {
             child.parent = parent;
         }
     };
-
     // (1) link the messages by their references
     for (const entry of entries) {
         const header = getMessageData(entry.message).tree.parsedHeader;
-
         // (1.A) a message without a valid Message-ID, or with one that an earlier message already has, gets a unique one
         const messageId = parseMessageIds(header['message-id'])[0];
         let node = messageId !== undefined && getNode(messageId);
@@ -164,13 +152,11 @@ function references(entries) {
             all.push(node);
         }
         node.entry = entry;
-
         // the References header, or else the first Message ID of In-Reply-To
         let refs = parseMessageIds(header.references);
         if (!refs.length) {
             refs = parseMessageIds(header['in-reply-to']).slice(0, 1);
         }
-
         // (1.A) each reference is the parent of the next one, existing links are kept
         const refNodes = refs.map(getNode);
         for (let i = 1; i < refNodes.length; i++) {
@@ -178,7 +164,6 @@ function references(entries) {
                 link(refNodes[i - 1], refNodes[i]);
             }
         }
-
         // (1.B) the last reference is the parent of the message, replacing an existing link
         const parent = refNodes[refNodes.length - 1] || null;
         if (node.parent !== parent) {
@@ -188,10 +173,8 @@ function references(entries) {
             }
         }
     }
-
     // (2) messages without a parent are the top level
     const roots = all.filter(node => !node.parent);
-
     // (3) prune dummies: drop the ones without children, put the children of the others in their place,
     // but not at the top level if there is more than one child
     const replacement = (node, topLevel) => {
@@ -214,7 +197,6 @@ function references(entries) {
     top.forEach(node => {
         node.parent = null;
     });
-
     // (4) sort the top level by sent date, a dummy by its first child
     top.forEach(node => {
         if (!node.entry) {
@@ -222,12 +204,10 @@ function references(entries) {
         }
     });
     top.sort(compareNodes);
-
     // (5) gather threads with the same base subject, the subject of a dummy is the one of its first child
-    const threadSubject = node => (node.entry ? node.entry.subject : node.children[0].entry.subject);
-    const isReply = node => !!node.entry && node.entry.subject.isReply;
+    const threadSubject = (node) => (node.entry ? node.entry.subject : node.children[0].entry.subject);
+    const isReply = (node) => !!node.entry && node.entry.subject.isReply;
     const table = new Map();
-
     // (5.B) one message per base subject, a dummy or a message that is not a reply or forward is preferred
     for (const node of top) {
         const subject = threadSubject(node);
@@ -239,7 +219,6 @@ function references(entries) {
             table.set(subject.id, node);
         }
     }
-
     // (5.C) merge the other threads with the same subject into the one in the table
     const removed = new Set();
     for (const node of top) {
@@ -247,6 +226,7 @@ function references(entries) {
         if (!subject.id) {
             continue;
         }
+        // (5.B) put a node for every subject in the table
         const other = table.get(subject.id);
         if (other === node) {
             continue;
@@ -254,9 +234,11 @@ function references(entries) {
         removed.add(node);
         if (!other.entry && !node.entry) {
             node.children.forEach(child => link(other, child));
-        } else if (!other.entry || (isReply(node) && !isReply(other))) {
+        }
+        else if (!other.entry || (isReply(node) && !isReply(other))) {
             link(other, node);
-        } else {
+        }
+        else {
             // both become children of a new dummy that takes the place of the message in the table
             const dummy = createNode();
             top[top.indexOf(other)] = dummy;
@@ -266,7 +248,6 @@ function references(entries) {
         }
     }
     top = top.filter(node => !removed.has(node));
-
     // (6) sort all sets of siblings by sent date, the deepest ones first
     for (const node of preOrder(top).reverse()) {
         node.children.sort(compareNodes);
@@ -274,12 +255,10 @@ function references(entries) {
     top.sort(compareNodes);
     return top;
 }
-
 const ALGORITHMS = {
     ORDEREDSUBJECT: orderedSubject,
     REFERENCES: references
 };
-
 /**
  * Adds the THREAD and UID THREAD commands, unless another algorithm plugin did already, and the
  * THREAD=<algorithm> capability
@@ -289,38 +268,26 @@ const ALGORITHMS = {
  */
 function addThreadAlgorithm(server, algorithm) {
     server.registerCapability('THREAD=' + algorithm);
-
     if (server.threadAlgorithms) {
         server.threadAlgorithms[algorithm] = ALGORITHMS[algorithm];
         return;
     }
     server.threadAlgorithms = { [algorithm]: ALGORITHMS[algorithm] };
-
     const threadHandler = (isUid, connection, parsed, data, callback) => {
         const command = isUid ? 'UID THREAD' : 'THREAD';
         const attributes = parsed.attributes || [];
-
         // RFC 5256 section 5: thread-alg = "ORDEREDSUBJECT" / "REFERENCES" / thread-alg-ext, an atom
         const name = attributes[0] && attributes[0].type === 'ATOM' ? attributes[0].value.toUpperCase() : '';
         if (!Object.hasOwn(server.threadAlgorithms, name)) {
-            connection.sendStatus(
-                parsed,
-                data,
-                'BAD',
-                name ? 'Unsupported threading algorithm ' + name : command + ' expects a threading algorithm atom',
-                false,
-                command + ' FAILED'
-            );
+            connection.sendStatus(parsed, data, 'BAD', name ? 'Unsupported threading algorithm ' + name : command + ' expects a threading algorithm atom', false, command + ' FAILED');
             return callback();
         }
-
         const result = searchMessages(connection, parsed, data, attributes.slice(1));
         if (!result) {
             return callback();
         }
-
         // base subjects are compared with the collation (RFC 5256 sections 3 and 7)
-        const entries = result.list.map(message => {
+        const entries = result.list.map((message) => {
             const base = baseSubject(getMessageData(message).tree.parsedHeader.subject);
             return {
                 message,
@@ -330,28 +297,20 @@ function addThreadAlgorithm(server, algorithm) {
                 subject: { id: collationKey(base.subject).toString('binary'), isReply: base.isReply }
             };
         });
-
-        connection.send(
-            {
-                tag: '*',
-                command: 'THREAD',
-                // thread-data has no SP between thread-lists, so it can not be built from nested arrays
-                attributes: entries.length ? [{ type: 'TEXT', value: formatThreads(server.threadAlgorithms[name](entries), isUid) }] : []
-            },
-            command,
-            parsed,
-            data,
-            // the search result, so CONDSTORE knows about a MODSEQ search key (RFC 7162 section 3.1.9)
-            result
-        );
+        connection.send({
+            tag: '*',
+            command: 'THREAD',
+            // thread-data has no SP between thread-lists, so it can not be built from nested arrays
+            attributes: entries.length ? [{ type: 'TEXT', value: formatThreads(server.threadAlgorithms[name](entries), isUid) }] : []
+        }, command, parsed, data, 
+        // the search result, so CONDSTORE knows about a MODSEQ search key (RFC 7162 section 3.1.9)
+        result);
         connection.sendStatus(parsed, data, 'OK', command + ' completed', false, command);
         return callback();
     };
-
     // RFC 5256 section 3: EXPUNGE responses are not permitted while responding to THREAD, but are during UID THREAD.
     // The search criteria start after the algorithm and the charset
     server.setCommandHandler('THREAD', threadHandler.bind(null, false), { states: states.SELECTED, searchCriteria: 2, noExpunge: true });
     server.setCommandHandler('UID THREAD', threadHandler.bind(null, true), { states: states.SELECTED, searchCriteria: 2 });
 }
-
-module.exports = { addThreadAlgorithm };
+export { addThreadAlgorithm };

package/dist/esm/types.d.ts

@@ -0,0 +1,327 @@
+import type { IMAPServer, IMAPConnection } from './server.js';
+export type { IMAPServer, IMAPConnection };
+/**
+ * A value of the parsed command or of a response, as imap-handler parses and compiles it: an
+ * `{ type, value, section?, partial? }` node, a list (array), a string, a number or null (NIL).
+ * Commands and plugins walk these trees freely, so the type is left open.
+ */
+export type Attribute = any;
+/** A parsed client command, see imap-handler. Plugins add their own properties (e.g. `searchReturn`) */
+export interface ParsedCommand {
+    tag: string;
+    command: string;
+    attributes?: Attribute[] | undefined;
+    [key: string]: any;
+}
+/**
+ * The command a response answers, as `connection.send()` and `connection.sendStatus()` take it: a parsed
+ * command, or only the tag for input that could not be parsed (or `{ tag: '*' }` for an untagged response)
+ */
+export type CommandContext = ParsedCommand | {
+    tag: string;
+    command?: undefined;
+    attributes?: undefined;
+    [key: string]: any;
+};
+/** A response written to the client through `connection.send()` */
+export interface IMAPResponse {
+    tag: string;
+    command?: string | undefined;
+    attributes?: Attribute | Attribute[] | undefined;
+    /** set by an output handler to drop the response */
+    skipResponse?: boolean | undefined;
+    /** an unsolicited response from the notification queue, it does not flush the queue */
+    notification?: boolean | undefined;
+    [key: string]: any;
+}
+/**
+ * An untagged response distributed with `server.notify()`, queued per session in
+ * `connection.notificationQueue` until it can be sent
+ */
+export interface Notification extends IMAPResponse {
+    /** the session whose command caused the change, null for changes from SMTP */
+    origin?: IMAPConnection | null | undefined;
+    /** the new message of an EXISTS, or the removed message of an EXPUNGE */
+    message?: Message | undefined;
+    /** the removed messages of a VANISHED response (QRESYNC) */
+    messages?: Message[] | undefined;
+    /** the message list as it was before an expunge, for sessions that were not told about it yet */
+    mailboxCopy?: Message[] | undefined;
+    /** messages whose flags changed, sent as unsolicited FETCH responses */
+    flagUpdate?: Message[] | undefined;
+}
+/** The `notify` event of the server, see `server.notify()` */
+export interface NotifyEvent {
+    command: Notification;
+    /** the mailbox the change is about, false or null for changes that are not about the selected mailbox */
+    mailbox: Mailbox | string | false | null | undefined;
+    /** the session that does not get the notification */
+    ignoreConnection: IMAPConnection | false | null | undefined;
+    /** only connections for which it returns true get the notification */
+    filter: ((connection: IMAPConnection) => boolean) | false | null | undefined;
+    /** the session whose command caused the change, null for changes from outside (e.g. SMTP) */
+    origin: IMAPConnection | null;
+    [key: string]: any;
+}
+/** The `mailbox` event of the server, see `server.mailboxChanged()` */
+export interface MailboxChangeEvent {
+    /** "create", "delete", "rename", "subscribe" or "unsubscribe" */
+    type: string;
+    path: string;
+    oldPath: string | null;
+    mailbox: Mailbox | null;
+    origin: IMAPConnection | null;
+}
+export type Callback = (err?: any, ...args: any[]) => void;
+/** Handler of an IMAP command, it must send a tagged response and then call the callback */
+export type CommandHandler = (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+/** Options of a command, see `server.setCommandHandler()` and command-states.ts */
+export interface CommandOptions {
+    states?: string[] | string | false | undefined;
+    noArguments?: boolean | undefined;
+    mailboxArguments?: number[] | number | undefined;
+    astringArguments?: number[] | number | undefined;
+    searchCriteria?: number | false | undefined;
+    sequenceSet?: number | false | undefined;
+    noExpunge?: boolean | undefined;
+    /** also the name of the capability that allows literal8 (`'BINARY'`) */
+    literal8?: boolean | string | undefined;
+    noPipelining?: boolean | undefined;
+    appendMessage?: boolean | undefined;
+}
+/** A plugin, given as a function in `options.plugins` or built in */
+export interface Plugin {
+    (server: IMAPServer): void;
+    /** plugins that are loaded before this one, by name */
+    requires?: string[] | undefined;
+}
+/** An error that carries the response a command fails with */
+export interface IMAPError extends Error {
+    code?: string | undefined;
+    imapResponse?: string | undefined;
+    responseCode?: Attribute;
+    responseCodeArgs?: Attribute;
+    [key: string]: any;
+}
+/** Connection states of RFC 3501 section 3, "Logout" after LOGOUT or BYE */
+export type ConnectionState = 'Not Authenticated' | 'Authenticated' | 'Selected' | 'Logout';
+/** A message in a mailbox, plugins keep their own properties on it (MODSEQ, X-GM-LABELS ...) */
+export interface Message {
+    uid: number;
+    flags: string[];
+    internaldate: string;
+    /** the message source as a binary string (one char per octet) */
+    raw: string;
+    recent?: boolean | undefined;
+    /** expunged by another session but not yet reported to this one */
+    ghost?: boolean | undefined;
+    [key: string]: any;
+}
+/** Resolved messages of a sequence set, `[sequence number, message]` pairs */
+export type MessageRange = [number, Message][];
+/** A mailbox, plugins keep their own properties on it (acl, metadata, HIGHESTMODSEQ ...) */
+export interface Mailbox {
+    path: string;
+    namespace: string;
+    uid: number;
+    uidvalidity: number;
+    uidnext: number;
+    flags: string[];
+    permanentFlags: string[];
+    allowPermanentFlags: boolean;
+    messages: Message[];
+    /** flags that messages of the mailbox had, they stay in FLAGS and PERMANENTFLAGS, see server.rememberFlags() */
+    knownFlags?: string[] | undefined;
+    folders?: Record<string, Mailbox> | undefined;
+    separator?: string | undefined;
+    /** an accessor of `server.subscriptions`, see server.trackSubscription() */
+    subscribed?: boolean | undefined;
+    [key: string]: any;
+}
+/**
+ * A name that getSubscriptionTree() lists without a mailbox: a subscribed name that is not a mailbox, or a
+ * superior hierarchy level of a subscribed name
+ */
+export interface SubscriptionStandIn {
+    path: string;
+    namespace: string | false;
+    flags: string[];
+    subscribed: boolean;
+}
+/** The fields of a mailbox (or a stand-in) that LIST pattern matching needs, see server.matchFolders() */
+export interface ListedMailbox {
+    path: string;
+    namespace: string | false;
+    flags: string[];
+}
+/** A message as the storage option gives it, the server fills in the rest. A string is the message source */
+export interface StorageMessage {
+    uid?: number | undefined;
+    /** a single flag can be given as a string */
+    flags?: string | string[] | undefined;
+    /** a Date or a date-time string, the current time if not set */
+    internaldate?: string | Date | false | undefined;
+    raw?: string | Uint8Array | undefined;
+    recent?: boolean | undefined;
+    [key: string]: any;
+}
+/** A mailbox as the storage option gives it, the server fills in the rest */
+export interface StorageMailbox {
+    uid?: number | undefined;
+    uidvalidity?: number | undefined;
+    uidnext?: number | undefined;
+    flags?: string[] | undefined;
+    permanentFlags?: string[] | undefined;
+    allowPermanentFlags?: boolean | undefined;
+    subscribed?: boolean | undefined;
+    messages?: (StorageMessage | string)[] | undefined;
+    folders?: Record<string, StorageMailbox> | undefined;
+    separator?: string | undefined;
+    [key: string]: any;
+}
+export type NamespaceType = 'personal' | 'user' | 'shared';
+/** A namespace of the storage option, keyed by its prefix (`"INBOX"`, `""`, `"INBOX."`, ...) */
+export interface StorageNamespace extends StorageMailbox {
+    separator?: string | undefined;
+    type?: NamespaceType | undefined;
+}
+/** A namespace in `server.storage`, with every key set by the server */
+export interface Namespace {
+    separator: string;
+    type: NamespaceType;
+    folders: Record<string, Mailbox>;
+    [key: string]: any;
+}
+/** `server.storage`: the namespaces by prefix, and INBOX, which is a mailbox of its own */
+export type ServerStorage = {
+    INBOX: Mailbox;
+} & Record<string, Namespace>;
+/** Mailbox counters of `server.getStatus()` */
+export interface MailboxStatus {
+    /** number of messages by flag */
+    flags: Record<string, number>;
+    seen: number;
+    unseen: number;
+    recent: number;
+    permanentFlags: string[];
+}
+export interface UserData {
+    password?: string | undefined;
+    xoauth2?: {
+        accessToken?: string | undefined;
+        sessionTimeout?: number | undefined;
+    } | undefined;
+    [key: string]: any;
+}
+/** Options of `imapkit(options)` */
+export interface IMAPServerOptions {
+    /** the mailbox tree, keyed by namespace */
+    storage?: Record<string, StorageNamespace> | undefined;
+    /** plugin names (`"IDLE"`, `"LITERAL+"`, ...) or plugin functions */
+    plugins?: (string | Plugin)[] | string | Plugin | undefined;
+    users?: Record<string, UserData> | undefined;
+    secureConnection?: boolean | undefined;
+    credentials?: {
+        key: string | Buffer;
+        cert: string | Buffer;
+    } | undefined;
+    debug?: boolean | undefined;
+    systemFlags?: string[] | undefined;
+    /** largest literal accepted after login, in octets */
+    maxLiteralSize?: number | undefined;
+    [key: string]: any;
+}
+/**
+ * A layer between the socket and the IMAP protocol, such as COMPRESS=DEFLATE. It passes data on with
+ * `connection.writeRaw()` and `connection.onData()`
+ */
+export interface Transport {
+    write(data: Buffer): void;
+    receive(chunk: Buffer): void;
+    end(callback: () => void): void;
+    destroy(): void;
+}
+/** A response code, or a list for a code with arguments (`['MESSAGELIMIT', 1000]`) */
+export type ResponseCode = string | (string | number)[];
+/** The refusal of a command or a literal, sent as a tagged `command [code] text` */
+export interface Refusal {
+    command: string;
+    code?: string | undefined;
+    text: string;
+}
+/** A refusal of `server.commandChecks`, `command` defaults to BAD */
+export interface CommandRefusal {
+    command?: string | undefined;
+    code?: ResponseCode | undefined;
+    text: string;
+}
+/** A result of `server.appendChecks` (or other checks reported with `connection.applyChecks()`) */
+export interface CheckResult {
+    code?: ResponseCode | undefined;
+    text: string;
+    /** only a warning, sent as an untagged NO */
+    soft?: boolean | undefined;
+}
+/** A message that APPEND, REPLACE, COPY or MOVE is about to add to a mailbox */
+export interface AppendMessage {
+    raw: string;
+    flags?: string[] | undefined;
+    internaldate?: string | Date | false | undefined;
+    [key: string]: any;
+}
+/** Options of `server.appendChecks`: `{ move, source }` for COPY and MOVE, `{ command, replaced }` for APPEND and REPLACE */
+export interface AppendCheckOptions {
+    move?: boolean | undefined;
+    source?: Mailbox | false | undefined;
+    command?: string | undefined;
+    replaced?: Message | null | undefined;
+    [key: string]: any;
+}
+type BivariantCallback<T extends (...args: any[]) => any> = {
+    bivarianceHack(...args: Parameters<T>): ReturnType<T>;
+}['bivarianceHack'];
+/**
+ * `server.outputHandlers`: called with the arguments of every `connection.send()`, can change the response or set
+ * `skipResponse`. Handlers may declare narrower parameter types for the responses they act on
+ */
+export type OutputHandler = BivariantCallback<(connection: IMAPConnection, response: IMAPResponse, description: string | undefined, parsed: CommandContext | null | undefined, data: string | null | undefined, ...extra: any[]) => void>;
+/** `server.fetchHandlers`: the value of a FETCH item */
+export interface FetchHandler {
+    (connection: IMAPConnection, message: Message, query?: Attribute, ...args: any[]): any;
+    /** fetching the item sets \Seen like BODY[] */
+    setsSeen?: boolean | undefined;
+}
+/** `server.searchHandlers`: checks a message against a search key, the arguments follow the index */
+export interface SearchHandler {
+    (connection: IMAPConnection, message: Message, index: number, ...args: any[]): any;
+    /** decides the argument types of the key instead of one string per handler parameter */
+    argumentTypes?: ((list: Attribute[]) => any[]) | undefined;
+}
+/** `server.storeHandlers`: applies a STORE item to a message */
+export interface StoreHandler {
+    (connection: IMAPConnection, message: Message, values: any, index: number, parsed: ParsedCommand, data: string): any;
+    /** the values are astrings (X-GM-LABELS), NIL atoms are kept and literals accepted */
+    astringValues?: boolean | undefined;
+}
+/** `server.statusHandlers`: the value of a STATUS item */
+export type StatusHandler = (connection: IMAPConnection, mailbox: Mailbox, status: MailboxStatus) => any;
+/** `server.fetchFilters` and `server.storeFilters`: false leaves a message out */
+export type MessageFilter = (connection: IMAPConnection, message: Message, parsed: ParsedCommand, index: number) => unknown;
+/** `server.appendDataHandlers`: parses an append-data extension and returns the function that builds the message source */
+export type AppendDataHandler = (connection: IMAPConnection, value: Attribute) => () => string;
+export type CapabilityCheck = (connection: IMAPConnection) => boolean;
+export type ConnectionHandler = (connection: IMAPConnection) => void;
+export type MessageHandler = (server: IMAPServer, message: Message, mailbox: Mailbox) => void;
+export type MailboxHandler = (server: IMAPServer, mailbox: Mailbox) => void;
+export type CopyHandler = (server: IMAPServer, source: Message, properties: Record<string, any>, mailbox: Mailbox) => void;
+export type NotifyFilter = (connection: IMAPConnection, event: NotifyEvent) => boolean;
+export type AppendCheck = (connection: IMAPConnection, mailbox: Mailbox, messages: AppendMessage[], options: AppendCheckOptions) => CheckResult | false | null | undefined | void;
+export type LiteralFilter = (connection: IMAPConnection, command: string, line: string, size: number) => Refusal | false | null | undefined;
+export type UrlAccessCheck = (connection: IMAPConnection, mailbox: Mailbox, url: any) => {
+    text: string;
+} | false | null | undefined;
+export type SearchAccessCheck = (connection: IMAPConnection, mailbox: Mailbox, named: boolean) => boolean;
+export type CommandCheck = (connection: IMAPConnection, parsed: ParsedCommand) => CommandRefusal | false | null | undefined;
+export type RangeLimit = (connection: IMAPConnection, parsed: ParsedCommand, range: MessageRange) => MessageRange | false | null | undefined;
+export type SearchLimit = (connection: IMAPConnection, messages: Message[], query: any) => Message[] | false | null | undefined;
+export type ClosedCheck = (connection: IMAPConnection) => boolean;

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+// Shared types of the server, the commands and the plugins
+export {};

package/dist/esm/utf8-session.d.ts

@@ -0,0 +1,17 @@
+import type { IMAPConnection } from './types.js';
+/**
+ * Sets the UTF-8 options of a session from the extensions it has enabled. Run it when the session starts,
+ * after ENABLE and after UNAUTHENTICATE (once the ENABLE plugin has cleared `connection.enabled`).
+ *
+ * - With the UTF8=ACCEPT plugin, quoted strings may hold UTF-8 even before ENABLE (RFC 9755 section 3) and
+ *   modified UTF-7 names must decode to Net-Unicode. Without it, 8-bit quoted strings are a syntax error until
+ *   ENABLE IMAP4rev2, like RFC 3501 says
+ * - ENABLE UTF8=ACCEPT or IMAP4rev2: mailbox names are UTF-8 in both directions and strings that are valid
+ *   UTF-8 are sent quoted (RFC 9755 section 3, RFC 9051 sections 4.3 and 5.1)
+ * - ENABLE UTF8=ACCEPT: SEARCH strings are UTF-8 and CHARSET is refused (RFC 9755 section 3)
+ * - ENABLE IMAP4rev2: SEARCH strings are UTF-8 unless a CHARSET says otherwise (RFC 9051 section 6.4.4)
+ *
+ * @param {Object} connection IMAP connection
+ */
+declare function updateSession(connection: IMAPConnection): void;
+export { updateSession };