m06_task3.js 1.0.0

package/package/node_modules/@types/nodemailer/lib/dkim/index.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+
+import { PassThrough, Readable } from 'stream';
+
+declare namespace DKIM {
+    interface OptionalOptions {
+        /** optional location for cached messages. If not set then caching is not used. */
+        cacheDir?: string | false | undefined;
+        /** optional size in bytes, if message is larger than this treshold it gets cached to disk (assuming cacheDir is set and writable). Defaults to 131072 (128 kB). */
+        cacheTreshold?: number | undefined;
+        /** optional algorithm for the body hash, defaults to ‘sha256’ */
+        hashAlgo?: string | undefined;
+        /** an optional colon separated list of header keys to sign (eg. message-id:date:from:to...') */
+        headerFieldNames?: string | undefined;
+        /** optional colon separated list of header keys not to sign. This is useful if you want to sign all the relevant keys but your provider changes some values, ie Message-ID and Date. In this case you should use 'message-id:date' to prevent signing these values. */
+        skipFields?: string | undefined;
+    }
+
+    interface SingleKeyOptions extends OptionalOptions {
+        /** is the domain name to use in the signature */
+        domainName: string;
+        /** is the DKIM key selector */
+        keySelector: string;
+        /** is the private key for the selector in PEM format */
+        privateKey: string | { key: string; passphrase: string };
+    }
+
+    interface MultipleKeysOptions extends OptionalOptions {
+        /** is an optional array of key objects (domainName, keySelector, privateKey) if you want to add more than one signature to the message. If this value is set then the default key values are ignored */
+        keys: SingleKeyOptions[];
+    }
+
+    type Options = SingleKeyOptions | MultipleKeysOptions;
+}
+
+declare class DKIM {
+    options: DKIM.Options;
+    keys: DKIM.SingleKeyOptions[];
+
+    constructor(options?: DKIM.Options);
+
+    sign(input: string | Buffer | Readable, extraOptions?: DKIM.Options): PassThrough;
+}
+
+export = DKIM;

package/package/node_modules/@types/nodemailer/lib/dkim/message-parser.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+
+import { Transform } from 'stream';
+
+declare namespace MessageParser {
+    interface Header {
+        key: string;
+        line: string;
+    }
+}
+
+/**
+ * MessageParser instance is a transform stream that separates message headers
+ * from the rest of the body. Headers are emitted with the 'headers' event. Message
+ * body is passed on as the resulting stream.
+ */
+declare class MessageParser extends Transform {
+    addListener(event: 'headers', listener: (headers: MessageParser.Header[]) => void): this;
+    addListener(event: 'close', listener: () => void): this;
+    addListener(event: 'data', listener: (chunk: any) => void): this;
+    addListener(event: 'end', listener: () => void): this;
+    addListener(event: 'readable', listener: () => void): this;
+    addListener(event: 'error', listener: (err: Error) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    emit(event: 'headers', headers: MessageParser.Header[]): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'data', chunk: any): boolean;
+    emit(event: 'end'): boolean;
+    emit(event: 'readable'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+
+    on(event: 'headers', listener: (headers: MessageParser.Header[]) => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'data', listener: (chunk: any) => void): this;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'readable', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    once(event: 'headers', listener: (headers: MessageParser.Header[]) => void): this;
+    once(event: 'close', listener: () => void): this;
+    once(event: 'data', listener: (chunk: any) => void): this;
+    once(event: 'end', listener: () => void): this;
+    once(event: 'readable', listener: () => void): this;
+    once(event: 'error', listener: (err: Error) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependListener(event: 'headers', listener: (headers: MessageParser.Header[]) => void): this;
+    prependListener(event: 'close', listener: () => void): this;
+    prependListener(event: 'data', listener: (chunk: any) => void): this;
+    prependListener(event: 'end', listener: () => void): this;
+    prependListener(event: 'readable', listener: () => void): this;
+    prependListener(event: 'error', listener: (err: Error) => void): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependOnceListener(event: 'headers', listener: (headers: MessageParser.Header[]) => void): this;
+    prependOnceListener(event: 'close', listener: () => void): this;
+    prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
+    prependOnceListener(event: 'end', listener: () => void): this;
+    prependOnceListener(event: 'readable', listener: () => void): this;
+    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: 'headers', listener: (headers: MessageParser.Header[]) => void): this;
+    removeListener(event: 'close', listener: () => void): this;
+    removeListener(event: 'data', listener: (chunk: any) => void): this;
+    removeListener(event: 'end', listener: () => void): this;
+    removeListener(event: 'readable', listener: () => void): this;
+    removeListener(event: 'error', listener: (err: Error) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+export = MessageParser;

package/package/node_modules/@types/nodemailer/lib/dkim/relaxed-body.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+
+import { Transform, TransformOptions } from 'stream';
+
+declare namespace RelaxedBody {
+    interface Options extends TransformOptions {
+        hashAlgo?: string;
+        debug?: boolean;
+    }
+}
+
+/**
+ * Streams through a message body and calculates relaxed body hash
+ */
+declare class RelaxedBody extends Transform {
+    constructor(options?: RelaxedBody.Options);
+
+    addListener(event: 'hash', listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    addListener(event: 'close', listener: () => void): this;
+    addListener(event: 'data', listener: (chunk: any) => void): this;
+    addListener(event: 'end', listener: () => void): this;
+    addListener(event: 'readable', listener: () => void): this;
+    addListener(event: 'error', listener: (err: Error) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    emit(event: 'hash', digest: Buffer, debugBody: Buffer | false): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'data', chunk: any): boolean;
+    emit(event: 'end'): boolean;
+    emit(event: 'readable'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+
+    on(event: 'hash', listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'data', listener: (chunk: any) => void): this;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'readable', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    once(event: 'hash', listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    once(event: 'close', listener: () => void): this;
+    once(event: 'data', listener: (chunk: any) => void): this;
+    once(event: 'end', listener: () => void): this;
+    once(event: 'readable', listener: () => void): this;
+    once(event: 'error', listener: (err: Error) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependListener(event: 'hash', listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    prependListener(event: 'close', listener: () => void): this;
+    prependListener(event: 'data', listener: (chunk: any) => void): this;
+    prependListener(event: 'end', listener: () => void): this;
+    prependListener(event: 'readable', listener: () => void): this;
+    prependListener(event: 'error', listener: (err: Error) => void): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependOnceListener(event: 'hash', listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    prependOnceListener(event: 'close', listener: () => void): this;
+    prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
+    prependOnceListener(event: 'end', listener: () => void): this;
+    prependOnceListener(event: 'readable', listener: () => void): this;
+    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: 'hash', listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    removeListener(event: 'close', listener: () => void): this;
+    removeListener(event: 'data', listener: (chunk: any) => void): this;
+    removeListener(event: 'end', listener: () => void): this;
+    removeListener(event: 'readable', listener: () => void): this;
+    removeListener(event: 'error', listener: (err: Error) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+export = RelaxedBody;

package/package/node_modules/@types/nodemailer/lib/dkim/sign.d.ts

@@ -0,0 +1,11 @@
+import DKIM = require('.');
+import MessageParser = require('./message-parser');
+
+/** Returns DKIM signature header line */
+declare function relaxedHeaders(headers: MessageParser.Header[], hashAlgo: string, bodyHash: string, options?: DKIM.SingleKeyOptions): string;
+
+declare namespace relaxedHeaders {
+    function relaxedHeaders(headers: MessageParser.Header[], hashAlgo: string, bodyHash: string, options?: DKIM.SingleKeyOptions): string;
+}
+
+export = relaxedHeaders;

package/package/node_modules/@types/nodemailer/lib/fetch/cookies.d.ts

@@ -0,0 +1,54 @@
+type s = number;
+
+declare namespace Cookies {
+    interface Cookie {
+        name: string;
+        value?: string | undefined;
+        expires?: Date | undefined;
+        path?: string | undefined;
+        domain?: string | undefined;
+        secure?: boolean | undefined;
+        httponly?: boolean | undefined;
+    }
+
+    interface Options {
+        sessionTimeout?: s | undefined;
+    }
+}
+
+/** Creates a biskviit cookie jar for managing cookie values in memory */
+declare class Cookies {
+    options: Cookies.Options;
+    cookies: Cookies.Cookie[];
+
+    constructor(options?: Cookies.Options);
+
+    /** Stores a cookie string to the cookie storage */
+    set(cookieStr: string, url: string): boolean;
+
+    /** Returns cookie string for the 'Cookie:' header. */
+    get(url: string): string;
+
+    /** Lists all valied cookie objects for the specified URL */
+    list(url: string): Cookies.Cookie[];
+
+    /** Parses cookie string from the 'Set-Cookie:' header */
+    parse(cookieStr: string): Cookies.Cookie;
+
+    /** Checks if a cookie object is valid for a specified URL */
+    match(cookie: Cookies.Cookie, url: string): boolean;
+
+    /** Adds (or updates/removes if needed) a cookie object to the cookie storage */
+    add(cookie: Cookies.Cookie): boolean;
+
+    /** Checks if two cookie objects are the same */
+    compare(a: Cookies.Cookie, b: Cookies.Cookie): boolean;
+
+    /** Checks if a cookie is expired */
+    isExpired(cookie: Cookies.Cookie): boolean;
+
+    /** Returns normalized cookie path for an URL path argument */
+    getPath(pathname: string): string;
+}
+
+export = Cookies;

package/package/node_modules/@types/nodemailer/lib/fetch/index.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+
+type ms = number;
+
+import _Cookies = require('./cookies');
+
+import * as http from 'http';
+import { Writable } from 'stream';
+import * as tls from 'tls';
+
+declare namespace fetch {
+    type Cookies = _Cookies;
+
+    interface WritableResponse extends Writable {
+        statusCode: number;
+        headers: http.IncomingHttpHeaders;
+    }
+
+    interface Options {
+        fetchRes?: Writable | undefined;
+        cookies?: Cookies | undefined;
+        cookie?: string | undefined;
+        redirects?: number | undefined;
+        maxRedirects?: number | undefined;
+        method?: string | undefined;
+        headers?: { [key: string]: string } | undefined;
+        userAgent?: string | undefined;
+        body?: Buffer | string | { [key: string]: string } | undefined;
+        contentType?: string | false | undefined;
+        tls?: tls.TlsOptions | undefined;
+        timeout?: ms | undefined;
+        allowErrorResponse?: boolean | undefined;
+    }
+}
+
+declare function fetch(url: string, options?: fetch.Options): fetch.WritableResponse;
+
+export = fetch;

package/package/node_modules/@types/nodemailer/lib/json-transport/index.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+
+import { Transport, TransportOptions } from '../..';
+
+import * as shared from '../shared';
+
+import Mail = require('../mailer');
+import MailMessage = require('../mailer/mail-message');
+import MimeNode = require('../mime-node');
+
+declare namespace JSONTransport {
+    type MailOptions = Mail.Options;
+
+    interface Options extends MailOptions, TransportOptions {
+        jsonTransport: true;
+        skipEncoding?: boolean | undefined;
+    }
+
+    interface SentMessageInfo {
+        /** an envelope object {from:‘address’, to:[‘address’]} */
+        envelope: MimeNode.Envelope;
+        /** the Message-ID header value */
+        messageId: string;
+        /** JSON string */
+        message: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+        response: string;
+    }
+}
+
+declare class JSONTransport implements Transport<JSONTransport.SentMessageInfo> {
+    options: JSONTransport.Options;
+
+    logger: shared.Logger;
+    mailer: Mail<JSONTransport.SentMessageInfo>;
+
+    name: string;
+    version: string;
+
+    constructor(options: JSONTransport.Options);
+
+    /** Compiles a mailcomposer message and forwards it to handler that sends it */
+    send(mail: MailMessage<JSONTransport.SentMessageInfo>, callback: (err: Error | null, info: JSONTransport.SentMessageInfo) => void): void;
+}
+
+export = JSONTransport;

package/package/node_modules/@types/nodemailer/lib/mail-composer/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+
+import { URL } from 'url';
+
+import Mail = require('../mailer');
+import MimeNode = require('../mime-node');
+
+/** Creates the object for composing a MimeNode instance out from the mail options */
+declare class MailComposer {
+  mail: Mail.Options;
+  message: MimeNode | false;
+
+  constructor(mail: Mail.Options);
+
+  /** Builds MimeNode instance */
+  compile(): MimeNode;
+
+  /** List all attachments. Resulting attachment objects can be used as input for MimeNode nodes */
+  getAttachments(findRelated: boolean): Mail.Attachment[];
+
+  /** List alternatives. Resulting objects can be used as input for MimeNode nodes */
+  getAlternatives(): Mail.Attachment[];
+}
+
+export = MailComposer;

package/package/node_modules/@types/nodemailer/lib/mailer/index.d.ts

@@ -0,0 +1,230 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+import { Socket } from 'net';
+import { Readable } from 'stream';
+import { Url } from 'url';
+
+import { Transport, TransportOptions } from '../..';
+import * as shared from '../shared';
+
+import DKIM = require('../dkim');
+import MailMessage = require('./mail-message');
+import MimeNode = require('../mime-node');
+import SMTPConnection = require('../smtp-connection');
+import XOAuth2 = require('../xoauth2');
+
+declare namespace Mail {
+    type Headers = { [key: string]: string | string[] | { prepared: boolean, value: string } } | Array<{ key: string, value: string }>;
+
+    type ListHeader = string | { url: string, comment: string };
+
+    interface ListHeaders {
+        [key: string]: ListHeader | ListHeader[] | ListHeader[][];
+    }
+
+    type TextEncoding = 'quoted-printable' | 'base64';
+
+    interface Address {
+        name: string;
+        address: string;
+    }
+
+    interface AttachmentLike {
+        /** String, Buffer or a Stream contents for the attachmentent */
+        content?: string | Buffer | Readable | undefined;
+        /** path to a file or an URL (data uris are allowed as well) if you want to stream the file instead of including it (better for larger attachments) */
+        path?: string | Url | undefined;
+    }
+
+    interface Attachment extends AttachmentLike {
+        /** filename to be reported as the name of the attached file, use of unicode is allowed. If you do not want to use a filename, set this value as false, otherwise a filename is generated automatically */
+        filename?: string | false | undefined;
+        /** optional content id for using inline images in HTML message source. Using cid sets the default contentDisposition to 'inline' and moves the attachment into a multipart/related mime node, so use it only if you actually want to use this attachment as an embedded image */
+        cid?: string | undefined;
+        /** If set and content is string, then encodes the content to a Buffer using the specified encoding. Example values: base64, hex, binary etc. Useful if you want to use binary attachments in a JSON formatted e-mail object */
+        encoding?: string | undefined;
+        /** optional content type for the attachment, if not set will be derived from the filename property */
+        contentType?: string | undefined;
+        /** optional transfer encoding for the attachment, if not set it will be derived from the contentType property. Example values: quoted-printable, base64. If it is unset then base64 encoding is used for the attachment. If it is set to false then previous default applies (base64 for most, 7bit for text). */
+        contentTransferEncoding?: '7bit' | 'base64' | 'quoted-printable' | false | undefined;
+        /** optional content disposition type for the attachment, defaults to ‘attachment’ */
+        contentDisposition?: 'attachment' | 'inline' | undefined;
+        /** is an object of additional headers */
+        headers?: Headers | undefined;
+        /** an optional value that overrides entire node content in the mime message. If used then all other options set for this node are ignored. */
+        raw?: string | Buffer | Readable | AttachmentLike | undefined;
+    }
+
+    interface AmpAttachment extends AttachmentLike {
+        /** is an alternative for content to load the AMP4EMAIL data from an URL */
+        href?: string | undefined;
+        /** defines optional content encoding, eg. ‘base64’ or ‘hex’. This only applies if the content is a string. By default an unicode string is assumed. */
+        encoding?: string | undefined;
+        /** optional content type for the attachment, if not set will be derived from the filename property */
+        contentType?: string | undefined;
+        /** an optional value that overrides entire node content in the mime message. If used then all other options set for this node are ignored. */
+        raw?: string | Buffer | Readable | AttachmentLike | undefined;
+    }
+
+    interface IcalAttachment extends AttachmentLike {
+        /** optional method, case insensitive, defaults to ‘publish’. Other possible values would be ‘request’, ‘reply’, ‘cancel’ or any other valid calendar method listed in RFC5546. This should match the METHOD: value in calendar event file. */
+        method?: string | undefined;
+        /** optional filename, defaults to ‘invite.ics’ */
+        filename?: string | false | undefined;
+        /** is an alternative for content to load the calendar data from an URL */
+        href?: string | undefined;
+        /** defines optional content encoding, eg. ‘base64’ or ‘hex’. This only applies if the content is a string. By default an unicode string is assumed. */
+        encoding?: string | undefined;
+    }
+
+    interface Connection {
+        connection: Socket;
+    }
+
+    interface Envelope {
+        /** the first address gets used as MAIL FROM address in SMTP */
+        from?: string | undefined;
+        /** addresses from this value get added to RCPT TO list */
+        to?: string | undefined;
+        /** addresses from this value get added to RCPT TO list */
+        cc?: string | undefined;
+        /** addresses from this value get added to RCPT TO list */
+        bcc?: string | undefined;
+    }
+
+    interface Options {
+        /** The e-mail address of the sender. All e-mail addresses can be plain 'sender@server.com' or formatted 'Sender Name <sender@server.com>' */
+        from?: string | Address | undefined;
+        /** An e-mail address that will appear on the Sender: field */
+        sender?: string | Address | undefined;
+        /** Comma separated list or an array of recipients e-mail addresses that will appear on the To: field */
+        to?: string | Address | Array<string | Address> | undefined;
+        /** Comma separated list or an array of recipients e-mail addresses that will appear on the Cc: field */
+        cc?: string | Address | Array<string | Address> | undefined;
+        /** Comma separated list or an array of recipients e-mail addresses that will appear on the Bcc: field */
+        bcc?: string | Address | Array<string | Address> | undefined;
+        /** Comma separated list or an array of e-mail addresses that will appear on the Reply-To: field */
+        replyTo?: string | Address | Array<string | Address> | undefined;
+        /** The message-id this message is replying */
+        inReplyTo?: string | Address | undefined;
+        /** Message-id list (an array or space separated string) */
+        references?: string | string[] | undefined;
+        /** The subject of the e-mail */
+        subject?: string | undefined;
+        /** The plaintext version of the message */
+        text?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** The HTML version of the message */
+        html?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** Apple Watch specific HTML version of the message, same usage as with text and html */
+        watchHtml?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** AMP4EMAIL specific HTML version of the message, same usage as with text and html. Make sure it is a full and valid AMP4EMAIL document, otherwise the displaying email client falls back to html and ignores the amp part */
+        amp?: string | Buffer | Readable | AmpAttachment | undefined;
+        /** iCalendar event, same usage as with text and html. Event method attribute defaults to ‘PUBLISH’ or define it yourself: {method: 'REQUEST', content: iCalString}. This value is added as an additional alternative to html or text. Only utf-8 content is allowed */
+        icalEvent?: string | Buffer | Readable | IcalAttachment | undefined;
+        /** An object or array of additional header fields */
+        headers?: Headers | undefined;
+        /** An object where key names are converted into list headers. List key help becomes List-Help header etc. */
+        list?: ListHeaders | undefined;
+        /** An array of attachment objects */
+        attachments?: Attachment[] | undefined;
+        /** An array of alternative text contents (in addition to text and html parts) */
+        alternatives?: Attachment[] | undefined;
+        /** optional SMTP envelope, if auto generated envelope is not suitable */
+        envelope?: Envelope | MimeNode.Envelope | undefined;
+        /** optional Message-Id value, random value will be generated if not set */
+        messageId?: string | undefined;
+        /** optional Date value, current UTC string will be used if not set */
+        date?: Date | string | undefined;
+        /** optional transfer encoding for the textual parts */
+        encoding?: string | undefined;
+        /** if set then overwrites entire message output with this value. The value is not parsed, so you should still set address headers or the envelope value for the message to work */
+        raw?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** set explicitly which encoding to use for text parts (quoted-printable or base64). If not set then encoding is detected from text content (mostly ascii means quoted-printable, otherwise base64) */
+        textEncoding?: TextEncoding | undefined;
+        /** if set to true then fails with an error when a node tries to load content from URL */
+        disableUrlAccess?: boolean | undefined;
+        /** if set to true then fails with an error when a node tries to load content from a file */
+        disableFileAccess?: boolean | undefined;
+        /** is an object with DKIM options */
+        dkim?: DKIM.Options | undefined;
+        /** method to normalize header keys for custom caseing */
+        normalizeHeaderKey?(key: string): string;
+        priority?: "high"|"normal"|"low" | undefined;
+    }
+
+    type PluginFunction<T = any> = (mail: MailMessage<T>, callback: (err?: Error | null) => void) => void;
+}
+
+/** Creates an object for exposing the Mail API */
+declare class Mail<T = any> extends EventEmitter {
+    options: Mail.Options;
+    meta: Map<string, any>;
+    dkim: DKIM;
+    transporter: Transport<T>;
+    logger: shared.Logger;
+
+    /** Usage: typeof transporter.MailMessage */
+    MailMessage: MailMessage<T>;
+
+    constructor(transporter: Transport<T>, options?: TransportOptions, defaults?: TransportOptions);
+
+    /** Closes all connections in the pool. If there is a message being sent, the connection is closed later */
+    close(): void;
+
+    /** Returns true if there are free slots in the queue */
+    isIdle(): boolean;
+
+    /** Verifies SMTP configuration */
+    verify(callback: (err: Error | null, success: true) => void): void;
+    verify(): Promise<true>;
+
+    use(step: string, plugin: Mail.PluginFunction<T>): this;
+
+    /** Sends an email using the preselected transport object */
+    sendMail(mailOptions: Mail.Options, callback: (err: Error | null, info: T) => void): void;
+    sendMail(mailOptions: Mail.Options): Promise<T>;
+
+    getVersionString(): string;
+
+    /** Sets up proxy handler for a Nodemailer object */
+    setupProxy(proxyUrl: string): void;
+
+    set(key: 'oauth2_provision_cb', value: (user: string, renew: boolean, callback: (err: Error | null, accessToken?: string, expires?: number) => void) => void): Map<string, any>;
+    set(key: 'proxy_handler_http' | 'proxy_handler_https' | 'proxy_handler_socks' | 'proxy_handler_socks5' | 'proxy_handler_socks4' | 'proxy_handler_socks4a', value: (proxy: Url, options: TransportOptions, callback: (err: Error | null, socketOptions?: { connection: Socket }) => void) => void): Map<string, any>;
+    set(key: string, value: any): Map<string, any>;
+
+    get(key: 'oauth2_provision_cb'): (user: string, renew: boolean, callback: (err: Error | null, accessToken: string, expires: number) => void) => void;
+    get(key: 'proxy_handler_http' | 'proxy_handler_https' | 'proxy_handler_socks' | 'proxy_handler_socks5' | 'proxy_handler_socks4' | 'proxy_handler_socks4a'): (proxy: Url, options: TransportOptions, callback: (err: Error | null, socketOptions: { connection: Socket }) => void) => void;
+    get(key: string): any;
+
+    addListener(event: 'error', listener: (err: Error) => void): this;
+    addListener(event: 'idle', listener: () => void): this;
+    addListener(event: 'token', listener: (token: XOAuth2.Token) => void): this;
+
+    emit(event: 'error', error: Error): boolean;
+    emit(event: 'idle'): boolean;
+    emit(event: 'token', token: XOAuth2.Token): boolean;
+
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'idle', listener: () => void): this;
+    on(event: 'token', listener: (token: XOAuth2.Token) => void): this;
+
+    once(event: 'error', listener: (err: Error) => void): this;
+    once(event: 'idle', listener: () => void): this;
+    once(event: 'token', listener: (token: XOAuth2.Token) => void): this;
+
+    prependListener(event: 'error', listener: (err: Error) => void): this;
+    prependListener(event: 'idle', listener: () => void): this;
+    prependListener(event: 'end', listener: (token: XOAuth2.Token) => void): this;
+
+    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+    prependOnceListener(event: 'idle', listener: () => void): this;
+    prependOnceListener(event: 'end', listener: (token: XOAuth2.Token) => void): this;
+
+    listeners(event: 'error'): Array<(err: Error) => void>;
+    listeners(event: 'idle'): Array<() => void>;
+    listeners(event: 'end'): Array<(token: XOAuth2.Token) => void>;
+}
+
+export = Mail;

package/package/node_modules/@types/nodemailer/lib/mailer/mail-message.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+
+import { Readable } from 'stream';
+
+import Mail = require('.');
+import MimeNode = require('../mime-node');
+
+declare class MailMessage<T = any> {
+    mailer: Mail<T>;
+    data: Mail.Options;
+    message: MimeNode;
+
+    constructor(mailer: Mail<T>, data: Mail.Options);
+
+    resolveContent(data: object | any[], key: string | number, callback: (err: Error | null, value?: any) => any): Promise<any>;
+
+    resolveAll(callback: (err?: Error | null, data?: Mail.Options) => void): void;
+
+    normalize(callback: (err?: Error | null, data?: Mail.Options) => void): void;
+
+    setMailerHeader(): void;
+
+    setPriorityHeaders(): void;
+
+    setListHeaders(): void;
+}
+
+export = MailMessage;