imapkit 4.0.2 → 4.1.0

package/{lib → dist/esm}/plugins/notify.js

@@ -1,12 +1,9 @@
-'use strict';
-
-const { states } = require('../command-states');
-const { fetchResponse } = require('../commands/fetch');
-const builtinFetchHandlers = require('../commands/handlers/fetch');
-const { statusResponse } = require('../commands/handlers/status');
-const { badError } = require('../commands/handlers/search');
-const { isAtom, isAstring } = require('../arguments');
-
+import { states } from '../command-states.js';
+import { fetchResponse } from '../commands/fetch.js';
+import builtinFetchHandlers from '../commands/handlers/fetch.js';
+import { statusResponse } from '../commands/handlers/status.js';
+import { badError } from '../commands/handlers/search.js';
+import { isAtom, isAstring } from '../arguments.js';
 /**
  * @help Adds NOTIFY [RFC5465] capability. Events: MessageNew (with
  * @help fetch attributes for the selected mailbox), MessageExpunge,
@@ -25,23 +22,17 @@ const { isAtom, isAstring } = require('../arguments');
  * responses of its own commands are sent as usual. Fetch attributes of MessageNew never set \Seen,
  * clients SHOULD NOT use such attributes anyway (section 5.2).
  */
-
 // RFC 5465 section 8, canonical names by upper case name
 const MESSAGE_EVENTS = ['MessageNew', 'MessageExpunge', 'FlagChange', 'AnnotationChange'];
-const EVENT_NAMES = new Map(
-    MESSAGE_EVENTS.concat(['MailboxName', 'SubscriptionChange', 'MailboxMetadataChange', 'ServerMetadataChange']).map(name => [name.toUpperCase(), name])
-);
+const EVENT_NAMES = new Map(MESSAGE_EVENTS.concat(['MailboxName', 'SubscriptionChange', 'MailboxMetadataChange', 'ServerMetadataChange']).map(name => [name.toUpperCase(), name]));
 const SELECTED_FILTERS = ['SELECTED', 'SELECTED-DELAYED'];
 const OTHER_FILTERS = ['INBOXES', 'PERSONAL', 'SUBSCRIBED', 'SUBTREE', 'MAILBOXES'];
 // fetch items whose arguments are checked with a dry run when NOTIFY SET is parsed
 const SECTION_ITEMS = ['BODY', 'BODY.PEEK', 'BINARY', 'BINARY.PEEK', 'BINARY.SIZE'];
-
-module.exports = function (server) {
+export default function notifyPlugin(server) {
     server.registerCapability('NOTIFY');
-
     // NOTIFY needs the authenticated state, UNAUTHENTICATE clears the settings
-    const isActive = connection => !!connection.notifyState;
-
+    const isActive = (connection) => !!connection.notifyState;
     // RFC 5465 sections 5.6 and 5.7: the metadata events are supported (and REQUIRED) with METADATA or METADATA-SERVER
     const getSupportedEvents = () => {
         const supported = ['MessageNew', 'MessageExpunge', 'FlagChange', 'MailboxName', 'SubscriptionChange'];
@@ -53,7 +44,6 @@ module.exports = function (server) {
         }
         return supported;
     };
-
     // Access checks, RFC 5465 section 3.1 and section 5: every event needs the "l" and "r" rights
     const hasRights = (connection, mailbox, letters, acl) => {
         const rights = server.acl && server.acl.getRights(connection, mailbox, acl);
@@ -61,9 +51,7 @@ module.exports = function (server) {
     };
     const canList = (connection, mailbox, acl) => hasRights(connection, mailbox, 'l', acl);
     const canRead = (connection, mailbox, acl) => hasRights(connection, mailbox, 'lr', acl);
-
-    const normalizePath = path => (path.toUpperCase() === 'INBOX' ? 'INBOX' : path);
-
+    const normalizePath = (path) => (path.toUpperCase() === 'INBOX' ? 'INBOX' : path);
     /**
      * Checks if an event group of NOTIFY SET covers a mailbox name (RFC 5465 section 6)
      *
@@ -83,14 +71,13 @@ module.exports = function (server) {
                 // RFC 5465 section 6.4: the list is reevaluated when subscriptions change
                 return !!subscription || !!(mailbox && mailbox.subscribed);
             case 'SUBTREE':
-                return group.paths.indexOf(path) >= 0 || group.prefixes.some(prefix => path.substr(0, prefix.length) === prefix);
+                return group.paths.indexOf(path) >= 0 || group.prefixes.some((prefix) => path.substr(0, prefix.length) === prefix);
             case 'MAILBOXES':
                 // RFC 5465 section 6.6: no wildcard expansion
                 return group.paths.indexOf(path) >= 0;
         }
         return false;
     };
-
     /**
      * Lists the events a session asked for on a mailbox other than the selected one. Several groups
      * can cover the same mailbox (RFC 5465 section 6), message events for the selected mailbox only
@@ -110,24 +97,20 @@ module.exports = function (server) {
         }
         return events;
     };
-
     // RFC 5465 section 6.1.2: with SELECTED-DELAYED an expunge waits for a command that allows it
-    const isHeld = connection =>
-        !!(connection.notifyState.selected && connection.notifyState.selected.delayed) && !connection.directNotifications && connection.hasPendingExpunge();
-
+    const isHeld = (connection) => !!(connection.notifyState.selected && connection.notifyState.selected.delayed) && !connection.directNotifications && connection.hasPendingExpunge();
     /**
      * Sends the queued notifications of a session that is between commands (RFC 5465 section 3.1: the
      * client listens all the time). During a command they wait for its tagged response
      */
-    const flush = connection => {
+    const flush = (connection) => {
         if (!connection.socket || !connection.notificationQueue.length || connection._runningCommand || !isActive(connection) || isHeld(connection)) {
             return;
         }
         connection.processNotifications();
     };
-
     // the events of one command go out together, e.g. several expunges as one VANISHED response (QRESYNC)
-    const scheduleFlush = connection => {
+    const scheduleFlush = (connection) => {
         if (!connection.notifyFlushPending) {
             connection.notifyFlushPending = true;
             setImmediate(() => {
@@ -136,14 +119,14 @@ module.exports = function (server) {
             });
         }
     };
-
     /**
      * Sends an event response about another mailbox or about the server
      *
      * @param {Object} connection IMAP connection
      * @param {Object} response Untagged response
      */
-    const deliver = (connection, response) => {
+    const deliver = (connection, event) => {
+        const response = event;
         response.tag = '*';
         response.notification = true;
         if (!connection._runningCommand && isHeld(connection)) {
@@ -154,10 +137,8 @@ module.exports = function (server) {
         connection.notificationQueue.push(response);
         scheduleFlush(connection);
     };
-
     // the sessions that use NOTIFY, other than the one that caused a change (RFC 5465 section 5: SHOULD omit)
-    const listeners = origin => [...server.connections].filter(connection => connection !== origin && isActive(connection));
-
+    const listeners = (origin) => [...server.connections].filter(connection => connection !== origin && isActive(connection));
     /**
      * Builds an unsolicited STATUS response for a mailbox. With FlagChange the UNSEEN count is added
      * when it changed since the session last heard of it (RFC 5465 section 5.1), with CONDSTORE (or
@@ -168,7 +149,8 @@ module.exports = function (server) {
     const eventStatus = (connection, mailbox, items, events) => {
         items = items.slice();
         if (events.has('FlagChange')) {
-            const unseen = server.getStatus(mailbox).unseen || 0;
+            const status = server.getStatus(mailbox);
+            const unseen = (status && status.unseen) || 0;
             if (connection.notifyState.unseen.get(mailbox) !== unseen) {
                 connection.notifyState.unseen.set(mailbox, unseen);
                 items.push('UNSEEN');
@@ -182,7 +164,6 @@ module.exports = function (server) {
         }
         return statusResponse(connection, mailbox.path, mailbox, items);
     };
-
     // Reports a change of the messages of a mailbox that is not selected (RFC 5465 sections 5.1, 5.2 and 5.3)
     const messageEvent = (mailbox, event, items, origin) => {
         listeners(origin).forEach(connection => {
@@ -193,22 +174,14 @@ module.exports = function (server) {
             if (!events.has(event)) {
                 return;
             }
-            const response = eventStatus(
-                connection,
-                mailbox,
-                event === 'FlagChange' && server.condstore && server.condstore.isEnabled(connection) ? ['UIDVALIDITY'] : items,
-                events
-            );
+            const response = eventStatus(connection, mailbox, event === 'FlagChange' && server.condstore && server.condstore.isEnabled(connection) ? ['UIDVALIDITY'] : items, events);
             if (response) {
                 deliver(connection, response);
             }
         });
     };
-
     // Checks if any mailbox below a mailbox is visible to the session (RFC 3348 section 4)
-    const hasVisibleChildren = (connection, path) =>
-        server.hasDescendant(path, child => canList(connection, child) && child.flags.indexOf('\\NonExistent') < 0);
-
+    const hasVisibleChildren = (connection, path) => server.hasDescendant(path, (child) => canList(connection, child) && child.flags.indexOf('\\NonExistent') < 0);
     /**
      * Builds an unsolicited LIST response with accurate attributes (RFC 5465 sections 5.4 and 5.5)
      *
@@ -233,7 +206,6 @@ module.exports = function (server) {
         }
         return { tag: '*', command: 'LIST', attributes };
     };
-
     // RFC 5465 section 5.4: a created or deleted mailbox and its direct parent are affected
     const nameEvent = (connection, path, mailbox, exists) => {
         [path, server.getParentPath(path)].forEach(name => {
@@ -246,16 +218,15 @@ module.exports = function (server) {
             }
         });
     };
-
     // RFC 5465 section 5.1: with FlagChange the server MUST tell about UIDVALIDITY changes, a mailbox that
     // gets a name that is watched has a new UIDVALIDITY
     const uidvalidityEvent = (connection, mailbox) => {
         if (mailbox !== connection.selectedMailbox && canRead(connection, mailbox) && getEvents(connection, mailbox.path, mailbox).has('FlagChange')) {
+            // the item list is not empty, so there is always a response
             deliver(connection, eventStatus(connection, mailbox, ['MESSAGES', 'UIDNEXT', 'UIDVALIDITY'], new Set(['FlagChange'])));
         }
     };
-
-    server.on('mailbox', change => {
+    server.on('mailbox', (change) => {
         const mailbox = server.getMailbox(change.path);
         listeners(change.origin).forEach(connection => {
             switch (change.type) {
@@ -274,6 +245,7 @@ module.exports = function (server) {
                     // RFC 5465 section 5.4: one LIST response for the new name, none for the children
                     if (mailbox && canList(connection, mailbox)) {
                         const events = getEvents(connection, change.path, mailbox);
+                        // a rename always has the old name
                         getEvents(connection, change.oldPath).forEach(event => events.add(event));
                         if (events.has('MailboxName')) {
                             deliver(connection, listResponse(connection, change.path, { oldPath: change.oldPath }));
@@ -291,7 +263,6 @@ module.exports = function (server) {
             }
         });
     });
-
     // RFC 5465 section 5.4: granting or revoking the "l" right counts as creating or deleting the mailbox. Section 5.9:
     // monitoring stops without the rights and starts again when they are granted, \NoAccess tells about the "r" right
     server.on('acl', (mailbox, previous) => {
@@ -300,7 +271,8 @@ module.exports = function (server) {
             const after = { list: canList(connection, mailbox), read: canRead(connection, mailbox) };
             if (before.list !== after.list) {
                 nameEvent(connection, mailbox.path, mailbox, after.list);
-            } else if (after.list && before.read !== after.read) {
+            }
+            else if (after.list && before.read !== after.read) {
                 const events = getEvents(connection, mailbox.path, mailbox);
                 if (MESSAGE_EVENTS.some(event => events.has(event))) {
                     deliver(connection, listResponse(connection, mailbox.path, { noAccess: !after.read }));
@@ -308,18 +280,17 @@ module.exports = function (server) {
             }
         });
     });
-
     server.on('expunge', (mailbox, messages, origin) => messageEvent(mailbox, 'MessageExpunge', ['MESSAGES', 'UIDNEXT'], origin));
-
-    server.on('notify', notification => {
+    server.on('notify', (notification) => {
         const command = notification.command || {};
         const mailbox = typeof notification.mailbox === 'string' ? server.getMailbox(notification.mailbox) : notification.mailbox;
-
         if (mailbox && command.flagUpdate) {
             messageEvent(mailbox, 'FlagChange', [], notification.origin);
-        } else if (mailbox && command.message && isAtom(command.attributes && command.attributes[1], 'EXISTS')) {
+        }
+        else if (mailbox && command.message && isAtom(command.attributes && command.attributes[1], 'EXISTS')) {
             messageEvent(mailbox, 'MessageNew', ['MESSAGES', 'UIDNEXT'], notification.origin);
-        } else if (command.command === 'METADATA' && command.attributes && command.attributes[0]) {
+        }
+        else if (command.command === 'METADATA' && command.attributes && command.attributes[0]) {
             // RFC 5465 sections 5.6 and 5.7: METADATA responses without ENABLE METADATA
             const path = command.attributes[0].value;
             const target = path === '' ? null : server.getMailbox(path);
@@ -327,7 +298,8 @@ module.exports = function (server) {
                 let wanted;
                 if (path === '') {
                     wanted = connection.notifyState.groups.some(group => group.events.has('ServerMetadataChange'));
-                } else {
+                }
+                else {
                     wanted = !!target && canRead(connection, target) && getEvents(connection, path, target).has('MailboxMetadataChange');
                 }
                 if (wanted) {
@@ -338,12 +310,10 @@ module.exports = function (server) {
             });
         }
     });
-
     // a METADATA response that NOTIFY sent already does not go out again for ENABLE METADATA
     server.notifyFilters.push((connection, notification) => !(notification.notifyHandled && notification.notifyHandled.has(connection)));
-
     // Which message event a notification for the selected mailbox is
-    const selectedEvent = command => {
+    const selectedEvent = (command) => {
         if (command.flagUpdate) {
             return 'FlagChange';
         }
@@ -357,14 +327,14 @@ module.exports = function (server) {
         }
         return false;
     };
-
     // Builds the FETCH response for a new message in the selected mailbox (RFC 5465 section 5.2)
     const newMessageFetch = (connection, items, sequence, message) => {
         const params = items.map(item => Object.assign({}, item));
         let data;
         try {
             data = fetchResponse(connection, message, params);
-        } catch {
+        }
+        catch {
             // the items were checked by NOTIFY SET, a failure here leaves out the FETCH response
             return false;
         }
@@ -372,10 +342,8 @@ module.exports = function (server) {
         // marks an EXPUNGE notification
         return { tag: '*', notification: true, attributes: [sequence, { type: 'ATOM', value: 'FETCH' }, data], fetchedMessage: message };
     };
-
-    server.connectionHandlers.push(connection => {
+    server.connectionHandlers.push((connection) => {
         connection.notifyState = null;
-
         const queueNotification = connection.queueNotification;
         connection.queueNotification = function (command, notification) {
             const event = notification && notification.mailbox && selectedEvent(command);
@@ -384,6 +352,7 @@ module.exports = function (server) {
                 return queueNotification.call(this, command, notification);
             }
             const selected = this.notifyState.selected;
+            // notifications about the selected mailbox
             if (!selected || !selected.events.has(event) || !canRead(this, this.selectedMailbox)) {
                 // RFC 5465 section 3.1: without SELECTED or SELECTED-DELAYED (or without the event) the client
                 // does not want to hear about it
@@ -400,40 +369,36 @@ module.exports = function (server) {
             scheduleFlush(this);
         };
     });
-
     // RFC 8437 section 4.1: UNAUTHENTICATE forgets the NOTIFY settings
-    server.resetHandlers.push(connection => {
+    server.resetHandlers.push((connection) => {
         connection.notifyState = null;
     });
-
     // notifications held back during a command (FETCH, STORE, SEARCH) go out once it completed
     server.outputHandlers.push((connection, response) => {
         if (response.tag !== '*' && !response.notification && isActive(connection) && connection.notificationQueue.length) {
             scheduleFlush(connection);
         }
     });
-
     /**
      * RFC 5465 section 5.8: disables notifications for a session (or all sessions that use NOTIFY),
      * which get an untagged OK [NOTIFICATIONOVERFLOW] and behave as after NOTIFY NONE
      *
      * @param {Object} [target] IMAP connection, all sessions if not set
      */
-    server.notifyOverflow = target => {
+    server.notifyOverflow = (target) => {
         listeners(null)
             .filter(connection => !target || connection === target)
             .forEach(connection => {
-                connection.notifyState = { selected: null, groups: [], unseen: new WeakMap() };
-                deliver(connection, {
-                    command: 'OK',
-                    attributes: [
-                        { type: 'SECTION', section: [{ type: 'ATOM', value: 'NOTIFICATIONOVERFLOW' }] },
-                        { type: 'TEXT', value: 'Too many notifications, NOTIFY is turned off' }
-                    ]
-                });
+            connection.notifyState = { selected: null, groups: [], unseen: new WeakMap() };
+            deliver(connection, {
+                command: 'OK',
+                attributes: [
+                    { type: 'SECTION', section: [{ type: 'ATOM', value: 'NOTIFICATIONOVERFLOW' }] },
+                    { type: 'TEXT', value: 'Too many notifications, NOTIFY is turned off' }
+                ]
             });
+        });
     };
-
     /**
      * Parses the fetch attributes of MessageNew (RFC 5465 section 8: "(" fetch-att *(SP fetch-att) ")")
      *
@@ -455,15 +420,16 @@ module.exports = function (server) {
                 // check the section and the partial range against a message
                 const params = [Object.assign({}, item)];
                 try {
+                    // a dry run against a minimal message, the section items only look at its source
                     fetchResponse(connection, { raw: 'Subject: test\r\n\r\nTest\r\n', flags: [], uid: 1 }, params);
-                } catch (err) {
+                }
+                catch (err) {
                     throw badError(err.message);
                 }
             }
             return item;
         });
     };
-
     /**
      * Parses the events of an event group (RFC 5465 section 8: events = ( "(" event *(SP event) ")" ) / "NONE")
      *
@@ -515,7 +481,6 @@ module.exports = function (server) {
         }
         return { events, fetch };
     };
-
     // one-or-more-mailbox = mailbox / many-mailboxes, the names are converted to storage names
     const parseMailboxes = (connection, value) => {
         const list = Array.isArray(value) ? value : [value];
@@ -524,7 +489,6 @@ module.exports = function (server) {
         }
         return list.map(item => normalizePath(connection.importMailboxName(item.value)));
     };
-
     /**
      * Parses the arguments of NOTIFY (RFC 5465 section 8)
      *
@@ -562,7 +526,8 @@ module.exports = function (server) {
                     throw badError('Only one of SELECTED and SELECTED-DELAYED can be used');
                 }
                 state.selected = Object.assign({ delayed: filter === 'SELECTED-DELAYED' }, parseEvents(connection, group[1], true, unknown));
-            } else if (OTHER_FILTERS.indexOf(filter) >= 0) {
+            }
+            else if (OTHER_FILTERS.indexOf(filter) >= 0) {
                 const withNames = filter === 'SUBTREE' || filter === 'MAILBOXES';
                 if (group.length !== (withNames ? 3 : 2)) {
                     throw badError('Invalid event group');
@@ -572,19 +537,19 @@ module.exports = function (server) {
                 // the names below a SUBTREE root start with these
                 const prefixes = filter === 'SUBTREE' ? paths.map(root => root + server.getSeparator(root)) : [];
                 state.groups.push({ filter, paths, prefixes, events });
-            } else {
+            }
+            else {
                 throw badError('Unknown mailbox filter ' + group[0].value);
             }
         });
         return { state, status, unknown };
     };
-
     // RFC 5465 section 3.1: the initial STATUS responses and the \NoAccess LIST responses of NOTIFY SET
     const sendInitialResponses = (connection, status, parsed, data) => {
         const paths = Object.keys(server.folderCache).sort((a, b) => (a === 'INBOX' ? -1 : b === 'INBOX' ? 1 : a.localeCompare(b)));
         paths.forEach(path => {
             const mailbox = server.folderCache[path];
-            if (mailbox === connection.selectedMailbox || mailbox.flags.some(flag => /^\\(Noselect|NonExistent)$/i.test(flag))) {
+            if (mailbox === connection.selectedMailbox || mailbox.flags.some((flag) => /^\\(Noselect|NonExistent)$/i.test(flag))) {
                 return;
             }
             const events = getEvents(connection, path, mailbox);
@@ -601,7 +566,8 @@ module.exports = function (server) {
             const items = ['MESSAGES', 'UIDNEXT', 'UIDVALIDITY'];
             if (events.has('FlagChange')) {
                 items.push('UNSEEN');
-                connection.notifyState.unseen.set(mailbox, server.getStatus(mailbox).unseen || 0);
+                const mailboxStatus = server.getStatus(mailbox);
+                connection.notifyState.unseen.set(mailbox, (mailboxStatus && mailboxStatus.unseen) || 0);
                 if (server.condstore) {
                     items.push('HIGHESTMODSEQ');
                 }
@@ -609,46 +575,36 @@ module.exports = function (server) {
             connection.send(statusResponse(connection, path, mailbox, items), 'NOTIFY STATUS', parsed, data);
         });
     };
-
-    server.setCommandHandler(
-        'NOTIFY',
-        (connection, parsed, data, callback) => {
-            let result;
-            try {
-                result = parseNotify(connection, parsed.attributes || []);
-            } catch (err) {
-                connection.sendStatus(parsed, data, 'BAD', err.imapResponse === 'BAD' ? err.message : 'Invalid NOTIFY arguments');
-                return callback();
-            }
-
-            const supported = getSupportedEvents();
-            const used = [result.state.selected].concat(result.state.groups).filter(group => group);
-            const unsupported = result.unknown.concat(...used.map(group => [...group.events].filter(event => supported.indexOf(event) < 0)));
-            if (unsupported.length) {
-                // RFC 5465 section 3.1: NO with BADEVENT, which MUST list all supported events
-                connection.send(
-                    {
-                        tag: parsed.tag,
-                        command: 'NO',
-                        attributes: [
-                            { type: 'SECTION', section: [{ type: 'ATOM', value: 'BADEVENT' }, supported.map(event => ({ type: 'ATOM', value: event }))] },
-                            { type: 'TEXT', value: 'Unsupported NOTIFY events' }
-                        ]
-                    },
-                    'NOTIFY FAILED',
-                    parsed,
-                    data
-                );
-                return callback();
-            }
-
-            connection.notifyState = result.state;
-            sendInitialResponses(connection, result.status, parsed, data);
-
-            // the tagged response sends the changes of the selected mailbox, NOTIFY SET implies NOOP (section 3.1)
-            connection.sendStatus(parsed, data, 'OK', 'NOTIFY completed');
+    server.setCommandHandler('NOTIFY', (connection, parsed, data, callback) => {
+        let result;
+        try {
+            result = parseNotify(connection, parsed.attributes || []);
+        }
+        catch (err) {
+            connection.sendStatus(parsed, data, 'BAD', err.imapResponse === 'BAD' ? err.message : 'Invalid NOTIFY arguments');
+            return callback();
+        }
+        const supported = getSupportedEvents();
+        const used = [result.state.selected]
+            .concat(result.state.groups)
+            .filter((group) => !!group);
+        const unsupported = result.unknown.concat(...used.map(group => [...group.events].filter(event => supported.indexOf(event) < 0)));
+        if (unsupported.length) {
+            // RFC 5465 section 3.1: NO with BADEVENT, which MUST list all supported events
+            connection.send({
+                tag: parsed.tag,
+                command: 'NO',
+                attributes: [
+                    { type: 'SECTION', section: [{ type: 'ATOM', value: 'BADEVENT' }, supported.map(event => ({ type: 'ATOM', value: event }))] },
+                    { type: 'TEXT', value: 'Unsupported NOTIFY events' }
+                ]
+            }, 'NOTIFY FAILED', parsed, data);
             return callback();
-        },
-        { states: states.AUTHENTICATED }
-    );
-};
+        }
+        connection.notifyState = result.state;
+        sendInitialResponses(connection, result.status, parsed, data);
+        // the tagged response sends the changes of the selected mailbox, NOTIFY SET implies NOOP (section 3.1)
+        connection.sendStatus(parsed, data, 'OK', 'NOTIFY completed');
+        return callback();
+    }, { states: states.AUTHENTICATED });
+}

package/dist/esm/plugins/oauthbearer.d.ts

@@ -0,0 +1,32 @@
+import type { IMAPServer } from '../types.js';
+/** A parsed OAUTHBEARER client response, see parseClientResponse() */
+interface ClientResponse {
+    kvsepOnly?: boolean | undefined;
+    error?: string | undefined;
+    channelBinding?: boolean | undefined;
+    authzid?: string | false | undefined;
+    pairs?: Record<string, string> | undefined;
+    /** the user that the credentials log in, set by checkCredentials() */
+    username?: string | undefined;
+}
+/**
+ * Parses an OAUTHBEARER client response (RFC 7628 section 3.1)
+ *
+ *     client-resp = (gs2-header kvsep *kvpair kvsep) / kvsep
+ *     kvpair      = key "=" value kvsep
+ *     key         = 1*(ALPHA)
+ *     value       = *(VCHAR / SP / HTAB / CR / LF)
+ *
+ * and its GS2 header (RFC 5801 section 4)
+ *
+ *     gs2-header = [gs2-nonstd-flag ","] gs2-cb-flag "," [gs2-authzid] ","
+ *     gs2-cb-flag = ("p=" cb-name) / "n" / "y"
+ *     gs2-authzid = "a=" saslname
+ *
+ * @param {Buffer} input Decoded client response
+ * @return {Object} `{ kvsepOnly }`, `{ error }` when the response breaks the grammar, or
+ *   `{ channelBinding, authzid, pairs }` where pairs maps keys to values
+ */
+declare function parseClientResponse(input: Buffer): ClientResponse;
+export default function oauthbearerPlugin(server: IMAPServer): void;
+export { parseClientResponse };