imapflow 1.7.8 → 2.0.0

package/{lib/imap-flow.d.ts → dist/cjs/types.d.ts}

@@ -1,35 +1,49 @@
-import { EventEmitter } from 'events';
-import { ConnectionOptions } from 'tls';
-import { Readable } from 'stream';
-
+import type { ConnectionOptions, CipherNameAndProtocol } from 'node:tls';
+import type { Readable } from 'node:stream';
+/**
+ * Logger interface. Any object with `debug`, `info`, `warn` and `error` methods can be used,
+ * for example a pino or bunyan instance. `trace` and `fatal` are used when present.
+ */
+export interface Logger {
+    trace?: ((obj: any) => void) | undefined;
+    debug(obj: any): void;
+    info(obj: any): void;
+    warn(obj: any): void;
+    error(obj: any): void;
+    fatal?: ((obj: any) => void) | undefined;
+}
+/**
+ * Authentication options
+ */
+export interface AuthOptions {
+    /** Username */
+    user: string;
+    /** Password for regular authentication (if using OAuth2 then use `accessToken` instead) */
+    pass?: string | undefined;
+    /** OAuth2 access token, if using OAuth2 authentication */
+    accessToken?: string | undefined;
+    /** Optional login method override. Set to 'LOGIN', 'AUTH=LOGIN' or 'AUTH=PLAIN' to use specific method */
+    loginMethod?: string | undefined;
+    /** Authorization identity for SASL PLAIN (used for admin impersonation/delegation). When set, authenticates as `user` but authorizes as `authzid` */
+    authzid?: string | undefined;
+}
 export interface ImapFlowOptions {
     /** Hostname of the IMAP server */
-    host: string;
+    host?: string | undefined;
     /** Port number for the IMAP server */
-    port: number;
+    port?: number | undefined;
     /** If true, the connection will use TLS. If false, then TLS is used only if the server supports STARTTLS extension */
-    secure?: boolean;
+    secure?: boolean | undefined;
     /** Servername for SNI (or when host is set to an IP address) */
-    servername?: string;
+    servername?: string | undefined;
     /** If true, do not use COMPRESS=DEFLATE extension even if server supports it */
-    disableCompression?: boolean;
+    disableCompression?: boolean | undefined;
     /** Authentication options */
-    auth?: {
-        /** Username */
-        user: string;
-        /** Password for regular authentication (if using OAuth2 then use `accessToken` instead) */
-        pass?: string;
-        /** OAuth2 access token, if using OAuth2 authentication */
-        accessToken?: string;
-        /** Optional login method override. Set to 'LOGIN', 'AUTH=LOGIN' or 'AUTH=PLAIN' to use specific method */
-        loginMethod?: string;
-        /** Authorization identity for SASL PLAIN (used for admin impersonation/delegation). When set, authenticates as `user` but authorizes as `authzid` */
-        authzid?: string;
-    };
+    auth?: AuthOptions | undefined;
     /** Client identification info sent to the server if server supports ID extension */
-    clientInfo?: IdInfoObject;
+    clientInfo?: IdInfoObject | undefined;
     /** If true, then do not start IDLE when connection is established */
-    disableAutoIdle?: boolean;
+    disableAutoIdle?: boolean | undefined;
     /**
      * How long (in ms) the connection has to be inactive before IDLE is started automatically.
      * Keep it above the pause your own code usually leaves between two commands, otherwise every
@@ -40,22 +54,22 @@ export interface ImapFlowOptions {
      * the polling fallback starts, not how often it polls - the poll interval is `maxIdleTime`,
      * capped at 2 minutes. Default: 15000 ms.
      */
-    autoIdleDelay?: number;
+    autoIdleDelay?: number | string | undefined;
     /** Additional TLS options (see Node.js TLS documentation) */
-    tls?: ConnectionOptions;
+    tls?: ConnectionOptions | undefined;
     /** Custom logger instance. Set to false to disable logging */
-    logger?: Logger | false;
+    logger?: Logger | false | undefined;
     /**
      * If true, log data read and written to socket encoded in base64. Client frames that carry
      * credentials are replaced with a fixed placeholder and marked with `hidden: true`.
      */
-    logRaw?: boolean;
+    logRaw?: boolean | undefined;
     /** If true, emit 'log' events */
-    emitLogs?: boolean;
+    emitLogs?: boolean | undefined;
     /** If true, then logs out automatically after successful authentication */
-    verifyOnly?: boolean;
+    verifyOnly?: boolean | undefined;
     /** If true and verifyOnly is set, lists mailboxes */
-    includeMailboxes?: boolean;
+    includeMailboxes?: boolean | undefined;
     /**
      * Proxy URL. Supports HTTP CONNECT (http:, https:) and SOCKS (socks:, socks4:, socks4a:,
      * socks5:) proxies. IPv6 proxy endpoints are given in URL form, e.g. `socks5://[2001:db8::1]:1080`.
@@ -72,29 +86,29 @@ export interface ImapFlowOptions {
      * The proxy endpoint itself is never resolved by ImapFlow; a hostname endpoint is handed to
      * Node as-is. Proxy DNS and negotiation run inside `connectionTimeout`.
      */
-    proxy?: string;
+    proxy?: string | undefined;
     /** If true, then use QRESYNC instead of CONDSTORE. EXPUNGE notifications will include UID instead of sequence number */
-    qresync?: boolean;
+    qresync?: boolean | undefined;
     /** If set, then breaks and restarts IDLE every maxIdleTime ms */
-    maxIdleTime?: number;
+    maxIdleTime?: number | undefined;
     /** What command to run if IDLE is not supported. Defaults to 'NOOP' */
-    missingIdleCommand?: 'NOOP' | 'SELECT' | 'STATUS';
+    missingIdleCommand?: 'NOOP' | 'SELECT' | 'STATUS' | undefined;
     /** If true, ignores BINARY extension when making FETCH and APPEND calls */
-    disableBinary?: boolean;
+    disableBinary?: boolean | undefined;
     /** If true, do not enable supported extensions */
-    disableAutoEnable?: boolean;
+    disableAutoEnable?: boolean | undefined;
     /** If true, do not enable IMAP4rev2 mode even if the server supports it */
-    disableIMAP4rev2?: boolean;
+    disableIMAP4rev2?: boolean | undefined;
     /**
      * How long to wait for a usable transport, covering DNS resolution, proxy negotiation and the
      * TCP/TLS handshake as a single budget. Defaults to 90 seconds. An expiry in any of those
      * phases rejects with error code `CONNECT_TIMEOUT`.
      */
-    connectionTimeout?: number;
+    connectionTimeout?: number | undefined;
     /** How long to wait for the greeting. Defaults to 16 seconds */
-    greetingTimeout?: number;
+    greetingTimeout?: number | undefined;
     /** How long to wait for socket inactivity before timing out the connection. Defaults to 5 minutes */
-    socketTimeout?: number;
+    socketTimeout?: number | undefined;
     /**
      * Maximum allowed length in bytes of a single response line (a response without a literal).
      * Guards against a malicious or broken server that never sends a line terminator. Defaults to
@@ -104,7 +118,7 @@ export interface ImapFlowOptions {
      * Exceeding it is terminal: the connection fails with error code `LineTooLarge` and
      * no further input is parsed.
      */
-    maxLineLength?: number;
+    maxLineLength?: number | undefined;
     /**
      * Maximum allowed size in bytes of a single IMAP literal block. Bounds peak memory allocation
      * against a malicious or broken server announcing an oversized literal. Defaults to 1GB. A
@@ -113,7 +127,7 @@ export interface ImapFlowOptions {
      * with error code `LiteralTooLarge`, and neither the marker line nor any byte of the rejected
      * literal is interpreted as protocol.
      */
-    maxLiteralSize?: number;
+    maxLiteralSize?: number | undefined;
     /**
      * Maximum allowed total size in bytes of a single assembled IMAP response (every line
      * segment and literal of one response combined). Bounds peak memory allocation against
@@ -126,28 +140,20 @@ export interface ImapFlowOptions {
      * Exceeding it is terminal: the connection fails with error code `ResponseTooLarge` and
      * no further input is parsed.
      */
-    maxResponseSize?: number;
+    maxResponseSize?: number | undefined;
     /**
      * Threshold in milliseconds for warning that a mailbox lock has been held
      * for a long time (diagnostic for forgotten release() calls). Defaults to
      * 30 minutes. Set to 0 or false to disable.
      */
-    maxLockHoldTime?: number | false;
+    maxLockHoldTime?: number | false | undefined;
     /** If true, uses TLS. If false, uses cleartext. If not set, upgrades to TLS if available */
-    doSTARTTLS?: boolean;
+    doSTARTTLS?: boolean | undefined;
     /** Custom instance ID string for logs */
-    id?: string;
+    id?: string | undefined;
     /** Optional expunge event handler function */
-    expungeHandler?: (event: ExpungeEvent) => Promise<void> | void;
+    expungeHandler?: ((event: ExpungeEvent) => Promise<void> | void) | undefined;
 }
-
-export interface Logger {
-    debug(obj: any): void;
-    info(obj: any): void;
-    warn(obj: any): void;
-    error(obj: any): void;
-}
-
 export interface MailboxObject {
     /** Mailbox path */
     path: string;
@@ -156,19 +162,19 @@ export interface MailboxObject {
     /** List of flags for this mailbox */
     flags: Set<string>;
     /** One of special-use flags (if applicable): "\All", "\Archive", "\Drafts", "\Flagged", "\Junk", "\Sent", "\Trash". Additionally INBOX has non-standard "\Inbox" flag set */
-    specialUse?: string;
+    specialUse?: string | undefined;
     /** True if mailbox was found from the output of LIST command */
-    listed?: boolean;
+    listed?: boolean | undefined;
     /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed */
-    subscribed?: boolean;
+    subscribed?: boolean | undefined;
     /** A Set of flags available to use in this mailbox. If it is not set or includes special flag "\*" then any flag can be used */
-    permanentFlags?: Set<string>;
+    permanentFlags?: Set<string> | undefined;
     /** Unique mailbox ID if server has OBJECTID extension enabled */
-    mailboxId?: string;
+    mailboxId?: string | undefined;
     /** Latest known modseq value if server has CONDSTORE or XYMHIGHESTMODSEQ enabled */
-    highestModseq?: bigint;
+    highestModseq?: bigint | undefined;
     /** If true then the server doesn't support the persistent storage of mod-sequences for the mailbox */
-    noModseq?: boolean;
+    noModseq?: boolean | undefined;
     /** Mailbox UIDVALIDITY value */
     uidValidity: bigint;
     /** Next predicted UID */
@@ -176,36 +182,33 @@ export interface MailboxObject {
     /** Messages in this folder */
     exists: number;
     /** Sequence number of the first unseen message, if the server reported [UNSEEN] on SELECT. Not a count of unseen messages - use mailboxStatus() with {unseen: true} for that */
-    unseen?: number;
+    unseen?: number | undefined;
     /** Largest message size in octets the server accepts for APPEND into this mailbox, if it reported [APPENDLIMIT] (RFC 7889) */
-    appendlimit?: number;
+    appendlimit?: number | undefined;
     /** Read-only state */
-    readOnly?: boolean;
+    readOnly?: boolean | undefined;
 }
-
 export interface MailboxLockObject {
     /** Mailbox path */
     path: string;
     /** Release current lock */
     release(): void;
 }
-
 export interface IdInfoObject {
     /** Name of the program */
-    name?: string;
+    name?: string | false | undefined;
     /** Version number of the program */
-    version?: string;
+    version?: string | false | undefined;
     /** Name of the operating system */
-    os?: string;
+    os?: string | false | undefined;
     /** Vendor of the client/server */
-    vendor?: string;
+    vendor?: string | false | undefined;
     /** URL to contact for support */
-    'support-url'?: string;
+    'support-url'?: string | false | undefined;
     /** Date program was released */
-    date?: Date;
+    date?: Date | string | false | undefined;
     [key: string]: any;
 }
-
 export interface QuotaResponse {
     /** Mailbox path this quota applies to */
     path: string;
@@ -215,16 +218,52 @@ export interface QuotaResponse {
         used: number;
         /** Total storage available */
         limit: number;
-    };
+    } | undefined;
     /** Message count quota if provided by server */
     messages?: {
         /** Stored messages */
         used: number;
         /** Maximum messages allowed */
         limit: number;
-    };
+    } | undefined;
+    [resource: string]: any;
+}
+/**
+ * Status data items to request with `status()` or the `statusQuery` listing option
+ */
+export interface StatusQuery {
+    /** If true request count of messages */
+    messages?: boolean | undefined;
+    /** If true request count of messages with \Recent tag */
+    recent?: boolean | undefined;
+    /** If true request predicted next UID */
+    uidNext?: boolean | undefined;
+    /** If true request mailbox UIDVALIDITY value */
+    uidValidity?: boolean | undefined;
+    /** If true request count of unseen messages */
+    unseen?: boolean | undefined;
+    /** If true request last known modseq value */
+    highestModseq?: boolean | undefined;
+    /** If true request total mailbox size in octets (requires STATUS=SIZE or IMAP4rev2) */
+    size?: boolean | undefined;
+    /** If true request count of messages with \Deleted flag (requires IMAP4rev2) */
+    deleted?: boolean | undefined;
+}
+/**
+ * Explicit special-use folder paths, overriding what the server reports
+ */
+export interface SpecialUseHints {
+    /** Path to "Sent Mail" folder */
+    sent?: string | undefined;
+    /** Path to "Trash" folder */
+    trash?: string | undefined;
+    /** Path to "Junk Mail" folder */
+    junk?: string | undefined;
+    /** Path to "Drafts" folder */
+    drafts?: string | undefined;
+    /** Path to "Archive" folder */
+    archive?: string | undefined;
 }
-
 export interface ListResponse {
     /** Mailbox path (unicode string) */
     path: string;
@@ -241,437 +280,444 @@ export interface ListResponse {
     /** A set of flags for this mailbox */
     flags: Set<string>;
     /** One of special-use flags (if applicable) */
-    specialUse?: string;
+    specialUse?: string | undefined;
     /** How specialUse was determined: "user" (from specialUseHints), "extension" (SPECIAL-USE or XLIST flag reported by the server) or "name" (matched against known localized folder names) */
-    specialUseSource?: 'user' | 'extension' | 'name';
+    specialUseSource?: 'user' | 'extension' | 'name' | undefined;
     /** True if mailbox was found from the output of LIST command */
     listed: boolean;
     /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed */
     subscribed: boolean;
     /** If statusQuery was used, then this value includes the status response */
-    status?: StatusObject;
+    status?: StatusObject | undefined;
 }
-
 export interface ListOptions {
     /** Request status items for every listed entry */
-    statusQuery?: {
-        /** If true request count of messages */
-        messages?: boolean;
-        /** If true request count of messages with \Recent tag */
-        recent?: boolean;
-        /** If true request predicted next UID */
-        uidNext?: boolean;
-        /** If true request mailbox UIDVALIDITY value */
-        uidValidity?: boolean;
-        /** If true request count of unseen messages */
-        unseen?: boolean;
-        /** If true request last known modseq value */
-        highestModseq?: boolean;
-        /** If true request total mailbox size in octets (requires STATUS=SIZE or IMAP4rev2) */
-        size?: boolean;
-        /** If true request count of messages with \Deleted flag (requires IMAP4rev2) */
-        deleted?: boolean;
-    };
+    statusQuery?: StatusQuery | undefined;
     /** Set specific paths as special use folders */
-    specialUseHints?: {
-        /** Path to "Sent Mail" folder */
-        sent?: string;
-        /** Path to "Trash" folder */
-        trash?: string;
-        /** Path to "Junk Mail" folder */
-        junk?: string;
-        /** Path to "Drafts" folder */
-        drafts?: string;
-        /** Path to "Archive" folder */
-        archive?: string;
-    };
-}
-
+    specialUseHints?: SpecialUseHints | undefined;
+    /** If true then only runs LIST, without LSUB or subscription lookups */
+    listOnly?: boolean | undefined;
+}
 export interface ListTreeResponse {
     /** If true then this is root node without any additional properties besides folders */
-    root?: boolean;
+    root?: boolean | undefined;
     /** Mailbox path */
-    path?: string;
+    path?: string | undefined;
     /** Mailbox name (last part of path after delimiter) */
-    name?: string;
+    name?: string | undefined;
     /** Mailbox path delimiter, usually "." or "/" */
-    delimiter?: string;
+    delimiter?: string | undefined;
     /** List of flags for this mailbox */
-    flags?: Set<string>;
+    flags?: Set<string> | undefined;
     /** One of special-use flags (if applicable) */
-    specialUse?: string;
+    specialUse?: string | undefined;
     /** True if mailbox was found from the output of LIST command */
-    listed?: boolean;
+    listed?: boolean | undefined;
     /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed */
-    subscribed?: boolean;
+    subscribed?: boolean | undefined;
     /** If true then this mailbox can not be selected in the UI */
-    disabled?: boolean;
+    disabled?: boolean | undefined;
     /** An array of subfolders */
-    folders?: ListTreeResponse[];
+    folders?: ListTreeResponse[] | undefined;
     /** Status response */
-    status?: StatusObject;
+    status?: StatusObject | undefined;
 }
-
 export interface MailboxCreateResponse {
     /** Full mailbox path */
     path: string;
     /** Unique mailbox ID if server supports OBJECTID extension */
-    mailboxId?: string;
+    mailboxId?: string | undefined;
     /** If true then mailbox was created otherwise it already existed */
     created: boolean;
 }
-
 export interface MailboxRenameResponse {
     /** Full mailbox path that was renamed */
     path: string;
     /** New full mailbox path */
     newPath: string;
 }
-
 export interface MailboxDeleteResponse {
     /** Full mailbox path that was deleted */
     path: string;
 }
-
 export interface StatusObject {
     /** Full mailbox path that was checked */
     path: string;
     /** Count of messages */
-    messages?: number;
+    messages?: number | undefined;
     /** Count of messages with \Recent tag */
-    recent?: number;
+    recent?: number | undefined;
     /** Predicted next UID */
-    uidNext?: number;
+    uidNext?: number | undefined;
     /** Mailbox UIDVALIDITY value */
-    uidValidity?: bigint;
+    uidValidity?: bigint | undefined;
     /** Count of unseen messages */
-    unseen?: number;
+    unseen?: number | undefined;
     /** Last known modseq value (if CONDSTORE extension is enabled) */
-    highestModseq?: bigint;
+    highestModseq?: bigint | undefined;
     /** Total size of the mailbox in octets (only if requested and the server supports STATUS=SIZE or IMAP4rev2) */
-    size?: number;
+    size?: number | undefined;
     /** Count of messages with \Deleted flag (only if requested and IMAP4rev2 is active) */
-    deleted?: number;
+    deleted?: number | undefined;
 }
-
+/**
+ * Sequence range string. Separate different values with commas, number ranges with colons and use "*" as the placeholder for the newest message in mailbox
+ */
 export type SequenceString = string | number | bigint;
-
 export interface SearchObject {
     /** Message ordering sequence range */
-    seq?: SequenceString;
+    seq?: SequenceString | undefined;
     /** Messages with (value is true) or without (value is false) \Answered flag */
-    answered?: boolean;
+    answered?: boolean | undefined;
     /** Messages with (value is true) or without (value is false) \Deleted flag */
-    deleted?: boolean;
+    deleted?: boolean | undefined;
     /** Messages with (value is true) or without (value is false) \Draft flag */
-    draft?: boolean;
+    draft?: boolean | undefined;
     /** Messages with (value is true) or without (value is false) \Flagged flag */
-    flagged?: boolean;
+    flagged?: boolean | undefined;
     /** Messages with (value is true) or without (value is false) \Seen flag */
-    seen?: boolean;
+    seen?: boolean | undefined;
     /** If true matches all messages */
-    all?: boolean;
+    all?: boolean | undefined;
     /** If true matches messages that have the \Recent flag set but not the \Seen flag */
-    new?: boolean;
+    new?: boolean | undefined;
     /** If true matches messages that do not have the \Recent flag set */
-    old?: boolean;
+    old?: boolean | undefined;
     /** If true matches messages that have the \Recent flag set */
-    recent?: boolean;
+    recent?: boolean | undefined;
     /** Matches From: address field */
-    from?: string;
+    from?: string | undefined;
     /** Matches To: address field */
-    to?: string;
+    to?: string | undefined;
     /** Matches Cc: address field */
-    cc?: string;
+    cc?: string | undefined;
     /** Matches Bcc: address field */
-    bcc?: string;
+    bcc?: string | undefined;
     /** Matches message body */
-    body?: string;
+    body?: string | undefined;
     /** Matches message subject */
-    subject?: string;
+    subject?: string | undefined;
     /** Matches any text in headers and body */
-    text?: string;
+    text?: string | undefined;
     /** Matches messages larger than value */
-    larger?: number;
+    larger?: number | undefined;
     /** Matches messages smaller than value */
-    smaller?: number;
+    smaller?: number | undefined;
     /** UID sequence range */
-    uid?: SequenceString;
+    uid?: SequenceString | undefined;
     /** Matches messages with modseq higher than value */
-    modseq?: bigint;
+    modseq?: bigint | number | undefined;
     /** Unique email ID. Only used if server supports OBJECTID or X-GM-EXT-1 extensions */
-    emailId?: string;
+    emailId?: string | undefined;
     /** Unique thread ID. Only used if server supports OBJECTID or X-GM-EXT-1 extensions */
-    threadId?: string;
+    threadId?: string | undefined;
     /** Matches messages received before date */
-    before?: Date | string;
+    before?: Date | string | undefined;
     /** Matches messages received on date (ignores time) */
-    on?: Date | string;
+    on?: Date | string | undefined;
     /** Matches messages received after date */
-    since?: Date | string;
+    since?: Date | string | undefined;
     /** Matches messages sent before date */
-    sentBefore?: Date | string;
+    sentBefore?: Date | string | undefined;
     /** Matches messages sent on date (ignores time) */
-    sentOn?: Date | string;
+    sentOn?: Date | string | undefined;
     /** Matches messages sent after date */
-    sentSince?: Date | string;
+    sentSince?: Date | string | undefined;
     /** Matches messages that have the custom flag set */
-    keyword?: string;
+    keyword?: string | undefined;
     /** Matches messages that do not have the custom flag set */
-    unKeyword?: string;
+    unKeyword?: string | undefined;
     /** Matches messages with header key set if value is true or messages where header partially matches a string value */
-    header?: { [key: string]: boolean | string };
+    header?: {
+        [key: string]: boolean | string;
+    } | undefined;
     /** A SearchObject object. It must not match */
-    not?: SearchObject;
+    not?: SearchObject | undefined;
     /** An array of 2 or more SearchObject objects. At least one of these must match */
-    or?: SearchObject[];
+    or?: SearchObject[] | undefined;
     /** Gmail raw search query (only for Gmail) */
-    gmraw?: string;
+    gmraw?: string | undefined;
     /** Gmail raw search query (alias for gmraw) */
-    gmailraw?: string;
+    gmailraw?: string | undefined;
     /** Gmail label filter (only for Gmail). Compiles to an X-GM-RAW "label:"/"-label:" query. "has" matches messages carrying all listed labels, "not" excludes messages carrying any listed label */
-    labels?: { has?: string[]; not?: string[] };
+    labels?: {
+        has?: string[] | undefined;
+        not?: string[] | undefined;
+    } | undefined;
+}
+/**
+ * A message range: a sequence string, a list of sequence numbers or a search query
+ */
+export type MessageRange = SequenceString | number[] | SearchObject;
+export interface FetchBodyPartQuery {
+    /** Body part identifier, for example "1.2" or "HEADER" */
+    key: string;
+    /** Start offset in bytes */
+    start?: number | undefined;
+    /** Maximum number of bytes to fetch */
+    maxLength?: number | undefined;
 }
-
 export interface FetchQueryObject {
     /** If true then include UID in the response */
-    uid?: boolean;
+    uid?: boolean | undefined;
     /** If true then include flags Set in the response */
-    flags?: boolean;
+    flags?: boolean | undefined;
     /** If true then include parsed BODYSTRUCTURE object in the response */
-    bodyStructure?: boolean;
+    bodyStructure?: boolean | undefined;
     /** If true then include parsed ENVELOPE object in the response */
-    envelope?: boolean;
+    envelope?: boolean | undefined;
     /** If true then include internal date value in the response */
-    internalDate?: boolean;
+    internalDate?: boolean | undefined;
     /** If true then include message size in the response */
-    size?: boolean;
+    size?: boolean | undefined;
     /** If true then include full message in the response */
-    source?:
-        | boolean
-        | {
-              /** Include full message in the response starting from start byte */
-              start?: number;
-              /** Include full message in the response, up to maxLength bytes */
-              maxLength?: number;
-          };
+    source?: boolean | {
+        /** Include full message in the response starting from start byte */
+        start?: number | undefined;
+        /** Include full message in the response, up to maxLength bytes */
+        maxLength?: number | undefined;
+    } | undefined;
     /** If true then include thread ID in the response (only if server supports either OBJECTID or X-GM-EXT-1 extensions) */
-    threadId?: boolean;
+    threadId?: boolean | undefined;
     /** If true then include GMail labels in the response (only if server supports X-GM-EXT-1 extension) */
-    labels?: boolean;
+    labels?: boolean | undefined;
     /** If true then includes full headers of the message in the response. If the value is an array of header keys then includes only headers listed in the array */
-    headers?: boolean | string[];
+    headers?: boolean | string[] | undefined;
     /** An array of BODYPART identifiers to include in the response */
-    bodyParts?: Array<string | { key: string; start?: number; maxLength?: number }>;
+    bodyParts?: Array<string | FetchBodyPartQuery> | undefined;
     /** Fast macro equivalent to flags, internalDate, size */
-    fast?: boolean;
+    fast?: boolean | undefined;
     /** All macro equivalent to flags, internalDate, size, envelope */
-    all?: boolean;
+    all?: boolean | undefined;
     /** Full macro equivalent to flags, internalDate, size, envelope, bodyStructure */
-    full?: boolean;
+    full?: boolean | undefined;
 }
-
 export interface MessageAddressObject {
     /** Name of the address object (unicode) */
-    name?: string;
+    name?: string | undefined;
     /** Email address */
-    address?: string;
+    address?: string | undefined;
 }
-
 export interface MessageEnvelopeObject {
     /** Header date */
-    date?: Date;
+    date?: Date | string | undefined;
     /** Message subject (unicode) */
-    subject?: string;
+    subject?: string | undefined;
     /** Message ID of the message */
-    messageId?: string;
+    messageId?: string | undefined;
     /** Message ID from In-Reply-To header */
-    inReplyTo?: string;
+    inReplyTo?: string | undefined;
     /** Array of addresses from the From: header */
-    from?: MessageAddressObject[];
+    from?: MessageAddressObject[] | undefined;
     /** Array of addresses from the Sender: header */
-    sender?: MessageAddressObject[];
+    sender?: MessageAddressObject[] | undefined;
     /** Array of addresses from the Reply-To: header */
-    replyTo?: MessageAddressObject[];
+    replyTo?: MessageAddressObject[] | undefined;
     /** Array of addresses from the To: header */
-    to?: MessageAddressObject[];
+    to?: MessageAddressObject[] | undefined;
     /** Array of addresses from the Cc: header */
-    cc?: MessageAddressObject[];
+    cc?: MessageAddressObject[] | undefined;
     /** Array of addresses from the Bcc: header */
-    bcc?: MessageAddressObject[];
+    bcc?: MessageAddressObject[] | undefined;
 }
-
 export interface MessageStructureObject {
     /** Body part number. This value can be used to later fetch the contents of this part of the message */
-    part?: string;
+    part?: string | undefined;
     /** Content-Type of this node */
     type: string;
     /** Additional parameters for Content-Type, eg "charset" */
-    parameters?: { [key: string]: string };
+    parameters?: {
+        [key: string]: string;
+    } | undefined;
     /** Content-ID */
-    id?: string;
+    id?: string | undefined;
     /** Transfer encoding */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Expected size of the node */
-    size?: number;
+    size?: number | undefined;
     /** Message envelope of embedded RFC822 message */
-    envelope?: MessageEnvelopeObject;
+    envelope?: MessageEnvelopeObject | undefined;
     /** Content disposition */
-    disposition?: string;
+    disposition?: string | undefined;
     /** Additional parameters for Content-Disposition */
-    dispositionParameters?: { [key: string]: string };
+    dispositionParameters?: {
+        [key: string]: string;
+    } | undefined;
     /** An array of child nodes if this is a multipart node */
-    childNodes?: MessageStructureObject[];
+    childNodes?: MessageStructureObject[] | undefined;
     /** MD5 hash */
-    md5?: string;
+    md5?: string | undefined;
     /** Language */
-    language?: string[];
+    language?: string[] | undefined;
     /** Location */
-    location?: string;
+    location?: string | undefined;
     /** Description */
-    description?: string;
+    description?: string | undefined;
     /** Line count */
-    lineCount?: number;
+    lineCount?: number | undefined;
 }
-
 export interface FetchMessageObject {
     /** Message sequence number. Always included in the response */
     seq: number;
     /** Message UID number. Always included in the response */
     uid: number;
     /** Message source for the requested byte range */
-    source?: Buffer;
+    source?: Buffer | undefined;
     /** Message Modseq number. Always included if the server supports CONDSTORE extension */
-    modseq?: bigint;
+    modseq?: bigint | undefined;
     /** Unique email ID. Always included if server supports OBJECTID or X-GM-EXT-1 extensions */
-    emailId?: string;
+    emailId?: string | undefined;
     /** Unique thread ID. Only present if server supports OBJECTID or X-GM-EXT-1 extension */
-    threadId?: string;
+    threadId?: string | undefined;
     /** A Set of labels. Only present if server supports X-GM-EXT-1 extension */
-    labels?: Set<string>;
+    labels?: Set<string> | undefined;
     /** Message size */
-    size?: number;
+    size?: number | undefined;
     /** A set of message flags */
-    flags?: Set<string>;
+    flags?: Set<string> | undefined;
     /** Flag color like "red", or "yellow". This value is derived from the flags Set */
-    flagColor?: string;
+    flagColor?: string | undefined;
     /** Message envelope */
-    envelope?: MessageEnvelopeObject;
+    envelope?: MessageEnvelopeObject | undefined;
     /** Message body structure */
-    bodyStructure?: MessageStructureObject;
+    bodyStructure?: MessageStructureObject | undefined;
     /** Message internal date */
-    internalDate?: Date | string;
+    internalDate?: Date | string | undefined;
     /** A Map of message body parts where key is requested part identifier and value is a Buffer */
-    bodyParts?: Map<string, Buffer>;
+    bodyParts?: Map<string, Buffer> | undefined;
     /** Part identifiers from bodyParts that arrived via FETCH BINARY, i.e. with the content-transfer-encoding already decoded by the server */
-    binaryParts?: Set<string>;
+    binaryParts?: Set<string> | undefined;
     /** Requested header lines as Buffer */
-    headers?: Buffer;
+    headers?: Buffer | undefined;
     /** Account unique ID for this email */
-    id?: string;
+    id?: string | undefined;
+}
+export interface DownloadMeta {
+    /** The fetch response size */
+    expectedSize?: number | undefined;
+    /** Content-Type of the streamed file */
+    contentType?: string | undefined;
+    /** Charset of the body part */
+    charset?: string | undefined;
+    /** Content-Disposition of the streamed file */
+    disposition?: string | false | undefined;
+    /** Filename of the streamed body part */
+    filename?: string | undefined;
+    /** Transfer encoding */
+    encoding?: string | undefined;
+    /** If content uses flowed formatting */
+    flowed?: boolean | undefined;
+    /** If flowed text uses delSp */
+    delSp?: boolean | undefined;
 }
-
 export interface DownloadObject {
     /** Content metadata */
-    meta: {
-        /** The fetch response size */
-        expectedSize: number;
-        /** Content-Type of the streamed file */
-        contentType: string;
-        /** Charset of the body part */
-        charset?: string;
-        /** Content-Disposition of the streamed file */
-        disposition?: string;
-        /** Filename of the streamed body part */
-        filename?: string;
-        /** Transfer encoding */
-        encoding?: string;
-        /** If content uses flowed formatting */
-        flowed?: boolean;
-        /** If flowed text uses delSp */
-        delSp?: boolean;
-    };
+    meta: DownloadMeta;
     /** Streamed content */
     content: Readable;
 }
-
+export interface DownloadOptions {
+    /** If true then uses UID number instead of sequence number for `range` */
+    uid?: boolean | undefined;
+    /** If set then limits download size to specified bytes */
+    maxBytes?: number | undefined;
+    /** How large content parts to ask from the server. Defaults to 65536 */
+    chunkSize?: number | undefined;
+}
+/** Options for downloadMany(), the same shape as the download() options */
+export type DownloadManyOptions = DownloadOptions;
+export interface DownloadManyPart {
+    meta: DownloadMeta;
+    content?: Buffer | null | undefined;
+}
+export type DownloadManyResult = {
+    [part: string]: DownloadManyPart;
+};
 export interface AppendResponseObject {
     /** Full mailbox path where the message was uploaded to */
     destination: string;
     /** Mailbox UIDVALIDITY if server has UIDPLUS extension enabled */
-    uidValidity?: bigint;
+    uidValidity?: bigint | undefined;
     /** UID of the uploaded message if server has UIDPLUS extension enabled */
-    uid?: number;
+    uid?: number | undefined;
     /** Sequence number of the uploaded message if path is currently selected mailbox */
-    seq?: number;
+    seq?: number | undefined;
 }
-
 export interface CopyResponseObject {
     /** Path of source mailbox */
     path: string;
     /** Path of destination mailbox */
     destination: string;
     /** Destination mailbox UIDVALIDITY if server has UIDPLUS extension enabled */
-    uidValidity?: bigint;
+    uidValidity?: bigint | undefined;
     /** Map of UID values where key is UID in source mailbox and value is the UID for the same message in destination mailbox */
-    uidMap?: Map<number, number>;
+    uidMap?: Map<number, number> | undefined;
 }
-
 export interface FetchOptions {
     /** If true then uses UID numbers instead of sequence numbers */
-    uid?: boolean;
+    uid?: boolean | undefined;
     /** If set then only messages with a higher modseq value are returned */
-    changedSince?: bigint;
+    changedSince?: bigint | number | undefined;
     /** If true then requests a binary response if the server supports this */
-    binary?: boolean;
+    binary?: boolean | undefined;
 }
-
 export interface StoreOptions {
     /** If true then uses UID numbers instead of sequence numbers */
-    uid?: boolean;
+    uid?: boolean | undefined;
     /** If set then only messages with a lower or equal modseq value are updated */
-    unchangedSince?: bigint;
+    unchangedSince?: bigint | number | undefined;
     /** If true then update Gmail labels instead of message flags */
-    useLabels?: boolean;
+    useLabels?: boolean | undefined;
     /** If true then does not emit 'flags' event */
-    silent?: boolean;
+    silent?: boolean | undefined;
 }
-
 export interface MailboxOpenOptions {
     /** If true then opens mailbox in read-only mode */
-    readOnly?: boolean;
+    readOnly?: boolean | undefined;
     /** Optional description for mailbox lock tracking */
-    description?: string;
+    description?: string | undefined;
 }
-
 export interface MailboxLockOptions extends MailboxOpenOptions {
     /**
      * Optional timeout in milliseconds to wait for the lock to be granted.
      * If the lock cannot be acquired within this time, the promise rejects
      * with an error whose `code` is `'LockTimeout'`. Defaults to no timeout.
      */
-    acquireTimeout?: number;
+    acquireTimeout?: number | undefined;
     /**
      * Per-call override for the threshold after which a held lock triggers
      * a warning log entry. Overrides the ImapFlow constructor option of the
      * same name. Set to 0 or false to disable for this lock only.
      */
-    maxLockHoldTime?: number | false;
+    maxLockHoldTime?: number | false | undefined;
+}
+/** Options for messageCopy(), messageMove() and messageDelete() */
+export interface MessageRangeOptions {
+    /** If true then uses UID numbers instead of sequence numbers */
+    uid?: boolean | undefined;
+}
+/** A RETURN option for ESEARCH (RFC 4731) and PARTIAL (RFC 9394) searches */
+export type SearchReturnOption = 'MIN' | 'MAX' | 'COUNT' | 'ALL' | 'min' | 'max' | 'count' | 'all' | {
+    partial: string;
+};
+export interface SearchOptions {
+    /** If true then returns UID numbers instead of sequence numbers */
+    uid?: boolean | undefined;
+    /** ESEARCH RETURN options. When set, the result is an ESearchResult object */
+    returnOptions?: SearchReturnOption[] | undefined;
 }
-
 export interface ExpungeEvent {
     /** Mailbox path */
     path: string;
     /** Sequence number (if vanished is false) */
-    seq?: number;
+    seq?: number | undefined;
     /** UID number (if vanished is true or QRESYNC is enabled) */
-    uid?: number;
+    uid?: number | undefined;
     /** True if message was expunged using VANISHED response */
     vanished: boolean;
     /** True if VANISHED EARLIER response */
-    earlier?: boolean;
+    earlier?: boolean | undefined;
 }
-
 export interface ExistsEvent {
     /** Mailbox path */
     path: string;
@@ -680,25 +726,31 @@ export interface ExistsEvent {
     /** Message count before this update */
     prevCount: number;
 }
-
 export interface FlagsEvent {
     /** Mailbox path */
     path: string;
     /** Sequence number of updated message */
     seq: number;
     /** UID number of updated message (if server provided this value) */
-    uid?: number;
+    uid?: number | undefined;
     /** Updated modseq number for the mailbox */
-    modseq?: bigint;
+    modseq?: bigint | undefined;
     /** A set of all flags for the updated message */
     flags: Set<string>;
     /** Flag color if message is flagged */
-    flagColor?: string;
-}
-
+    flagColor?: string | undefined;
+}
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/**
+ * The logger a connection uses internally: every level is always callable, whatever the
+ * configured logger supports, and entries are mirrored as 'log' events when `emitLogs` is set
+ */
+export type InternalLogger = {
+    [level in LogLevel]: (obj: any) => void;
+};
 export interface LogEvent {
     /** Log level */
-    level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    level: LogLevel;
     /** Timestamp */
     t: number;
     /** Connection ID */
@@ -708,251 +760,69 @@ export interface LogEvent {
     /** Additional log data */
     [key: string]: any;
 }
-
 export interface ResponseEvent {
     /** Response type */
     response: string;
     /** Response code */
-    code?: string;
+    code?: string | undefined;
 }
-
 /** Result object returned by ESEARCH (RFC 4731) when returnOptions is specified */
 export interface ESearchResult {
     /** Total number of matching messages */
-    count?: number;
+    count?: number | undefined;
     /** Lowest matching UID */
-    min?: number;
+    min?: number | undefined;
     /** Highest matching UID */
-    max?: number;
+    max?: number | undefined;
     /** All matching UIDs as compact sequence-set string (e.g. "1,5:10,20") */
-    all?: string;
+    all?: string | undefined;
     /** Paged subset (RFC 9394 PARTIAL) */
     partial?: {
         /** The requested range, e.g. "1:100" */
         range: string;
         /** Matching UIDs in that range as compact sequence-set */
         messages: string;
-    };
+    } | undefined;
     /** Highest mod-sequence of the matching messages (RFC 7162, present when the search used a modseq criterion on a CONDSTORE session) */
-    modseq?: bigint;
-}
-
-export class AuthenticationFailure extends Error {
-    authenticationFailed: true;
-    serverResponseCode?: string;
-    response?: string;
-    oauthError?: any;
-}
-
-export class ImapFlow extends EventEmitter {
-    /** Current module version */
-    static version: string;
-
-    /** Instance ID for logs */
-    id: string;
-
-    /** Server identification info */
-    serverInfo: IdInfoObject | null;
-
-    /** Is the connection currently encrypted or not */
-    secureConnection: boolean;
-
-    /** Active IMAP capabilities */
-    capabilities: Map<string, boolean | number>;
-
-    /** Enabled capabilities */
-    enabled: Set<string>;
-
-    /** Is the connection currently usable or not */
-    usable: boolean;
-
-    /** Currently authenticated user */
-    authenticated: string | boolean;
-
-    /** Currently selected mailbox */
-    mailbox: MailboxObject | false;
-
-    /** Is current mailbox idling */
-    idling: boolean;
-
-    constructor(options: ImapFlowOptions);
-
-    /** Initiates a connection against IMAP server */
-    connect(): Promise<void>;
-
-    /** Graceful connection close by sending logout command to server */
-    logout(): Promise<void>;
-
-    /** Closes TCP connection without notifying the server */
-    close(): void;
-
-    /** Returns current quota */
-    getQuota(path?: string | string[]): Promise<QuotaResponse | false>;
-
-    /** Lists available mailboxes as an Array */
-    list(options?: ListOptions): Promise<ListResponse[]>;
-
-    /** Lists available mailboxes as a tree structured object */
-    listTree(options?: ListOptions): Promise<ListTreeResponse>;
-
-    /** Performs a no-op call against server */
-    noop(): Promise<void>;
-
-    /** Creates a new mailbox folder */
-    mailboxCreate(path: string | string[]): Promise<MailboxCreateResponse>;
-
-    /** Renames a mailbox */
-    mailboxRename(path: string | string[], newPath: string | string[]): Promise<MailboxRenameResponse>;
-
-    /** Deletes a mailbox */
-    mailboxDelete(path: string | string[]): Promise<MailboxDeleteResponse>;
-
-    /** Subscribes to a mailbox */
-    mailboxSubscribe(path: string | string[]): Promise<boolean>;
-
-    /** Unsubscribes from a mailbox */
-    mailboxUnsubscribe(path: string | string[]): Promise<boolean>;
-
-    /** Opens a mailbox to access messages */
-    mailboxOpen(path: string | string[], options?: MailboxOpenOptions): Promise<MailboxObject>;
-
-    /** Closes a previously opened mailbox */
-    mailboxClose(): Promise<boolean>;
-
-    /** Requests the status of the indicated mailbox */
-    status(
-        path: string | string[],
-        query: {
-            messages?: boolean;
-            recent?: boolean;
-            uidNext?: boolean;
-            uidValidity?: boolean;
-            unseen?: boolean;
-            highestModseq?: boolean;
-            /** Requires STATUS=SIZE or IMAP4rev2 */
-            size?: boolean;
-            /** Requires IMAP4rev2 */
-            deleted?: boolean;
-        }
-    ): Promise<StatusObject>;
-
-    /** Starts listening for new or deleted messages from the currently opened mailbox */
-    idle(): Promise<boolean>;
-
-    /** Sets flags for a message or message range */
-    messageFlagsSet(range: SequenceString | number[] | SearchObject, flags: string[], options?: StoreOptions): Promise<boolean>;
-
-    /** Adds flags for a message or message range */
-    messageFlagsAdd(range: SequenceString | number[] | SearchObject, flags: string[], options?: StoreOptions): Promise<boolean>;
-
-    /** Remove specific flags from a message or message range */
-    messageFlagsRemove(range: SequenceString | number[] | SearchObject, flags: string[], options?: StoreOptions): Promise<boolean>;
-
-    /** Sets a colored flag for an email */
-    setFlagColor(range: SequenceString | number[] | SearchObject, color: string, options?: StoreOptions): Promise<boolean>;
-
-    /** Delete messages from the currently opened mailbox */
-    messageDelete(range: SequenceString | number[] | SearchObject, options?: { uid?: boolean }): Promise<boolean>;
-
-    /** Appends a new message to a mailbox */
-    append(path: string | string[], content: string | Buffer, flags?: string[], idate?: Date | string): Promise<AppendResponseObject | false>;
-
-    /** Copies messages from current mailbox to destination mailbox */
-    messageCopy(
-        range: SequenceString | number[] | SearchObject,
-        destination: string | string[],
-        options?: { uid?: boolean }
-    ): Promise<CopyResponseObject | false>;
-
-    /** Moves messages from current mailbox to destination mailbox */
-    messageMove(
-        range: SequenceString | number[] | SearchObject,
-        destination: string | string[],
-        options?: { uid?: boolean }
-    ): Promise<CopyResponseObject | false>;
-
-    /** Search messages from the currently opened mailbox — returns number[] (backward-compatible) */
-    search(query: SearchObject, options?: { uid?: boolean }): Promise<number[] | false>;
-    /** Search messages with ESEARCH RETURN options — returns ESearchResult */
-    search(
-        query: SearchObject,
-        options: {
-            uid?: boolean;
-            returnOptions: Array<'MIN' | 'MAX' | 'COUNT' | 'ALL' | { partial: string }>;
-        }
-    ): Promise<ESearchResult | number[] | false>;
-
-    /** Fetch messages from the currently opened mailbox */
-    fetch(range: SequenceString | number[] | SearchObject, query: FetchQueryObject, options?: FetchOptions): AsyncIterableIterator<FetchMessageObject>;
-
-    /** Fetch all messages from the currently opened mailbox */
-    fetchAll(range: SequenceString | number[] | SearchObject, query: FetchQueryObject, options?: FetchOptions): Promise<FetchMessageObject[]>;
-
-    /** Fetch a single message from the currently opened mailbox */
-    fetchOne(seq: SequenceString, query: FetchQueryObject, options?: FetchOptions): Promise<FetchMessageObject | false>;
-
-    /** Download either full rfc822 formatted message or a specific bodystructure part as a Stream */
-    download(
-        range: SequenceString,
-        part?: string,
-        options?: {
-            uid?: boolean;
-            maxBytes?: number;
-            chunkSize?: number;
-        }
-    ): Promise<DownloadObject>;
-
-    /** Fetch multiple attachments as Buffer values */
-    downloadMany(
-        range: SequenceString,
-        parts: string[],
-        options?: { uid?: boolean }
-    ): Promise<{
-        [part: string]: {
-            meta: {
-                contentType?: string;
-                charset?: string;
-                disposition?: string;
-                filename?: string;
-                encoding?: string;
-            };
-            content: Buffer | null;
-        };
-    }>;
-
-    /** Opens a mailbox if not already open and returns a lock */
-    getMailboxLock(path: string | string[], options?: MailboxLockOptions): Promise<MailboxLockObject>;
-
-    /** Returns byte counters for the current connection, optionally resets them */
-    stats(reset?: boolean): { sent: number; received: number };
-
-    /** Detaches sockets from the IMAP pipeline, returns read and write sockets */
-    unbind(): { readSocket: any; writeSocket: any };
-
+    modseq?: bigint | undefined;
+}
+/** A single IMAP namespace entry as reported by the NAMESPACE command */
+export interface NamespaceObject {
+    /** Namespace prefix */
+    prefix: string;
+    /** Hierarchy delimiter. `null` when the server reported NIL (a flat namespace, RFC 2342 section 5), `undefined` when the LIST fallback could not determine it */
+    delimiter: string | null | undefined;
+}
+/** Namespaces reported by the server, grouped by type. `other` and `shared` are `false` when the server reported none */
+export interface NamespacesObject {
+    personal: NamespaceObject[];
+    other: NamespaceObject[] | false;
+    shared: NamespaceObject[] | false;
+}
+/** Negotiated TLS session details, from `tls.TLSSocket#getCipher()` plus the authorization state */
+export interface TlsInfo extends CipherNameAndProtocol {
+    authorized?: boolean | undefined;
+}
+/**
+ * Events emitted by an ImapFlow client
+ */
+export interface ImapFlowEvents {
     /** Connection close event */
-    on(event: 'close', listener: () => void): this;
-
+    close: [];
     /** Error event */
-    on(event: 'error', listener: (error: Error) => void): this;
-
+    error: [error: Error];
     /** Message count in currently opened mailbox changed */
-    on(event: 'exists', listener: (data: ExistsEvent) => void): this;
-
+    exists: [data: ExistsEvent];
     /** Deleted message sequence number in currently opened mailbox */
-    on(event: 'expunge', listener: (data: ExpungeEvent) => void): this;
-
+    expunge: [data: ExpungeEvent];
     /** Flags were updated for a message */
-    on(event: 'flags', listener: (data: FlagsEvent) => void): this;
-
+    flags: [data: FlagsEvent];
     /** Mailbox was opened */
-    on(event: 'mailboxOpen', listener: (mailbox: MailboxObject) => void): this;
-
+    mailboxOpen: [mailbox: MailboxObject];
     /** Mailbox was closed, either explicitly or because the connection went away while a mailbox was still selected */
-    on(event: 'mailboxClose', listener: (mailbox: MailboxObject) => void): this;
-
+    mailboxClose: [mailbox: MailboxObject];
     /** Log event if emitLogs=true */
-    on(event: 'log', listener: (entry: LogEvent) => void): this;
-
+    log: [entry: LogEvent];
     /** Response event */
-    on(event: 'response', listener: (response: ResponseEvent) => void): this;
+    response: [response: ResponseEvent];
 }