@mavogel/awscdk-rootmail 0.1.8 → 0.1.10

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

@@ -34,6 +34,8 @@ export interface ResolvedHostname {
     /** The resolver error when a cached value was used because of it */
     error?: Error | undefined;
 }
+/** The name @types/nodemailer used for ResolvedHostname */
+export type ResolveHostnameValue = ResolvedHostname;
 /**
  * Resolved addresses as stored in the DNS cache
  */
@@ -83,6 +85,8 @@ export interface LogEntry {
     [key: string]: any;
 }
 export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/** The name @types/nodemailer used for LogLevel */
+export type LoggerLevel = LogLevel;
 /**
  * A logger supplied by the caller, bunyan style. Any object works, a level it does not
  * implement is routed to one it does, see _logFunc
@@ -104,16 +108,24 @@ export interface GetLoggerOptions {
     /** A bunyan compatible logger, true for the default console logger, false or unset for no logging */
     logger?: ExternalLogger | boolean | undefined;
 }
+/**
+ * A bunyan style log method: a data object followed by a printf style message, or the
+ * message alone
+ */
+export interface LogMethod {
+    (data: LogEntry | undefined, message?: string, ...args: any[]): void;
+    (message?: string, ...args: any[]): void;
+}
 /**
  * The bunyan compatible logger interface returned by getLogger
  */
 export interface Logger {
-    trace(data?: LogEntry, message?: string, ...args: any[]): void;
-    debug(data?: LogEntry, message?: string, ...args: any[]): void;
-    info(data?: LogEntry, message?: string, ...args: any[]): void;
-    warn(data?: LogEntry, message?: string, ...args: any[]): void;
-    error(data?: LogEntry, message?: string, ...args: any[]): void;
-    fatal(data?: LogEntry, message?: string, ...args: any[]): void;
+    trace: LogMethod;
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
+    fatal: LogMethod;
 }
 /**
  * A parsed data URI
@@ -175,6 +187,7 @@ export declare const parseConnectionUrl: (str?: string | null) => ConnectionUrlO
  * creates a default console logger
  *
  * @param [options] Options object that might include 'logger' value
+ * @param [defaults] Fields merged into every log entry, overridden by the fields of the entry itself
  * @return bunyan compatible logger
  */
 export declare const getLogger: (options?: GetLoggerOptions, defaults?: LogEntry) => Logger;
@@ -198,18 +211,41 @@ export declare const parseDataURI: (uri: unknown) => ParsedDataURI | null;
  *
  * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
  * @param key Property name or an Array index
- * @param [options] Optional access policy: { disableFileAccess, disableUrlAccess }
  * @param callback Callback function with (err, value)
  */
 export declare function resolveContent(data: {
     [key: string]: any;
 }, key: string | number, callback: ResolveContentCallback): void;
+/**
+ * Resolves a String or a Buffer value for content value
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param options Access policy: { disableFileAccess, disableUrlAccess }
+ * @param callback Callback function with (err, value)
+ */
 export declare function resolveContent(data: {
     [key: string]: any;
 }, key: string | number, options: ResolveContentOptions | false | undefined, callback: ResolveContentCallback): void;
+/**
+ * Resolves a String or a Buffer value for content value
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param [options] Optional access policy: { disableFileAccess, disableUrlAccess }
+ * @returns Promise that resolves with the value
+ */
 export declare function resolveContent(data: {
     [key: string]: any;
 }, key: string | number, options?: ResolveContentOptions | false): Promise<any>;
+/**
+ * Resolves a String or a Buffer value for content value
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param options Access policy: { disableFileAccess, disableUrlAccess }
+ * @param callback Callback function with (err, value), a Promise is returned if not set
+ */
 export declare function resolveContent(data: {
     [key: string]: any;
 }, key: string | number, options: ResolveContentOptions | false | undefined, callback: ResolveContentCallback | undefined): Promise<any> | void;

package/node_modules/nodemailer/dist/esm/shared/index.js

@@ -318,6 +318,7 @@ export const _logFunc = (logger, level, defaults, data, message, ...args) => {
  * creates a default console logger
  *
  * @param [options] Options object that might include 'logger' value
+ * @param [defaults] Fields merged into every log entry, overridden by the fields of the entry itself
  * @return bunyan compatible logger
  */
 export const getLogger = (options, defaults) => {
@@ -333,8 +334,10 @@ export const getLogger = (options, defaults) => {
     }
     const logger = options.logger === true ? createDefaultLogger(levels) : options.logger;
     levels.forEach(level => {
-        response[level] = (data, message, ...args) => {
-            _logFunc(logger, level, defaults, data, message, ...args);
+        response[level] = (...args) => {
+            // the bunyan forms: a data object first, or the message alone
+            const data = typeof args[0] === 'string' ? undefined : args.shift();
+            _logFunc(logger, level, defaults, data, ...args);
         };
     });
     return response;

package/node_modules/nodemailer/dist/esm/smtp-connection/data-stream.d.ts

@@ -1,7 +1,8 @@
 import { Transform, type TransformOptions } from 'node:stream';
 /**
  * Escapes dots in the beginning of lines. Ends the stream with <CR><LF>.<CR><LF>
- * Also makes sure that only <CR><LF> sequences are used for linebreaks
+ * Also makes sure that only <CR><LF> sequences are used for linebreaks, bare CR and bare LF
+ * are both turned into <CR><LF>
  *
  * @param options Stream options
  */

package/node_modules/nodemailer/dist/esm/smtp-connection/data-stream.js

@@ -1,7 +1,13 @@
 import { Transform } from 'node:stream';
+// bytes inserted into the output, shared as they are only ever copied by Buffer.concat
+const INSERT_LF = Buffer.from('\n');
+const INSERT_LF_DOT = Buffer.from('\n.');
+const INSERT_CR = Buffer.from('\r');
+const INSERT_DOT = Buffer.from('.');
 /**
  * Escapes dots in the beginning of lines. Ends the stream with <CR><LF>.<CR><LF>
- * Also makes sure that only <CR><LF> sequences are used for linebreaks
+ * Also makes sure that only <CR><LF> sequences are used for linebreaks, bare CR and bare LF
+ * are both turned into <CR><LF>
  *
  * @param options Stream options
  */
@@ -30,33 +36,35 @@ export default class DataStream extends Transform {
         }
         this.inByteCount += chunk.length;
         for (i = 0, len = chunk.length; i < len; i++) {
-            if (chunk[i] === 0x2e) {
-                // .
-                if ((i && chunk[i - 1] === 0x0a) || (!i && (!this.lastByte || this.lastByte === 0x0a))) {
-                    buf = chunk.slice(lastPos, i + 1);
-                    chunks.push(buf);
-                    chunks.push(Buffer.from('.'));
-                    chunklen += buf.length + 1;
-                    lastPos = i + 1;
-                }
+            const byte = chunk[i];
+            const prev = i ? chunk[i - 1] : this.lastByte;
+            let insert = false;
+            if (prev === 0x0d && byte !== 0x0a) {
+                // a bare CR becomes CRLF. A receiver that treats a lone CR as a line end would
+                // otherwise see "\r.\r" as the end of the data (SMTP smuggling), so a dot
+                // following it is stuffed like at the start of any other line
+                insert = byte === 0x2e ? INSERT_LF_DOT : INSERT_LF;
+            }
+            else if (byte === 0x0a && prev !== 0x0d) {
+                // a bare LF becomes CRLF
+                insert = INSERT_CR;
             }
-            else if (chunk[i] === 0x0a) {
-                // \n
-                if ((i && chunk[i - 1] !== 0x0d) || (!i && this.lastByte !== 0x0d)) {
-                    if (i > lastPos) {
-                        buf = chunk.slice(lastPos, i);
-                        chunks.push(buf);
-                        chunklen += buf.length + 2;
-                    }
-                    else {
-                        chunklen += 2;
-                    }
-                    chunks.push(Buffer.from('\r\n'));
-                    lastPos = i + 1;
+            else if (byte === 0x2e && (prev === 0x0a || prev === false)) {
+                // a dot at the start of a line
+                insert = INSERT_DOT;
+            }
+            if (insert) {
+                if (i > lastPos) {
+                    buf = chunk.slice(lastPos, i);
+                    chunks.push(buf);
+                    chunklen += buf.length;
                 }
+                chunks.push(insert);
+                chunklen += insert.length;
+                lastPos = i;
             }
         }
-        if (chunklen) {
+        if (chunks.length) {
             // add last piece
             if (lastPos < chunk.length) {
                 buf = chunk.slice(lastPos);

package/node_modules/nodemailer/dist/esm/smtp-connection/http-proxy-client.d.ts

@@ -2,7 +2,7 @@
  * Minimal HTTP/S proxy client
  */
 import net from 'node:net';
-import type { NodemailerError } from '../errors.js';
+import type { Callback } from '../errors.js';
 /**
  * TLS options for connecting to an HTTPS proxy
  */
@@ -13,7 +13,7 @@ export interface HttpProxyClientOptions {
 /**
  * Receives the proxied socket once the CONNECT handshake has succeeded, or the error that prevented it
  */
-export type HttpProxyClientCallback = (err: NodemailerError | null, socket?: net.Socket) => void;
+export type HttpProxyClientCallback = Callback<net.Socket>;
 /**
  * Establishes proxied connection to destinationPort
  *
@@ -21,13 +21,21 @@ export type HttpProxyClientCallback = (err: NodemailerError | null, socket?: net
  *     socket.write("GET / HTTP/1.0\r\n\r\n");
  * });
  *
- * @param proxyUrl proxy configuration, etg "http://proxy.host:3128/"
+ * @param proxyUrl proxy configuration, e.g. "http://proxy.host:3128/"
  * @param destinationPort Port to open in destination host
  * @param destinationHost Destination hostname
- * @param [tlsOptions] Optional TLS options for an HTTPS proxy (e.g. { rejectUnauthorized: false })
- * @param callback Callback to run with the rocket object once connection is established
+ * @param callback Callback to run with the socket object once connection is established
  */
 declare function httpProxyClient(proxyUrl: string, destinationPort: number | string, destinationHost: string, callback: HttpProxyClientCallback): void;
+/**
+ * Establishes proxied connection to destinationPort through an HTTPS proxy
+ *
+ * @param proxyUrl proxy configuration, e.g. "https://proxy.host:3128/"
+ * @param destinationPort Port to open in destination host
+ * @param destinationHost Destination hostname
+ * @param tlsOptions TLS options for the proxy connection (e.g. { rejectUnauthorized: false })
+ * @param callback Callback to run with the socket object once connection is established
+ */
 declare function httpProxyClient(proxyUrl: string, destinationPort: number | string, destinationHost: string, tlsOptions: HttpProxyClientOptions | undefined, callback: HttpProxyClientCallback): void;
 /**
  * Socket timeout in milliseconds while the CONNECT handshake is in progress, defaults to 30 seconds.

package/node_modules/nodemailer/dist/esm/smtp-connection/http-proxy-client.js

@@ -14,6 +14,8 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
         tlsOptions = {};
     }
     tlsOptions = tlsOptions || {};
+    // the error paths hand over the error alone
+    const done = callback;
     // Reject CRLF in the destination before it reaches the CONNECT request line
     // and Host header. A tainted host/port could otherwise inject additional
     // request headers into the proxy connection (HTTP request splitting).
@@ -21,7 +23,7 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
     if (!destinationPort || /[\r\n]/.test(destinationHost)) {
         const err = new Error('Invalid proxy destination');
         err.code = errors.EPROXY;
-        setImmediate(() => callback(err));
+        setImmediate(() => done(err));
         return;
     }
     const proxy = urllib.parse(proxyUrl);
@@ -55,7 +57,7 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
         catch (_E) {
             // ignore
         }
-        callback(err);
+        done(err);
     };
     const timeoutErr = () => {
         const err = new Error('Proxy socket timed out');
@@ -86,18 +88,28 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
                 .join('\r\n') +
             // End request
             '\r\n\r\n');
-        let headers = '';
+        // The response is collected as chunks and only the bytes that just arrived, together
+        // with the three before them, are searched for the end of the headers. Appending to a
+        // string and searching all of it again re-read the whole response on every chunk.
+        const chunks = [];
+        let received = 0;
+        let tail = '';
         const onSocketData = (chunk) => {
             let match;
-            let remainder;
             if (finished) {
                 return;
             }
-            headers += chunk.toString('binary');
-            if ((match = headers.match(/\r\n\r\n/))) {
+            const window = tail + chunk.toString('binary');
+            const windowEnd = window.indexOf('\r\n\r\n');
+            chunks.push(chunk);
+            received += chunk.length;
+            tail = window.slice(-3);
+            if (windowEnd >= 0) {
                 socket.removeListener('data', onSocketData);
-                remainder = headers.substr(match.index + match[0].length);
-                headers = headers.substr(0, match.index);
+                const headerEnd = received - window.length + windowEnd;
+                const response = Buffer.concat(chunks, received).toString('binary');
+                const headers = response.substr(0, headerEnd);
+                const remainder = response.substr(headerEnd + 4);
                 if (remainder) {
                     socket.unshift(Buffer.from(remainder, 'binary'));
                 }
@@ -114,14 +126,14 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
                     }
                     const err = new Error('Invalid response from proxy' + ((match && ': ' + match[1]) || ''));
                     err.code = errors.EPROXY;
-                    return callback(err);
+                    return done(err);
                 }
                 socket.removeListener('error', tempSocketErr);
                 socket.removeListener('timeout', timeoutErr);
                 socket.setTimeout(0);
-                return callback(null, socket);
+                return done(null, socket);
             }
-            if (headers.length > MAX_RESPONSE_HEADER_BYTES) {
+            if (received > MAX_RESPONSE_HEADER_BYTES) {
                 socket.removeListener('data', onSocketData);
                 const err = new Error('Proxy response headers too large');
                 err.code = errors.EPROXY;

package/node_modules/nodemailer/dist/esm/smtp-connection/index.d.ts

@@ -3,8 +3,9 @@ import net from 'node:net';
 import tls from 'node:tls';
 import { type Readable } from 'node:stream';
 import * as shared from '../shared/index.js';
-import type { NodemailerError } from '../errors.js';
+import type { Callback, NodemailerError } from '../errors.js';
 import type XOAuth2 from '../xoauth2/index.js';
+import type { XOAuth2Options } from '../xoauth2/index.js';
 /**
  * Custom authentication handlers keyed by (case insensitive) SASL method name
  */
@@ -25,11 +26,11 @@ export interface SMTPConnectionOptions {
     secured?: boolean | undefined;
     /** Server name for SNI, defaults to host when that is not an IP address */
     servername?: string | undefined;
-    /** Ignore STARTTLS even when the server advertises it */
+    /** Ignore STARTTLS even when the server advertises it, has no effect when requireTLS is set */
     ignoreTLS?: boolean | undefined;
-    /** Force STARTTLS, fail when the server does not support it */
+    /** Force STARTTLS, fail when the server does not support it. Takes precedence over ignoreTLS and opportunisticTLS */
     requireTLS?: boolean | undefined;
-    /** Continue unencrypted when the STARTTLS upgrade fails */
+    /** Continue unencrypted when the STARTTLS upgrade fails, has no effect when requireTLS is set */
     opportunisticTLS?: boolean | undefined;
     /** Name of the client server, sent with EHLO/HELO, CRLF is stripped */
     name?: string | undefined;
@@ -117,12 +118,23 @@ export interface SMTPConnectionCustomAuthResponse {
  * Callback for a command sent by a custom authentication handler
  */
 export type SMTPConnectionCustomAuthCommandCallback = (err: Error | null, data: SMTPConnectionCustomAuthResponse) => void;
+/**
+ * The auth object as a custom authentication handler sees it: the object handed to login()
+ * with the credentials filled in from its user and pass values
+ */
+export interface SMTPConnectionCustomAuthData extends SMTPConnectionAuth {
+    /** The user and pass values of the auth object, the way @types/nodemailer declared them */
+    credentials: SMTPConnectionCredentials & {
+        user: string;
+        pass: string;
+    };
+}
 /**
  * The object a custom authentication handler is run with
  */
 export interface SMTPConnectionCustomAuthContext {
-    /** The auth object handed to login() */
-    auth: SMTPConnectionAuth;
+    /** The auth object handed to login(), with the credentials filled in */
+    auth: SMTPConnectionCustomAuthData;
     /** Selected authentication method name */
     method: string;
     /** SMTP extensions the server advertised */
@@ -131,17 +143,20 @@ export interface SMTPConnectionCustomAuthContext {
     authMethods: string[];
     /** Maximum message size the server accepts, false when not advertised */
     maxAllowedSize: number | false;
-    /** Sends a command to the server. Returns a promise when no callback is given */
-    sendCommand(cmd: string, done?: SMTPConnectionCustomAuthCommandCallback): Promise<SMTPConnectionCustomAuthResponse> | undefined;
+    /** Sends a command to the server and resolves with the parsed reply */
+    sendCommand(cmd: string): Promise<SMTPConnectionCustomAuthResponse>;
+    /** Sends a command to the server and hands the parsed reply to the callback */
+    sendCommand(cmd: string, done: SMTPConnectionCustomAuthCommandCallback): void;
     /** Marks the user as authenticated */
     resolve(): void;
     /** Fails the authentication with an error */
     reject(err: Error | string): void;
 }
 /**
- * A custom authentication handler. Calls resolve() or reject() on the context, or returns a promise
+ * A custom authentication handler. Calls resolve() or reject() on the context, or returns a
+ * promise that settles the authentication. Any other return value is ignored
  */
-export type SMTPConnectionCustomAuthHandler = (ctx: SMTPConnectionCustomAuthContext) => void | Promise<unknown>;
+export type SMTPConnectionCustomAuthHandler = (ctx: SMTPConnectionCustomAuthContext) => unknown;
 /**
  * An envelope address, either a plain string or an object with an address property
  */
@@ -168,12 +183,16 @@ export interface SMTPEnvelopeDsn {
     /** Alias of recipient, in the 'rfc822;address' form */
     orcpt?: string | null | undefined;
 }
+/**
+ * A single DSN notify value
+ */
+export type SMTPEnvelopeDsnNotify = 'NEVER' | 'SUCCESS' | 'FAILURE' | 'DELAY';
 /**
  * Envelope object accepted by send()
  */
 export interface SMTPEnvelope {
-    /** Sender address */
-    from?: string | SMTPEnvelopeAddress | undefined;
+    /** Sender address, false for the null sender of a bounce message (MAIL FROM:<>) */
+    from?: string | SMTPEnvelopeAddress | false | undefined;
     /** Recipient address or addresses */
     to?: string | SMTPEnvelopeAddress | Array<string | SMTPEnvelopeAddress> | undefined;
     /** Message size in bytes, sent as the SIZE parameter when the server supports it */
@@ -202,9 +221,9 @@ export interface SMTPConnectionEnvelope extends SMTPEnvelope {
     accepted: string[];
 }
 /**
- * Result of a sent message
+ * The recipient bookkeeping of a sent message, known once the envelope is accepted
  */
-export interface SMTPConnectionSendInfo {
+export interface SMTPConnectionEnvelopeInfo {
     /** Recipients the server accepted */
     accepted: string[];
     /** Recipients the server rejected */
@@ -213,19 +232,25 @@ export interface SMTPConnectionSendInfo {
     ehlo?: string[] | undefined;
     /** Errors for the rejected recipients */
     rejectedErrors?: NodemailerError[] | undefined;
+}
+/**
+ * Result of a sent message
+ */
+export interface SMTPConnectionSendInfo extends SMTPConnectionEnvelopeInfo {
     /** Time in ms spent on the envelope commands */
-    envelopeTime?: number | undefined;
+    envelopeTime: number;
     /** Time in ms spent on streaming the message */
-    messageTime?: number | undefined;
+    messageTime: number;
     /** Size of the encoded message in bytes */
-    messageSize?: number | undefined;
+    messageSize: number;
     /** Final server response for the message */
-    response?: string | undefined;
+    response: string;
 }
 /**
- * Callback for send()
+ * Callback for send(), receives the result once the server accepted the message. The error
+ * path hands over the error alone
  */
-export type SMTPConnectionSendCallback = (err: NodemailerError | null, info?: SMTPConnectionSendInfo) => void;
+export type SMTPConnectionSendCallback = Callback<SMTPConnectionSendInfo>;
 /**
  * Callback for login() and reset(), the result is true on success
  */
@@ -263,8 +288,8 @@ export type SMTPConnectionResponseAction = (str: string) => void;
  *  * **port** - is the port to connect to (defaults to 587 or 465)
  *  * **host** - is the hostname or IP address to connect to (defaults to 'localhost')
  *  * **secure** - use SSL
- *  * **ignoreTLS** - ignore server support for STARTTLS
- *  * **requireTLS** - forces the client to use STARTTLS
+ *  * **ignoreTLS** - ignore server support for STARTTLS (has no effect when requireTLS is set)
+ *  * **requireTLS** - forces the client to use STARTTLS, takes precedence over ignoreTLS and opportunisticTLS
  *  * **name** - the name of the client server
  *  * **localAddress** - outbound address to bind to (see: http://nodejs.org/api/net.html#net_net_connect_options_connectionlistener)
  *  * **greetingTimeout** - Time to wait in ms until greeting message is received from the server (defaults to 30 seconds)
@@ -285,7 +310,7 @@ export type SMTPConnectionResponseAction = (str: string) => void;
  */
 declare class SMTPConnection extends EventEmitter {
     id: string;
-    stage: string;
+    stage: 'init' | 'connected';
     options: SMTPConnectionOptions;
     secureConnection: boolean;
     alreadySecured: boolean;
@@ -354,7 +379,7 @@ declare class SMTPConnection extends EventEmitter {
      *
      * @param envelope Envelope object, {from: addr, to: [addr]}
      * @param message String, Buffer or a Stream
-     * @param callback Callback to return once sending is completed
+     * @param done Callback to return once sending is completed
      */
     send(envelope: SMTPEnvelope, message: string | Buffer | Readable, done: SMTPConnectionSendCallback): void;
     /**
@@ -370,12 +395,22 @@ declare class SMTPConnection extends EventEmitter {
 declare namespace SMTPConnection {
     type Options = SMTPConnectionOptions;
     type AuthenticationType = SMTPConnectionAuth;
+    type AuthenticationTypeLogin = SMTPConnectionAuth;
+    type AuthenticationTypeOAuth2 = SMTPConnectionAuth;
+    type AuthenticationTypeCustom = SMTPConnectionAuth;
+    type AuthenticationCredentials = SMTPConnectionAuth;
+    type AuthenticationOAuth2 = SMTPConnectionAuth;
     type Credentials = SMTPConnectionCredentials;
+    type OAuth2 = XOAuth2Options;
     type Envelope = SMTPEnvelope;
     type DSNOptions = SMTPEnvelopeDsn;
+    type DSNOption = SMTPEnvelopeDsnNotify;
     type SentMessageInfo = SMTPConnectionSendInfo;
+    type SMTPError = NodemailerError;
     type CustomAuthenticationContext = SMTPConnectionCustomAuthContext;
     type CustomAuthenticationResponse = SMTPConnectionCustomAuthResponse;
     type CustomAuthenticationHandlers = SMTPConnectionCustomAuthHandlers;
 }
+/** The same aliases as module level exports, for `import * as SMTPConnection` and `import SMTPConnection = require()` */
+export type { SMTPConnectionOptions as Options, SMTPConnectionAuth as AuthenticationType, SMTPConnectionAuth as AuthenticationTypeLogin, SMTPConnectionAuth as AuthenticationTypeOAuth2, SMTPConnectionAuth as AuthenticationTypeCustom, SMTPConnectionAuth as AuthenticationCredentials, SMTPConnectionAuth as AuthenticationOAuth2, SMTPConnectionCredentials as Credentials, XOAuth2Options as OAuth2, SMTPEnvelope as Envelope, SMTPEnvelopeDsn as DSNOptions, SMTPEnvelopeDsnNotify as DSNOption, SMTPConnectionSendInfo as SentMessageInfo, NodemailerError as SMTPError, SMTPConnectionCustomAuthContext as CustomAuthenticationContext, SMTPConnectionCustomAuthResponse as CustomAuthenticationResponse, SMTPConnectionCustomAuthHandlers as CustomAuthenticationHandlers };
 export default SMTPConnection;