@types/nodemailer 6.4.0 → 6.4.4

nodemailer/LICENSE

@@ -1,21 +1,21 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation. All rights reserved.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

nodemailer/README.md

@@ -8,9 +8,9 @@ This package contains type definitions for Nodemailer (https://github.com/nodema
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nodemailer.
 
 ### Additional Details
- * Last updated: Wed, 18 Dec 2019 16:21:54 GMT
+ * Last updated: Thu, 08 Jul 2021 18:51:33 GMT
  * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
  * Global values: none
 
 # Credits
-These definitions were written by Rogier Schouten (https://github.com/rogierschouten), Piotr Roszatycki (https://github.com/dex4er), and Daniel Chao (https://github.com/bioball).
+These definitions were written by [Rogier Schouten](https://github.com/rogierschouten), [Piotr Roszatycki](https://github.com/dex4er), and [Daniel Chao](https://github.com/bioball).

nodemailer/index.d.ts

@@ -19,17 +19,17 @@ import StreamTransport = require('./lib/stream-transport');
 
 export type SendMailOptions = Mail.Options;
 
-export type SentMessageInfo = any;
+export type Transporter<T = any> = Mail<T>;
 
-export type Transporter = Mail;
+export type SentMessageInfo = any;
 
-export interface Transport {
-    mailer?: Mail;
+export interface Transport<T = any> {
+    mailer?: Transporter<T> | undefined;
 
     name: string;
     version: string;
 
-    send(mail: MailMessage, callback: (err: Error | null, info: SentMessageInfo) => void): void;
+    send(mail: MailMessage<T>, callback: (err: Error | null, info: T) => void): void;
 
     verify?(callback: (err: Error | null, success: true) => void): void;
     verify?(): Promise<true>;
@@ -38,27 +38,45 @@ export interface Transport {
 }
 
 export interface TransportOptions {
-    component?: string;
+    component?: string | undefined;
 }
 
 export interface TestAccount {
     user: string;
     pass: string;
-    smtp: { host: string, port: number, secure: boolean };
-    imap: { host: string, port: number, secure: boolean };
-    pop3: { host: string, port: number, secure: boolean };
+    smtp: { host: string; port: number; secure: boolean };
+    imap: { host: string; port: number; secure: boolean };
+    pop3: { host: string; port: number; secure: boolean };
     web: string;
 }
 
-export function createTransport(transport?: SMTPTransport | SMTPTransport.Options | string, defaults?: SMTPTransport.Options): Mail;
-export function createTransport(transport: SMTPPool | SMTPPool.Options, defaults?: SMTPPool.Options): Mail;
-export function createTransport(transport: SendmailTransport | SendmailTransport.Options, defaults?: SendmailTransport.Options): Mail;
-export function createTransport(transport: StreamTransport | StreamTransport.Options, defaults?: StreamTransport.Options): Mail;
-export function createTransport(transport: JSONTransport | JSONTransport.Options, defaults?: JSONTransport.Options): Mail;
-export function createTransport(transport: SESTransport | SESTransport.Options, defaults?: SESTransport.Options): Mail;
-export function createTransport(transport: Transport | TransportOptions, defaults?: TransportOptions): Mail;
+export function createTransport(
+    transport?: SMTPTransport | SMTPTransport.Options | string,
+    defaults?: SMTPTransport.Options,
+): Transporter<SMTPTransport.SentMessageInfo>;
+export function createTransport(transport: SMTPPool | SMTPPool.Options, defaults?: SMTPPool.Options): Transporter<SMTPPool.SentMessageInfo>;
+export function createTransport(
+    transport: SendmailTransport | SendmailTransport.Options,
+    defaults?: SendmailTransport.Options,
+): Transporter<SendmailTransport.SentMessageInfo>;
+export function createTransport(
+    transport: StreamTransport | StreamTransport.Options,
+    defaults?: StreamTransport.Options,
+): Transporter<StreamTransport.SentMessageInfo>;
+export function createTransport(
+    transport: JSONTransport | JSONTransport.Options,
+    defaults?: JSONTransport.Options,
+): Transporter<JSONTransport.SentMessageInfo>;
+export function createTransport(
+    transport: SESTransport | SESTransport.Options,
+    defaults?: SESTransport.Options,
+): Transporter<SESTransport.SentMessageInfo>;
+export function createTransport<T>(transport: Transport<T> | TransportOptions, defaults?: TransportOptions): Transporter<T>;
 
-export function createTestAccount(apiUrl: string, callback: (err: Error | null, testAccount: TestAccount) => void): void;
+export function createTestAccount(
+    apiUrl: string,
+    callback: (err: Error | null, testAccount: TestAccount) => void,
+): void;
 export function createTestAccount(callback: (err: Error | null, testAccount: TestAccount) => void): void;
 export function createTestAccount(apiUrl?: string): Promise<TestAccount>;
 

nodemailer/lib/base64.d.ts

@@ -9,7 +9,7 @@ export function encode(buffer: Buffer | string): string;
 export function wrap(str: string, lineLength?: number): string;
 
 export interface EncoderOptions extends TransformOptions {
-    lineLength?: number | false;
+    lineLength?: number | false | undefined;
 }
 
 export class Encoder extends Transform {

nodemailer/lib/dkim/index.d.ts

@@ -5,15 +5,15 @@ 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;
+        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;
+        cacheTreshold?: number | undefined;
         /** optional algorithm for the body hash, defaults to ‘sha256’ */
-        hashAlgo?: string;
+        hashAlgo?: string | undefined;
         /** an optional colon separated list of header keys to sign (eg. message-id:date:from:to...') */
-        headerFieldNames?: string;
+        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;
+        skipFields?: string | undefined;
     }
 
     interface SingleKeyOptions extends OptionalOptions {

nodemailer/lib/fetch/cookies.d.ts

@@ -3,16 +3,16 @@ type s = number;
 declare namespace Cookies {
     interface Cookie {
         name: string;
-        value?: string;
-        expires?: Date;
-        path?: string;
-        domain?: string;
-        secure?: boolean;
-        httponly?: boolean;
+        value?: string | undefined;
+        expires?: Date | undefined;
+        path?: string | undefined;
+        domain?: string | undefined;
+        secure?: boolean | undefined;
+        httponly?: boolean | undefined;
     }
 
     interface Options {
-        sessionTimeout?: s;
+        sessionTimeout?: s | undefined;
     }
 }
 

nodemailer/lib/fetch/index.d.ts

@@ -17,19 +17,19 @@ declare namespace fetch {
     }
 
     interface Options {
-        fetchRes?: Writable;
-        cookies?: Cookies;
-        cookie?: string;
-        redirects?: number;
-        maxRedirects?: number;
-        method?: string;
-        headers?: { [key: string]: string };
-        userAgent?: string;
-        body?: Buffer | string | { [key: string]: string };
-        contentType?: string | false;
-        tls?: tls.TlsOptions;
-        timeout?: ms;
-        allowErrorResponse?: boolean;
+        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;
     }
 }
 

nodemailer/lib/json-transport.d.ts

@@ -15,7 +15,7 @@ declare namespace JSONTransport {
 
     interface Options extends MailOptions, TransportOptions {
         jsonTransport: true;
-        skipEncoding?: boolean;
+        skipEncoding?: boolean | undefined;
     }
 
     interface SentMessageInfo {
@@ -25,14 +25,18 @@ declare namespace JSONTransport {
         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 {
+declare class JSONTransport implements Transport<JSONTransport.SentMessageInfo> {
     options: JSONTransport.Options;
 
     logger: shared.Logger;
-    mailer: Mail;
+    mailer: Mail<JSONTransport.SentMessageInfo>;
 
     name: string;
     version: string;
@@ -40,7 +44,7 @@ declare class JSONTransport implements Transport {
     constructor(options: JSONTransport.Options);
 
     /** Compiles a mailcomposer message and forwards it to handler that sends it */
-    send(mail: MailMessage, callback: (err: Error | null, info: JSONTransport.SentMessageInfo) => void): void;
+    send(mail: MailMessage<JSONTransport.SentMessageInfo>, callback: (err: Error | null, info: JSONTransport.SentMessageInfo) => void): void;
 }
 
 export = JSONTransport;

nodemailer/lib/mailer/index.d.ts

@@ -5,7 +5,7 @@ import { Socket } from 'net';
 import { Readable } from 'stream';
 import { Url } from 'url';
 
-import { SentMessageInfo, Transport, TransportOptions } from '../..';
+import { Transport, TransportOptions } from '../..';
 import * as shared from '../shared';
 
 import DKIM = require('../dkim');
@@ -32,50 +32,50 @@ declare namespace Mail {
 
     interface AttachmentLike {
         /** String, Buffer or a Stream contents for the attachmentent */
-        content?: string | Buffer | Readable;
+        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;
+        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;
+        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;
+        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;
+        encoding?: string | undefined;
         /** optional content type for the attachment, if not set will be derived from the filename property */
-        contentType?: string;
+        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;
+        contentTransferEncoding?: '7bit' | 'base64' | 'quoted-printable' | false | undefined;
         /** optional content disposition type for the attachment, defaults to ‘attachment’ */
-        contentDisposition?: 'attachment' | 'inline';
+        contentDisposition?: 'attachment' | 'inline' | undefined;
         /** is an object of additional headers */
-        headers?: 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;
+        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;
+        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;
+        encoding?: string | undefined;
         /** optional content type for the attachment, if not set will be derived from the filename property */
-        contentType?: string;
+        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;
+        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;
+        method?: string | undefined;
         /** optional filename, defaults to ‘invite.ics’ */
-        filename?: string | false;
+        filename?: string | false | undefined;
         /** is an alternative for content to load the calendar data from an URL */
-        href?: string;
+        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;
+        encoding?: string | undefined;
     }
 
     interface Connection {
@@ -84,90 +84,90 @@ declare namespace Mail {
 
     interface Envelope {
         /** the first address gets used as MAIL FROM address in SMTP */
-        from?: string;
+        from?: string | undefined;
         /** addresses from this value get added to RCPT TO list */
-        to?: string;
+        to?: string | undefined;
         /** addresses from this value get added to RCPT TO list */
-        cc?: string;
+        cc?: string | undefined;
         /** addresses from this value get added to RCPT TO list */
-        bcc?: string;
+        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;
+        from?: string | Address | undefined;
         /** An e-mail address that will appear on the Sender: field */
-        sender?: string | Address;
+        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>;
+        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>;
+        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>;
+        bcc?: string | Address | Array<string | Address> | undefined;
         /** An e-mail address that will appear on the Reply-To: field */
-        replyTo?: string | Address;
+        replyTo?: string | Address | undefined;
         /** The message-id this message is replying */
-        inReplyTo?: string | Address;
+        inReplyTo?: string | Address | undefined;
         /** Message-id list (an array or space separated string) */
-        references?: string | string[];
+        references?: string | string[] | undefined;
         /** The subject of the e-mail */
-        subject?: string;
+        subject?: string | undefined;
         /** The plaintext version of the message */
-        text?: string | Buffer | Readable | AttachmentLike;
+        text?: string | Buffer | Readable | AttachmentLike | undefined;
         /** The HTML version of the message */
-        html?: string | Buffer | Readable | AttachmentLike;
+        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;
+        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;
+        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;
+        icalEvent?: string | Buffer | Readable | IcalAttachment | undefined;
         /** An object or array of additional header fields */
-        headers?: Headers;
+        headers?: Headers | undefined;
         /** An object where key names are converted into list headers. List key help becomes List-Help header etc. */
-        list?: ListHeaders;
+        list?: ListHeaders | undefined;
         /** An array of attachment objects */
-        attachments?: Attachment[];
+        attachments?: Attachment[] | undefined;
         /** An array of alternative text contents (in addition to text and html parts) */
-        alternatives?: Attachment[];
+        alternatives?: Attachment[] | undefined;
         /** optional SMTP envelope, if auto generated envelope is not suitable */
-        envelope?: Envelope | MimeNode.Envelope;
+        envelope?: Envelope | MimeNode.Envelope | undefined;
         /** optional Message-Id value, random value will be generated if not set */
-        messageId?: string;
+        messageId?: string | undefined;
         /** optional Date value, current UTC string will be used if not set */
-        date?: Date | string;
+        date?: Date | string | undefined;
         /** optional transfer encoding for the textual parts */
-        encoding?: string;
+        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;
+        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;
+        textEncoding?: TextEncoding | undefined;
         /** if set to true then fails with an error when a node tries to load content from URL */
-        disableUrlAccess?: boolean;
+        disableUrlAccess?: boolean | undefined;
         /** if set to true then fails with an error when a node tries to load content from a file */
-        disableFileAccess?: boolean;
+        disableFileAccess?: boolean | undefined;
         /** is an object with DKIM options */
-        dkim?: DKIM.Options;
+        dkim?: DKIM.Options | undefined;
         /** method to normalize header keys for custom caseing */
         normalizeHeaderKey?(key: string): string;
-        priority?: "high"|"normal"|"low";
+        priority?: "high"|"normal"|"low" | undefined;
     }
 
-    type PluginFunction = (mail: MailMessage, callback: (err?: Error | null) => void) => void;
+    type PluginFunction<T = any> = (mail: MailMessage<T>, callback: (err?: Error | null) => void) => void;
 }
 
 /** Creates an object for exposing the Mail API */
-declare class Mail extends EventEmitter {
+declare class Mail<T = any> extends EventEmitter {
     options: Mail.Options;
     meta: Map<string, any>;
     dkim: DKIM;
-    transporter: Transport;
+    transporter: Transport<T>;
     logger: shared.Logger;
 
     /** Usage: typeof transporter.MailMessage */
-    MailMessage: MailMessage;
+    MailMessage: MailMessage<T>;
 
-    constructor(transporter: Transport, options?: TransportOptions, defaults?: TransportOptions);
+    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;
@@ -179,11 +179,11 @@ declare class Mail extends EventEmitter {
     verify(callback: (err: Error | null, success: true) => void): void;
     verify(): Promise<true>;
 
-    use(step: string, plugin: Mail.PluginFunction): this;
+    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: SentMessageInfo) => void): void;
-    sendMail(mailOptions: Mail.Options): Promise<SentMessageInfo>;
+    sendMail(mailOptions: Mail.Options, callback: (err: Error | null, info: T) => void): void;
+    sendMail(mailOptions: Mail.Options): Promise<T>;
 
     getVersionString(): string;
 

nodemailer/lib/mailer/mail-message.d.ts

@@ -5,12 +5,12 @@ import { Readable } from 'stream';
 import Mail = require('.');
 import MimeNode = require('../mime-node');
 
-declare class MailMessage {
-    mailer: Mail;
+declare class MailMessage<T = any> {
+    mailer: Mail<T>;
     data: Mail.Options;
     message: MimeNode;
 
-    constructor(mailer: Mail, data: Mail.Options);
+    constructor(mailer: Mail<T>, data: Mail.Options);
 
     resolveContent(data: object | any[], key: string | number, callback: (err: Error | null, value?: any) => any): Promise<any>;
 

nodemailer/lib/mime-funcs/index.d.ts

@@ -1,6 +1,6 @@
 export interface HeaderValue {
     value: string;
-    params?: { [key: string]: string };
+    params?: { [key: string]: string } | undefined;
 }
 
 export interface ParsedHeaderValue extends HeaderValue {

nodemailer/lib/mime-node/index.d.ts

@@ -7,12 +7,12 @@ import SMTPConnection = require('../smtp-connection');
 
 declare namespace MimeNode {
     interface Addresses {
-        from?: string[];
-        sender?: string[];
-        'reply-to'?: string[];
-        to?: string[];
-        cc?: string[];
-        bcc?: string[];
+        from?: string[] | undefined;
+        sender?: string[] | undefined;
+        'reply-to'?: string[] | undefined;
+        to?: string[] | undefined;
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
     }
 
     interface Envelope {
@@ -24,17 +24,17 @@ declare namespace MimeNode {
 
     interface Options {
         /** root node for this tree */
-        rootNode?: MimeNode;
+        rootNode?: MimeNode | undefined;
         /** immediate parent for this node */
-        parentNode?: MimeNode;
+        parentNode?: MimeNode | undefined;
         /** filename for an attachment node */
-        filename?: string;
+        filename?: string | undefined;
         /** shared part of the unique multipart boundary */
-        baseBoundary?: string;
+        baseBoundary?: string | undefined;
         /** If true, do not exclude Bcc from the generated headers */
-        keepBcc?: boolean;
+        keepBcc?: boolean | undefined;
         /** either 'Q' (the default) or 'B' */
-        textEncoding?: 'B' | 'Q';
+        textEncoding?: 'B' | 'Q' | undefined;
         /** method to normalize header keys for custom caseing */
         normalizeHeaderKey?(key: string): string;
     }

nodemailer/lib/qp.d.ts

@@ -9,7 +9,7 @@ export function encode(buffer: Buffer | string): string;
 export function wrap(str: string, lineLength?: number): string;
 
 export interface EncoderOptions extends TransformOptions {
-    lineLength?: number | false;
+    lineLength?: number | false | undefined;
 }
 
 /** Creates a transform stream for encoding data to Quoted-Printable encoding */

nodemailer/lib/sendmail-transport/index.d.ts

@@ -14,24 +14,27 @@ declare namespace SendmailTransport {
     interface Options extends MailOptions, TransportOptions {
         sendmail: true;
         /** path to the sendmail command (defaults to ‘sendmail’) */
-        path?: string;
+        path?: string | undefined;
         /** either ‘windows’ or ‘unix’ (default). Forces all newlines in the output to either use Windows syntax <CR><LF> or Unix syntax <LF> */
-        newline?: string;
+        newline?: string | undefined;
         /** an optional array of command line options to pass to the sendmail command (ie. ["-f", "foo@blurdybloop.com"]). This overrides all default arguments except for ’-i’ and recipient list so you need to make sure you have all required arguments set (ie. the ‘-f’ flag). */
-        args?: string[];
+        args?: string[] | undefined;
     }
 
     interface SentMessageInfo {
         envelope: MimeNode.Envelope;
         messageId: string;
         response: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
     }
 }
 
-declare class SendmailTransport implements Transport {
+declare class SendmailTransport implements Transport<SendmailTransport.SentMessageInfo> {
     options: SendmailTransport.Options;
     logger: shared.Logger;
-    mailer: Mail;
+    mailer: Mail<SendmailTransport.SentMessageInfo>;
     name: string;
     version: string;
     path: string;
@@ -41,7 +44,10 @@ declare class SendmailTransport implements Transport {
     constructor(options: SendmailTransport.Options);
 
     /** Compiles a mailcomposer message and forwards it to handler that sends it */
-    send(mail: MailMessage, callback: (err: Error | null, info: SendmailTransport.SentMessageInfo) => void): void;
+    send(
+        mail: MailMessage<SendmailTransport.SentMessageInfo>,
+        callback: (err: Error | null, info: SendmailTransport.SentMessageInfo) => void,
+    ): void;
 }
 
 export = SendmailTransport;

nodemailer/lib/ses-transport.d.ts

@@ -13,18 +13,18 @@ import MimeNode = require('./mime-node');
 declare namespace SESTransport {
     interface MailOptions extends Mail.Options {
         /** list of keys that SendRawEmail method can take */
-        ses?: MailSesOptions;
+        ses?: MailSesOptions | undefined;
     }
 
     interface MailSesOptions {
         /**
          * The identity's email address. If you do not provide a value for this parameter, you must specify a "From" address in the raw text of the message. (You can also specify both.)  Amazon SES does not support the SMTPUTF8 extension, as described inRFC6531. For this reason, the local part of a source email address (the part of the email address that precedes the @ sign) may only contain 7-bit ASCII characters. If the domain part of an address (the part after the @ sign) contains non-ASCII characters, they must be encoded using Punycode, as described in RFC3492. The sender name (also known as the friendly name) may contain non-ASCII characters. These characters must be encoded using MIME encoded-word syntax, as described in RFC 2047. MIME encoded-word syntax uses the following form: =?charset?encoding?encoded-text?=.  If you specify the Source parameter and have feedback forwarding enabled, then bounces and complaints will be sent to this email address. This takes precedence over any Return-Path header that you might include in the raw text of the message.
          */
-        Source?: string;
+        Source?: string | undefined;
         /**
          * A list of destinations for the message, consisting of To:, CC:, and BCC: addresses.
          */
-        Destinations?: string[];
+        Destinations?: string[] | undefined;
         /**
          * The raw email message itself. The message has to meet the following criteria:   The message has to contain a header and a body, separated by a blank line.   All of the required header fields must be present in the message.   Each part of a multipart MIME message must be formatted properly.   Attachments must be of a content type that Amazon SES supports. For a list on unsupported content types, see Unsupported Attachment Types in the Amazon SES Developer Guide.   The entire message must be base64-encoded.   If any of the MIME parts in your message contain content that is outside of the 7-bit ASCII character range, we highly recommend that you encode that content. For more information, see Sending Raw Email in the Amazon SES Developer Guide.   Per RFC 5321, the maximum length of each line of text, including the <CRLF>, must not exceed 1,000 characters.
          */
@@ -33,19 +33,19 @@ declare namespace SESTransport {
              * The raw data of the message. This data needs to base64-encoded if you are accessing Amazon SES directly through the HTTPS interface. If you are accessing Amazon SES using an AWS SDK, the SDK takes care of the base 64-encoding for you. In all cases, the client must ensure that the message format complies with Internet email standards regarding email header fields, MIME types, and MIME encoding. The To:, CC:, and BCC: headers in the raw message can contain a group list. If you are using SendRawEmail with sending authorization, you can include X-headers in the raw message to specify the "Source," "From," and "Return-Path" addresses. For more information, see the documentation for SendRawEmail.   Do not include these X-headers in the DKIM signature, because they are removed by Amazon SES before sending the email.  For more information, go to the Amazon SES Developer Guide.
              */
             Data: Buffer|Uint8Array|{}|string;
-        };
+        } | undefined;
         /**
          * This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to specify a particular "From" address in the header of the raw email. Instead of using this parameter, you can use the X-header X-SES-FROM-ARN in the raw message of the email. If you use both the FromArn parameter and the corresponding X-header, Amazon SES uses the value of the FromArn parameter.  For information about when to use this parameter, see the description of SendRawEmail in this guide, or see the Amazon SES Developer Guide.
          */
-        FromArn?: string;
+        FromArn?: string | undefined;
         /**
          * This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to send for the email address specified in the Source parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to send from user@example.com, then you would specify the SourceArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the Source to be user@example.com. Instead of using this parameter, you can use the X-header X-SES-SOURCE-ARN in the raw message of the email. If you use both the SourceArn parameter and the corresponding X-header, Amazon SES uses the value of the SourceArn parameter.  For information about when to use this parameter, see the description of SendRawEmail in this guide, or see the Amazon SES Developer Guide.
          */
-        SourceArn?: string;
+        SourceArn?: string | undefined;
         /**
          * This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to use the email address specified in the ReturnPath parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to use feedback@example.com, then you would specify the ReturnPathArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the ReturnPath to be feedback@example.com. Instead of using this parameter, you can use the X-header X-SES-RETURN-PATH-ARN in the raw message of the email. If you use both the ReturnPathArn parameter and the corresponding X-header, Amazon SES uses the value of the ReturnPathArn parameter.  For information about when to use this parameter, see the description of SendRawEmail in this guide, or see the Amazon SES Developer Guide.
          */
-        ReturnPathArn?: string;
+        ReturnPathArn?: string | undefined;
         /**
          * A list of tags, in the form of name/value pairs, to apply to an email that you send using SendRawEmail. Tags correspond to characteristics of the email that you define, so that you can publish email sending events.
          */
@@ -58,20 +58,20 @@ declare namespace SESTransport {
              * The value of the tag. The value must:   This value can only contain ASCII letters (a-z, A-Z), numbers (0-9), underscores (_), or dashes (-).   Contain less than 256 characters.
              */
             Value: string;
-        }>;
+        }> | undefined;
         /**
          * The name of the configuration set to use when you send an email using SendRawEmail.
          */
-        ConfigurationSetName?: string;
+        ConfigurationSetName?: string | undefined;
     }
 
     interface Options extends MailOptions, TransportOptions {
         /** is an option that expects an instantiated aws.SES object */
         SES: any; // aws-sdk.SES object
         /** How many messages per second is allowed to be delivered to SES */
-        maxConnections?: number;
+        maxConnections?: number | undefined;
         /** How many parallel connections to allow towards SES */
-        sendingRate?: number;
+        sendingRate?: number | undefined;
     }
 
     interface SentMessageInfo {
@@ -80,14 +80,17 @@ declare namespace SESTransport {
         /** the Message-ID header value. This value is derived from the response of SES API, so it differs from the Message-ID values used in logging. */
         messageId: string;
         response: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
     }
 }
 
-declare class SESTransport extends EventEmitter implements Transport {
+declare class SESTransport extends EventEmitter implements Transport<SESTransport.SentMessageInfo> {
     options: SESTransport.Options;
 
     logger: shared.Logger;
-    mailer: Mail;
+    mailer: Mail<SESTransport.SentMessageInfo>;
 
     name: string;
     version: string;
@@ -100,13 +103,13 @@ declare class SESTransport extends EventEmitter implements Transport {
     sendingRateTTL: number | null;
     rateInterval: number;
     rateMessages: Array<{ ts: number, pending: boolean }>;
-    pending: Array<{ mail: Mail; callback(err: Error | null, info: SESTransport.SentMessageInfo): void; }>;
+    pending: Array<{ mail: Mail<SESTransport.SentMessageInfo>; callback(err: Error | null, info: SESTransport.SentMessageInfo): void; }>;
     idling: boolean;
 
     constructor(options: SESTransport.Options);
 
     /** Schedules a sending of a message */
-    send(mail: MailMessage, callback: (err: Error | null, info: SESTransport.SentMessageInfo) => void): void;
+    send(mail: MailMessage<SESTransport.SentMessageInfo>, callback: (err: Error | null, info: SESTransport.SentMessageInfo) => void): void;
 
     /** Returns true if there are free slots in the queue */
     isIdle(): boolean;

nodemailer/lib/shared.d.ts

@@ -17,14 +17,14 @@ export interface Logger {
 }
 
 export interface ResolveHostnameOptions {
-  host?: string;
-  servername?: string | false;
+  host?: string | undefined;
+  servername?: string | false | undefined;
 }
 
 export interface ResolveHostnameValue {
   host: string;
   servername: string | false;
-  _cached?: true;
+  _cached?: true | undefined;
 }
 
 export function resolveHostname(options: ResolveHostnameOptions | null | undefined, callback: (err: Error | null, value: ResolveHostnameValue) => void): void;

nodemailer/lib/smtp-connection/index.d.ts

@@ -30,12 +30,12 @@ declare namespace SMTPConnection {
 
     interface AuthenticationTypeLogin extends Credentials {
         /** indicates the authetication type, defaults to ‘login’, other option is ‘oauth2’ or ‘custom’ */
-        type?: 'login' | 'Login' | 'LOGIN';
+        type?: 'login' | 'Login' | 'LOGIN' | undefined;
     }
 
     interface AuthenticationTypeOAuth2 extends OAuth2 {
         /** indicates the authetication type, defaults to ‘login’, other option is ‘oauth2’ or ‘custom’ */
-        type?: 'oauth2' | 'OAuth2' | 'OAUTH2';
+        type?: 'oauth2' | 'OAuth2' | 'OAUTH2' | undefined;
     }
 
     type AuthenticationType = AuthenticationTypeCustom | AuthenticationTypeLogin | AuthenticationTypeOAuth2;
@@ -55,7 +55,7 @@ declare namespace SMTPConnection {
         response: string;
         status: number;
         text: string;
-        code?: number;
+        code?: number | undefined;
     }
 
     interface CustomAuthenticationContext {
@@ -78,13 +78,13 @@ declare namespace SMTPConnection {
 
     interface DSNOptions {
         /** return either the full message ‘FULL’ or only headers ‘HDRS’ */
-        ret?: 'Full' | 'HDRS';
+        ret?: 'Full' | 'HDRS' | undefined;
         /** sender’s ‘envelope identifier’ for tracking */
-        envid?: string;
+        envid?: string | undefined;
         /** when to send a DSN. Multiple options are OK - array or comma delimited. NEVER must appear by itself. */
-        notify?: DSNOption | DSNOption[];
+        notify?: DSNOption | DSNOption[] | undefined;
         /** original recipient */
-        orcpt?: string;
+        orcpt?: string | undefined;
     }
 
     interface Envelope {
@@ -93,22 +93,22 @@ declare namespace SMTPConnection {
         /** the recipient address or an array of addresses */
         to: string | string[];
         /** an optional value of the predicted size of the message in bytes. This value is used if the server supports the SIZE extension (RFC1870) */
-        size?: number;
+        size?: number | undefined;
         /** if true then inform the server that this message might contain bytes outside 7bit ascii range */
-        use8BitMime?: boolean;
+        use8BitMime?: boolean | undefined;
         /** the dsn options */
-        dsn?: DSNOptions;
+        dsn?: DSNOptions | undefined;
     }
 
     interface SMTPError extends NodeJS.ErrnoException {
         /** string code identifying the error, for example ‘EAUTH’ is returned when authentication */
-        code?: string;
+        code?: string | undefined;
         /** the last response received from the server (if the error is caused by an error response from the server) */
-        response?: string;
+        response?: string | undefined;
         /** the numeric response code of the response string (if available) */
-        responseCode?: number;
+        responseCode?: number | undefined;
         /** command which provoked an error */
-        command?: string;
+        command?: string | undefined;
     }
 
     interface SentMessageInfo {
@@ -117,7 +117,7 @@ declare namespace SMTPConnection {
         /** an array of rejected recipient addresses. This array includes both the addresses that were rejected before sending the message and addresses rejected after sending it if using LMTP */
         rejected: string[];
         /** if some recipients were rejected then this property holds an array of error objects for the rejected recipients */
-        rejectedErrors?: SMTPError[];
+        rejectedErrors?: SMTPError[] | undefined;
         /** the last response received from the server */
         response: string;
         /** how long was envelope prepared */
@@ -130,44 +130,44 @@ declare namespace SMTPConnection {
 
     interface Options {
         /** the hostname or IP address to connect to (defaults to ‘localhost’) */
-        host?: string;
+        host?: string | undefined;
         /** the port to connect to (defaults to 25 or 465) */
-        port?: number;
+        port?: number | undefined;
         /** defines authentication data */
-        auth?: AuthenticationType;
+        auth?: AuthenticationType | undefined;
         /** defines if the connection should use SSL (if true) or not (if false) */
-        secure?: boolean;
+        secure?: boolean | undefined;
         /** turns off STARTTLS support if true */
-        ignoreTLS?: boolean;
+        ignoreTLS?: boolean | undefined;
         /** forces the client to use STARTTLS. Returns an error if upgrading the connection is not possible or fails. */
-        requireTLS?: boolean;
+        requireTLS?: boolean | undefined;
         /** tries to use STARTTLS and continues normally if it fails */
-        opportunisticTLS?: boolean;
+        opportunisticTLS?: boolean | undefined;
         /** optional hostname of the client, used for identifying to the server */
-        name?: string;
+        name?: string | undefined;
         /** the local interface to bind to for network connections */
-        localAddress?: string;
+        localAddress?: string | undefined;
         /** how many milliseconds to wait for the connection to establish */
-        connectionTimeout?: ms;
+        connectionTimeout?: ms | undefined;
         /** how many milliseconds to wait for the greeting after connection is established */
-        greetingTimeout?: ms;
+        greetingTimeout?: ms | undefined;
         /** how many milliseconds of inactivity to allow */
-        socketTimeout?: ms;
+        socketTimeout?: ms | undefined;
         /** optional bunyan compatible logger instance. If set to true then logs to console. If value is not set or is false then nothing is logged */
-        logger?: shared.Logger | boolean;
+        logger?: shared.Logger | boolean | undefined;
         /** if set to true, then logs SMTP traffic without message content */
-        transactionLog?: boolean;
+        transactionLog?: boolean | undefined;
         /** if set to true, then logs SMTP traffic and message content, otherwise logs only transaction events */
-        debug?: boolean;
+        debug?: boolean | undefined;
         /** defines preferred authentication method, e.g. ‘PLAIN’ */
-        authMethod?: string;
+        authMethod?: string | undefined;
         /** defines additional options to be passed to the socket constructor, e.g. {rejectUnauthorized: true} */
-        tls?: tls.ConnectionOptions;
+        tls?: tls.ConnectionOptions | undefined;
         /** initialized socket to use instead of creating a new one */
-        socket?: net.Socket;
+        socket?: net.Socket | undefined;
         /** connected socket to use instead of creating and connecting a new one. If secure option is true, then socket is upgraded from plaintext to ciphertext */
-        connection?: net.Socket;
-        customAuth?: CustomAuthenticationHandlers;
+        connection?: net.Socket | undefined;
+        customAuth?: CustomAuthenticationHandlers | undefined;
     }
 }
 

nodemailer/lib/smtp-pool/index.d.ts

@@ -12,24 +12,24 @@ import SMTPConnection = require('../smtp-connection');
 
 declare namespace SMTPPool {
     interface MailOptions extends Mail.Options {
-        auth?: SMTPConnection.AuthenticationType;
-        dsn?: SMTPConnection.DSNOptions;
+        auth?: SMTPConnection.AuthenticationType | undefined;
+        dsn?: SMTPConnection.DSNOptions | undefined;
     }
 
     interface Options extends MailOptions, TransportOptions, SMTPConnection.Options {
         /** set to true to use pooled connections (defaults to false) instead of creating a new connection for every email */
         pool: true;
-        service?: string;
+        service?: string | undefined;
         getSocket?(options: Options, callback: (err: Error | null, socketOptions: any) => void): void; // TODO http.ClientRequest?
-        url?: string;
+        url?: string | undefined;
         /** the count of maximum simultaneous connections to make against the SMTP server (defaults to 5) */
-        maxConnections?: number;
+        maxConnections?: number | undefined;
         /** limits the message count to be sent using a single connection (defaults to 100). After maxMessages is reached the connection is dropped and a new one is created for the following messages */
-        maxMessages?: number;
+        maxMessages?: number | undefined;
         /** defines the time measuring period in milliseconds (defaults to 1000, ie. to 1 second) for rate limiting */
-        rateDelta?: number;
+        rateDelta?: number | undefined;
         /** limits the message count to be sent in rateDelta time. Once rateLimit is reached, sending is paused until the end of the measuring period. This limit is shared between connections, so if one connection uses up the limit, then other connections are paused as well. If rateLimit is not set then sending rate is not limited */
-        rateLimit?: number;
+        rateLimit?: number | undefined;
     }
 
     interface SentMessageInfo extends SMTPConnection.SentMessageInfo {
@@ -43,10 +43,10 @@ declare namespace SMTPPool {
 /**
  * Creates a SMTP pool transport object for Nodemailer
  */
-declare class SMTPPool extends EventEmitter implements Transport {
+declare class SMTPPool extends EventEmitter implements Transport<SMTPPool.SentMessageInfo> {
     options: SMTPPool.Options;
 
-    mailer: Mail;
+    mailer: Mail<SMTPPool.SentMessageInfo>;
     logger: shared.Logger;
 
     name: string;
@@ -60,7 +60,7 @@ declare class SMTPPool extends EventEmitter implements Transport {
     getSocket(options: SMTPPool.Options, callback: (err: Error | null, socketOptions: any) => void): void;
 
     /** Sends an e-mail using the selected settings */
-    send(mail: MailMessage, callback: (err: Error | null, info: SMTPPool.SentMessageInfo) => void): void;
+    send(mail: MailMessage<SMTPPool.SentMessageInfo>, callback: (err: Error | null, info: SMTPPool.SentMessageInfo) => void): void;
 
     /** Closes all connections in the pool. If there is a message being sent, the connection is closed later */
     close(): void;

nodemailer/lib/smtp-transport.d.ts

@@ -35,14 +35,14 @@ declare namespace SMTPTransport {
     type AuthenticationType = AuthenticationTypeLogin | AuthenticationTypeOAuth2;
 
     interface MailOptions extends Mail.Options {
-        auth?: SMTPConnection.AuthenticationType;
-        dsn?: SMTPConnection.DSNOptions;
+        auth?: SMTPConnection.AuthenticationType | undefined;
+        dsn?: SMTPConnection.DSNOptions | undefined;
     }
 
     interface Options extends MailOptions, TransportOptions, SMTPConnection.Options {
-        service?: string;
+        service?: string | undefined;
         getSocket?(options: Options, callback: (err: Error | null, socketOptions: any) => void): void; // TODO http.ClientRequest?
-        url?: string;
+        url?: string | undefined;
     }
 
     interface SentMessageInfo {
@@ -50,13 +50,17 @@ declare namespace SMTPTransport {
         envelope: MimeNode.Envelope;
         /** most transports should return the final Message-Id value used with this property */
         messageId: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+        response: string;
     }
 }
 
-declare class SMTPTransport extends EventEmitter implements Transport {
+declare class SMTPTransport extends EventEmitter implements Transport<SMTPTransport.SentMessageInfo> {
     options: SMTPTransport.Options;
 
-    mailer: Mail;
+    mailer: Mail<SMTPTransport.SentMessageInfo>;
     logger: shared.Logger;
 
     name: string;
@@ -69,10 +73,15 @@ declare class SMTPTransport extends EventEmitter implements Transport {
     /** Placeholder function for creating proxy sockets. This method immediatelly returns without a socket */
     getSocket(options: SMTPTransport.Options, callback: (err: Error | null, socketOptions: object) => void): void;
 
-    getAuth(authOpts: SMTPConnection.AuthenticationTypeLogin | SMTPConnection.AuthenticationTypeOAuth2): SMTPTransport.AuthenticationType;
+    getAuth(
+        authOpts: SMTPConnection.AuthenticationTypeLogin | SMTPConnection.AuthenticationTypeOAuth2,
+    ): SMTPTransport.AuthenticationType;
 
     /** Sends an e-mail using the selected settings */
-    send(mail: MailMessage, callback: (err: Error | null, info: SMTPTransport.SentMessageInfo) => void): void;
+    send(
+        mail: MailMessage<SMTPTransport.SentMessageInfo>,
+        callback: (err: Error | null, info: SMTPTransport.SentMessageInfo) => void,
+    ): void;
 
     /** Verifies SMTP configuration */
     verify(callback: (err: Error | null, success: true) => void): void;

nodemailer/lib/stream-transport.d.ts

@@ -17,9 +17,9 @@ declare namespace StreamTransport {
     interface Options extends MailOptions, TransportOptions {
         streamTransport: true;
         /** if true, then returns the message as a Buffer object instead of a stream */
-        buffer?: boolean;
+        buffer?: boolean | undefined;
         /** either ‘windows’ or ‘unix’ (default). Forces all newlines in the output to either use Windows syntax <CR><LF> or Unix syntax <LF> */
-        newline?: string;
+        newline?: string | undefined;
     }
 
     interface SentMessageInfo {
@@ -29,14 +29,18 @@ declare namespace StreamTransport {
         messageId: string;
         /** either stream (default) of buffer depending on the options */
         message: Buffer | Readable;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+        response: string;
     }
 }
 
-declare class StreamTransport implements Transport {
+declare class StreamTransport implements Transport<StreamTransport.SentMessageInfo> {
     options: StreamTransport.Options;
 
     logger: shared.Logger;
-    mailer: Mail;
+    mailer: Mail<StreamTransport.SentMessageInfo>;
 
     name: string;
     version: string;
@@ -46,7 +50,7 @@ declare class StreamTransport implements Transport {
     constructor(options: StreamTransport.Options);
 
     /** Compiles a mailcomposer message and forwards it to handler that sends it */
-    send(mail: MailMessage, callback: (err: Error | null, info: StreamTransport.SentMessageInfo) => void): void;
+    send(mail: MailMessage<StreamTransport.SentMessageInfo>, callback: (err: Error | null, info: StreamTransport.SentMessageInfo) => void): void;
 }
 
 export = StreamTransport;

nodemailer/lib/xoauth2.d.ts

@@ -11,26 +11,26 @@ type s = number;
 declare namespace XOAuth2 {
     interface Options {
         /** User e-mail address */
-        user?: string;
+        user?: string | undefined;
         /** Client ID value */
-        clientId?: string;
+        clientId?: string | undefined;
         /** Client secret value */
-        clientSecret?: string;
+        clientSecret?: string | undefined;
         /** Refresh token for an user */
-        refreshToken?: string;
+        refreshToken?: string | undefined;
         /** Endpoint for token generation, defaults to 'https://accounts.google.com/o/oauth2/token' */
-        accessUrl?: string;
+        accessUrl?: string | undefined;
         /** An existing valid accessToken */
-        accessToken?: string;
+        accessToken?: string | undefined;
         /** Private key for JSW */
-        privateKey?: string | { key: string; passphrase: string; };
+        privateKey?: string | { key: string; passphrase: string; } | undefined;
         /** Optional Access Token expire time in ms */
-        expires?: ms;
+        expires?: ms | undefined;
         /** Optional TTL for Access Token in seconds */
-        timeout?: s;
+        timeout?: s | undefined;
         /** Function to run when a new access token is required */
         provisionCallback?(user: string, renew: boolean, callback: (err: Error | null, accessToken: string, expires: number) => void): void;
-        serviceClient?: string;
+        serviceClient?: string | undefined;
     }
 
     interface Token {
@@ -40,7 +40,7 @@ declare namespace XOAuth2 {
     }
 
     interface RequestParams {
-        customHeaders?: http.OutgoingHttpHeaders;
+        customHeaders?: http.OutgoingHttpHeaders | undefined;
     }
 }
 

nodemailer/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@types/nodemailer",
-    "version": "6.4.0",
+    "version": "6.4.4",
     "description": "TypeScript definitions for Nodemailer",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nodemailer",
     "license": "MIT",
     "contributors": [
         {
@@ -31,6 +32,6 @@
     "dependencies": {
         "@types/node": "*"
     },
-    "typesPublisherContentHash": "0039445f01109c0e68106090b3609cab060c769ad2516b099fdafdb8ca22d4a0",
-    "typeScriptVersion": "3.3"
+    "typesPublisherContentHash": "aabfa060f1f3a5e90fafe4b0747dd2dc57a19d35f7a2cf9942a0595d5bc067ee",
+    "typeScriptVersion": "3.6"
 }