@mavogel/awscdk-rootmail 0.1.4 → 0.1.6

package/node_modules/nodemailer/dist/esm/fetch/cookies.d.ts

@@ -3,19 +3,19 @@
  */
 export interface CookiesOptions {
     /** Lifetime in seconds for cookies that do not set their own expiration (default 1800) */
-    sessionTimeout?: number | string;
+    sessionTimeout?: number | string | undefined;
 }
 /**
  * A cookie as parsed from a 'Set-Cookie:' header and kept in the jar
  */
 export interface Cookie {
-    name?: string;
-    value?: string;
-    domain?: string;
-    path?: string;
-    expires?: Date;
-    secure?: boolean;
-    httponly?: boolean;
+    name?: string | undefined;
+    value?: string | undefined;
+    domain?: string | undefined;
+    path?: string | undefined;
+    expires?: Date | undefined;
+    secure?: boolean | undefined;
+    httponly?: boolean | undefined;
 }
 /**
  * Creates a biskviit cookie jar for managing cookie values in memory
@@ -85,10 +85,12 @@ export default class Cookies {
      */
     isExpired(cookie: Cookie): boolean;
     /**
-     * Returns normalized cookie path for an URL path argument
+     * Returns the default path for an URL path argument, the default-path of
+     * RFC 6265 section 5.1.4. A cookie that carries no Path attribute is scoped
+     * to the directory of the URL it was set from
      *
      * @param pathname
-     * @returns Normalized path
+     * @returns Default path
      */
     getPath(pathname?: string | null): string;
 }

package/node_modules/nodemailer/dist/esm/fetch/cookies.js

@@ -1,4 +1,5 @@
 // module to handle cookies
+import net from 'node:net';
 import * as urllib from '../shared/url.js';
 const SESSION_TIMEOUT = 1800; // 30 min
 /**
@@ -24,12 +25,19 @@ export default class Cookies {
         let domain;
         if (cookie.domain) {
             domain = cookie.domain.replace(/^\./, '');
-            // do not allow cross origin cookies
+            // do not allow cross origin cookies. There is no public suffix list here, so a
+            // multi-label suffix like 'co.uk' can not be told apart from a registrable domain
             if (
             // can't be valid if the requested domain is shorter than current hostname
             urlparts.hostname.length < domain.length ||
+                // a top level domain is not a valid scope, 'Domain=com' would otherwise be
+                // sent to every .com host. A trailing dot does not make 'com.' any better
+                domain.indexOf('.') < 0 ||
+                domain.endsWith('.') ||
+                // an IP address has no subdomains, so cookies set on it stay host-only
+                net.isIP(urlparts.hostname) ||
                 // prefix domains with dot to be sure that partial matches are not used
-                ('.' + urlparts.hostname).substr(-domain.length + 1) !== '.' + domain) {
+                !('.' + urlparts.hostname).endsWith('.' + domain)) {
                 cookie.domain = urlparts.hostname;
             }
         }
@@ -149,9 +157,13 @@ export default class Cookies {
                 ('.' + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)) {
             return false;
         }
-        // check if path matches
-        const path = this.getPath(urlparts.pathname);
-        if (path.substr(0, cookie.path.length) !== cookie.path) {
+        // check if the request path path-matches the cookie path (RFC 6265 section 5.1.4):
+        // identical paths match, otherwise the cookie path must be a directory prefix
+        const pathname = urlparts.pathname || '/';
+        const cookiePath = cookie.path;
+        const pathMatches = pathname === cookiePath ||
+            (pathname.startsWith(cookiePath) && (cookiePath.endsWith('/') || pathname.charAt(cookiePath.length) === '/'));
+        if (!pathMatches) {
             return false;
         }
         // check secure argument
@@ -208,22 +220,21 @@ export default class Cookies {
         return (cookie.expires && cookie.expires < new Date()) || !cookie.value;
     }
     /**
-     * Returns normalized cookie path for an URL path argument
+     * Returns the default path for an URL path argument, the default-path of
+     * RFC 6265 section 5.1.4. A cookie that carries no Path attribute is scoped
+     * to the directory of the URL it was set from
      *
      * @param pathname
-     * @returns Normalized path
+     * @returns Default path
      */
     getPath(pathname) {
         const pathParts = (pathname || '/').split('/');
         pathParts.pop(); // remove filename part
-        let path = pathParts.join('/').trim();
-        // ensure path prefix /
+        const path = pathParts.join('/').trim();
+        // a path that holds no more than one '/' is scoped to the root path, and so
+        // is one that does not start with '/' at all
         if (path.charAt(0) !== '/') {
-            path = '/' + path;
-        }
-        // ensure path suffix /
-        if (path.substr(-1) !== '/') {
-            path += '/';
+            return '/';
         }
         return path;
     }

package/node_modules/nodemailer/dist/esm/fetch/index.d.ts

@@ -6,43 +6,43 @@ import Cookies from './cookies.js';
  */
 export interface FetchOptions {
     /** HTTP method, defaults to GET, or to POST when a body is given */
-    method?: string;
+    method?: string | undefined;
     /** Request headers, keys are lowercased before use */
-    headers?: http.OutgoingHttpHeaders;
+    headers?: http.OutgoingHttpHeaders | undefined;
     /** Overrides the default User-Agent header */
-    userAgent?: string;
+    userAgent?: string | undefined;
     /** Cookie string(s) to seed the cookie jar with for this URL */
-    cookie?: string | string[] | false;
+    cookie?: string | string[] | false | undefined;
     /** Cookie jar shared across redirects, created when missing */
-    cookies?: Cookies;
+    cookies?: Cookies | undefined;
     /** Request body: a readable stream, a Buffer, a form object or a string */
     body?: Readable | Buffer | {
         [key: string]: any;
-    } | string | false;
+    } | string | false | undefined;
     /** Content-Type header for the body, false leaves it out for a stream body */
-    contentType?: string | false;
+    contentType?: string | false | undefined;
     /** TLS settings, only the keys listed in TLS_OPTION_KEYS are used */
     tls?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** Request timeout in milliseconds */
-    timeout?: number;
+    timeout?: number | undefined;
     /** Maximum number of redirects to follow (default 5) */
-    maxRedirects?: number;
+    maxRedirects?: number | undefined;
     /** Resolve responses with a status code of 300 or above instead of emitting an error */
-    allowErrorResponse?: boolean;
+    allowErrorResponse?: boolean | undefined;
     /** Redirects followed so far, set by nmfetch itself */
-    redirects?: number;
+    redirects?: number | undefined;
     /** Response stream shared across redirects, set by nmfetch itself */
-    fetchRes?: FetchResponse;
+    fetchRes?: FetchResponse | undefined;
 }
 /**
  * The stream nmfetch returns. The response body is piped into it, the status code and
  * headers of the final response are attached once they arrive
  */
 export interface FetchResponse extends PassThrough {
-    statusCode?: number;
-    headers?: http.IncomingHttpHeaders;
+    statusCode?: number | undefined;
+    headers?: http.IncomingHttpHeaders | undefined;
 }
 declare function nmfetch(url: string, options?: FetchOptions): FetchResponse;
 declare namespace nmfetch {

package/node_modules/nodemailer/dist/esm/json-transport/index.d.ts

@@ -7,9 +7,9 @@ import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOption
  */
 export interface JSONTransportOptions extends TransportOptions {
     /** Selects this transport in createTransport */
-    jsonTransport?: boolean;
+    jsonTransport?: boolean | undefined;
     /** If true, the message is returned as an object instead of a JSON string */
-    skipEncoding?: boolean;
+    skipEncoding?: boolean | undefined;
 }
 /**
  * The value the JSON transport hands to the send callback

package/node_modules/nodemailer/dist/esm/mail-composer/index.d.ts

@@ -8,45 +8,45 @@ import type { OutgoingHttpHeaders } from 'node:http';
  */
 export interface MailComposerAlternative {
     /** The content itself: a string, a Buffer, a readable stream or a content descriptor */
-    content?: MimeNodeContent;
+    content?: MimeNodeContent | undefined;
     /** File path, data URI or http(s) URL to read the content from */
-    path?: string | false;
+    path?: string | false | undefined;
     /** URL or data URI to fetch the content from */
-    href?: string | false;
+    href?: string | false | undefined;
     /** Request headers for a URL fetch */
-    httpHeaders?: OutgoingHttpHeaders;
+    httpHeaders?: OutgoingHttpHeaders | undefined;
     /** TLS settings for a URL fetch, see nmfetch */
     tls?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** Encoding of a string `content`, decoded into a Buffer unless it is utf8 or ascii */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Pregenerated MIME part, used as is instead of building the node */
-    raw?: MimeNodeContent;
+    raw?: MimeNodeContent | undefined;
     /** Content type, detected from the filename, path or URL when not set */
-    contentType?: string;
+    contentType?: string | undefined;
     /** Content-Transfer-Encoding for the node, false leaves the choice to the node */
-    contentTransferEncoding?: string | false;
+    contentTransferEncoding?: string | false | undefined;
     /** Filename for the node, false suppresses the generated one */
-    filename?: string | false;
+    filename?: string | false | undefined;
     /** Additional headers for the node */
-    headers?: MimeNodeHeaders;
+    headers?: MimeNodeHeaders | undefined;
 }
 /**
  * An attachment, the shape of the attachments entries
  */
 export interface MailComposerAttachment extends MailComposerAlternative {
     /** Content-Disposition for the node, 'attachment' by default and 'inline' for a message node or an image with a cid */
-    contentDisposition?: string;
+    contentDisposition?: string | undefined;
     /** Content-Id for an embedded image, moves the attachment into the multipart/related node beside the html */
-    cid?: string;
+    cid?: string | undefined;
 }
 /**
  * The icalEvent value as an object
  */
 export interface MailComposerIcalEvent extends MailComposerAlternative {
     /** iCalendar method, PUBLISH by default */
-    method?: string;
+    method?: string | undefined;
 }
 /**
  * The attachments as sorted by getAttachments
@@ -62,7 +62,7 @@ export interface MailComposerAttachments {
  */
 export type MailComposerListHeaderEntry = string | {
     url: string;
-    comment?: string;
+    comment?: string | undefined;
 };
 /**
  * The list value: List-* headers keyed by the part after "List-" (help, unsubscribe,
@@ -79,75 +79,68 @@ export interface MailComposerListHeaders {
  * by MailComposer itself, these are marked as such
  */
 export interface MailComposerOptions {
-    from?: MimeNodeAddressInput;
-    sender?: MimeNodeAddressInput;
-    to?: MimeNodeAddressInput;
-    cc?: MimeNodeAddressInput;
-    bcc?: MimeNodeAddressInput;
-    replyTo?: MimeNodeAddressInput;
-    inReplyTo?: string;
-    references?: string | string[];
-    subject?: string;
+    from?: MimeNodeAddressInput | undefined;
+    sender?: MimeNodeAddressInput | undefined;
+    to?: MimeNodeAddressInput | undefined;
+    cc?: MimeNodeAddressInput | undefined;
+    bcc?: MimeNodeAddressInput | undefined;
+    replyTo?: MimeNodeAddressInput | undefined;
+    inReplyTo?: string | undefined;
+    references?: string | string[] | undefined;
+    subject?: string | undefined;
     /** Message-ID header value, generated when missing */
-    messageId?: string;
+    messageId?: string | undefined;
     /** Date header value, the current time when missing */
-    date?: Date | string;
+    date?: Date | string | undefined;
     /** Plaintext version of the message */
-    text?: string | Buffer | Readable | MailComposerAlternative;
+    text?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** HTML version of the message */
-    html?: string | Buffer | Readable | MailComposerAlternative;
+    html?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** Apple Watch specific HTML version of the message */
-    watchHtml?: string | Buffer | Readable | MailComposerAlternative;
+    watchHtml?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** AMP4EMAIL version of the message */
-    amp?: string | Buffer | Readable | MailComposerAlternative;
+    amp?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** iCalendar event, included both as a text/calendar alternative and as an application/ics attachment */
-    icalEvent?: string | Buffer | Readable | MailComposerIcalEvent;
-    attachments?: MailComposerAttachment[];
+    icalEvent?: string | Buffer | Readable | MailComposerIcalEvent | undefined;
+    attachments?: MailComposerAttachment[] | undefined;
     /** Further alternatives for the multipart/alternative node, after text, watchHtml, amp, html and the calendar event */
-    alternatives?: MailComposerAlternative[];
+    alternatives?: MailComposerAlternative[] | undefined;
     /** Custom headers for the root node, the standard headers above override them */
-    headers?: MimeNodeHeaders;
+    headers?: MimeNodeHeaders | undefined;
     /** List-* headers, read by the mailer */
-    list?: MailComposerListHeaders;
+    list?: MailComposerListHeaders | undefined;
     /** SMTP envelope to use instead of the one generated from the headers */
-    envelope?: MimeNodeEnvelopeInput;
+    envelope?: MimeNodeEnvelopeInput | undefined;
     /** Content-Transfer-Encoding to force for the text/* nodes that do not set their own */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Header string encoding, 'Q' (the default) or 'B', 'quoted-printable' and 'base64' are accepted as well */
-    textEncoding?: string;
+    textEncoding?: string | undefined;
     /** Pregenerated rfc822 message, used as is instead of building one */
-    raw?: MimeNodeContent;
+    raw?: MimeNodeContent | undefined;
     /** Reject content that points to a URL */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
     /** Reject content that points to a file path */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Convert data: images in the html into embedded attachments, read by the mailer */
-    attachDataUrls?: boolean;
+    attachDataUrls?: boolean | undefined;
     /** Prefix for the generated multipart boundaries */
-    boundaryPrefix?: string;
+    boundaryPrefix?: string | undefined;
     /** Shared part of the unique multipart boundary */
-    baseBoundary?: string;
+    baseBoundary?: string | undefined;
     /** 'win' for CRLF and 'linux' for LF line breaks in the generated message, kept as is when not set */
-    newline?: string;
+    newline?: string | undefined;
     /** Keep the Bcc header in the generated message, listed for completeness, the transports set it on the message directly */
-    keepBcc?: boolean;
+    keepBcc?: boolean | undefined;
     /** Method to normalize header keys for custom caseing */
-    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'];
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** 'high', 'normal' or 'low', sets the priority headers, read by the mailer */
-    priority?: string;
+    priority?: string | undefined;
     /** X-Mailer header value, false leaves the header out, read by the mailer */
-    xMailer?: string | false;
+    xMailer?: string | false | undefined;
 }
 declare class MailComposer {
     mail: MailComposerOptions;
     message: MimeNode | false;
-    _alternatives: MailComposerAlternative[];
-    _htmlNode: MailComposerAlternative | undefined;
-    _attachments: MailComposerAttachments;
-    _useRelated: boolean;
-    _useAlternative: boolean;
-    _useMixed: boolean | number;
-    _icalEvent: MailComposerIcalEvent | undefined;
     constructor(mail?: MailComposerOptions);
     /**
      * Builds MimeNode instance
@@ -160,60 +153,12 @@ declare class MailComposer {
      * @returns An object of arrays (`related` and `attached`)
      */
     getAttachments(findRelated?: boolean): MailComposerAttachments;
-    /**
-     * Returns the icalEvent value with `path`/`href`/data uri input normalized into
-     * a `content` entry, the same way as for regular attachments. The same event is
-     * included twice (as a text/calendar alternative and as an application/ics
-     * attachment), so the shared content object is marked to be resolved just once
-     * and the buffered result is reused by the second node.
-     *
-     * @returns Normalized icalEvent data
-     */
-    _getIcalEvent(): MailComposerIcalEvent;
     /**
      * List alternatives. Resulting objects can be used as input for MimeNode nodes
      *
      * @returns An array of alternative elements. Includes the `text` and `html` values as well
      */
     getAlternatives(): MailComposerAlternative[];
-    /**
-     * Builds multipart/mixed node. It should always contain different type of elements on the same level
-     * eg. text + attachments
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createMixed(parentNode?: MimeNode): MimeNode;
-    /**
-     * Builds multipart/alternative node. It should always contain same type of elements on the same level
-     * eg. text + html view of the same data
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createAlternative(parentNode?: MimeNode): MimeNode;
-    /**
-     * Builds multipart/related node. It should always contain html node with related attachments
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createRelated(parentNode?: MimeNode): MimeNode;
-    /**
-     * Creates a regular node with contents
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @param element Node data
-     * @returns MimeNode node element
-     */
-    _createContentNode(parentNode: MimeNode | false, element?: MailComposerAttachment): MimeNode;
-    /**
-     * Parses data uri and converts it to a Buffer
-     *
-     * @param element Content element
-     * @return Parsed element
-     */
-    _processDataUrl<T extends MailComposerAlternative>(element: T): T;
 }
 /**
  * Type alias in the layout of the other modules (@types/nodemailer had no namespace for MailComposer)

package/node_modules/nodemailer/dist/esm/mail-composer/index.js

@@ -113,8 +113,10 @@ class MailComposer {
                 data.filename = attachment.filename;
             }
             else if (!isMessageNode && attachment.filename !== false) {
+                // a backslash separates as well, so a Windows path does not put the sender's directories in the headers
                 data.filename =
-                    (attachment.path || attachment.href || '').split('/').pop().split('?').shift() || 'attachment-' + (i + 1);
+                    (attachment.path || attachment.href || '').split(/[/\\]/).pop().split('?').shift() ||
+                        'attachment-' + (i + 1);
                 if (data.filename.indexOf('.') < 0) {
                     data.filename += '.' + mimeFuncs.detectExtension(data.contentType);
                 }
@@ -181,6 +183,7 @@ class MailComposer {
      * and the buffered result is reused by the second node.
      *
      * @returns Normalized icalEvent data
+     * @internal
      */
     _getIcalEvent() {
         if (!this._icalEvent) {
@@ -214,7 +217,8 @@ class MailComposer {
                 else if (icalEvent.href) {
                     icalEvent.content = {
                         href: icalEvent.href,
-                        httpHeaders: icalEvent.httpHeaders
+                        httpHeaders: icalEvent.httpHeaders,
+                        tls: icalEvent.tls
                     };
                     icalEvent.href = undefined;
                 }
@@ -323,7 +327,9 @@ class MailComposer {
             }
             else if (alternative.href) {
                 data.content = {
-                    href: alternative.href
+                    href: alternative.href,
+                    httpHeaders: alternative.httpHeaders,
+                    tls: alternative.tls
                 };
             }
             else {
@@ -345,6 +351,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createMixed(parentNode) {
         const node = parentNode
@@ -386,6 +393,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createAlternative(parentNode) {
         const node = parentNode
@@ -419,6 +427,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createRelated(parentNode) {
         const node = parentNode
@@ -447,6 +456,7 @@ class MailComposer {
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @param element Node data
      * @returns MimeNode node element
+     * @internal
      */
     _createContentNode(parentNode, element) {
         element = element || {};
@@ -507,6 +517,7 @@ class MailComposer {
      *
      * @param element Content element
      * @return Parsed element
+     * @internal
      */
     _processDataUrl(element) {
         const dataUrl = element.path || element.href;

package/node_modules/nodemailer/dist/esm/mailer/index.d.ts

@@ -25,13 +25,13 @@ export interface SentMessageInfo {
     /** Message-ID of the sent message */
     messageId: string;
     /** Recipient addresses the transport accepted */
-    accepted?: string[];
+    accepted?: string[] | undefined;
     /** Recipient addresses the transport rejected */
-    rejected?: string[];
+    rejected?: string[] | undefined;
     /** Recipient addresses left pending, LMTP reports these */
-    pending?: string[];
+    pending?: string[] | undefined;
     /** Last response from the server */
-    response?: string;
+    response?: string | undefined;
     /** The generated message, for the transports that hand it back instead of sending it */
     message?: unknown;
     /** Transport specific fields */
@@ -59,8 +59,8 @@ export type PluginFunction<T = SentMessageInfo> = (mail: MailMessage<T>, callbac
  * the socket, with the host and port to connect to
  */
 export interface GetSocketOptions {
-    host?: string;
-    port?: number | string;
+    host?: string | undefined;
+    port?: number | string | undefined;
     [key: string]: any;
 }
 /**
@@ -68,7 +68,7 @@ export interface GetSocketOptions {
  */
 export interface SocketOptions {
     /** An established socket, the proxied connection */
-    connection?: net.Socket;
+    connection?: net.Socket | undefined;
 }
 /**
  * Receives the socket options from a getSocket handler, or the error that prevented the
@@ -119,9 +119,9 @@ export interface Transport<T = SentMessageInfo> {
     /** Registers an event listener, the transport may emit 'log', 'error', 'idle' and 'clear' */
     on?(event: string | symbol, listener: (...args: any[]) => void): this;
     /** The Mail object the transport belongs to, set by Mail */
-    mailer?: Mail<T>;
+    mailer?: Mail<T> | undefined;
     /** Socket handler for a proxied connection, set by Mail when a proxy is configured */
-    getSocket?: GetSocketHandler;
+    getSocket?: GetSocketHandler | undefined;
 }
 /**
  * Transport configuration as read by Mail itself. The transport reads its own options from
@@ -129,25 +129,25 @@ export interface Transport<T = SentMessageInfo> {
  */
 export interface TransportOptions {
     /** Bunyan compatible logger, true for the default console logger, false or unset for no logging */
-    logger?: shared.ExternalLogger | boolean;
+    logger?: shared.ExternalLogger | boolean | undefined;
     /** Component name for the log lines, defaults to 'mail' */
-    component?: string;
+    component?: string | undefined;
     /** DKIM signing options, every message is signed with these unless it carries its own */
-    dkim?: DKIMOptions;
+    dkim?: DKIMOptions | undefined;
     /** Proxy url. http(s) proxies work as is, socks proxies need the socks module set with set('proxy_socks_module', socks) */
-    proxy?: string;
+    proxy?: string | undefined;
     /** TLS options, rejectUnauthorized applies to an https proxy as well */
-    tls?: ConnectionOptions;
+    tls?: ConnectionOptions | undefined;
     /** Reject content that points to a file path, forced onto every message */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Reject content that points to a URL, forced onto every message */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
     /** Method to normalize header keys for custom caseing, forced onto every message */
-    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'];
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** Recipients allowed on one message, forced onto every message, 0 disables the limit, defaults to 100000 */
-    maxRecipients?: number;
+    maxRecipients?: number | undefined;
     /** Convert data: images in the html into embedded attachments */
-    attachDataUrls?: boolean;
+    attachDataUrls?: boolean | undefined;
 }
 /**
  * The transporter object createTransport returns, a Mail instance wrapping a transport
@@ -161,13 +161,8 @@ export type Transporter<T = SentMessageInfo> = Mail<T>;
  */
 declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     options: TransportOptions;
+    /** Message defaults given to createTransport, kept public because the DefinitelyTyped typings declared it */
     _defaults: MailDefaults;
-    _defaultPlugins: {
-        [step: string]: PluginFunction<any>[];
-    };
-    _userPlugins: {
-        [step: string]: PluginFunction<any>[];
-    };
     meta: Map<string, any>;
     dkim: DKIM | false;
     transporter: Transport<T>;
@@ -182,7 +177,7 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
         (): Promise<true>;
     };
     /** Socket handler for a proxied connection, set by setupProxy and handed to the transport on the next send */
-    getSocket?: GetSocketHandler | false;
+    getSocket?: GetSocketHandler | false | undefined;
     constructor(transporter: Transport<T>, options?: TransportOptions, defaults?: MailDefaults);
     use(step: string, plugin: PluginFunction<T>): this;
     /**
@@ -194,14 +189,12 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     sendMail(data: SendMailOptions): Promise<T>;
     sendMail(data: SendMailOptions, callback: SendMailCallback<T>): void;
     getVersionString(): string;
-    _processPlugins(step: string, mail: MailMessage<T>, callback: PluginCallback): void;
     /**
      * Sets up proxy handler for a Nodemailer object
      *
      * @param proxyUrl Proxy configuration url
      */
     setupProxy(proxyUrl: string): void;
-    _convertDataImages(mail: MailMessage<T>, callback: PluginCallback): void;
     set<K extends keyof MailMeta & string>(key: K, value: MailMeta[K]): Map<string, any>;
     get<K extends keyof MailMeta & string>(key: K): MailMeta[K] | undefined;
 }