@mavogel/awscdk-rootmail 0.1.2 → 0.1.3

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

@@ -0,0 +1,719 @@
+import { EventEmitter } from 'node:events';
+import net from 'node:net';
+import tls from 'node:tls';
+import DataStream from './data-stream.js';
+import { type Readable } from 'node:stream';
+import * as shared from '../shared/index.js';
+import type { NodemailerError } from '../errors.js';
+import type XOAuth2 from '../xoauth2/index.js';
+/**
+ * Custom authentication handlers keyed by (case insensitive) SASL method name
+ */
+export type SMTPConnectionCustomAuthHandlers = {
+    [method: string]: SMTPConnectionCustomAuthHandler;
+};
+/**
+ * Options for the SMTP connection, see the SMTPConnection class description
+ */
+export interface SMTPConnectionOptions {
+    /** Port to connect to, defaults to 587, or to 465 when secure is set */
+    port?: number | string;
+    /** Hostname or IP address to connect to, defaults to 'localhost' */
+    host?: string;
+    /** Use TLS from the start */
+    secure?: boolean;
+    /** Marks the provided socket as already upgraded to TLS */
+    secured?: boolean;
+    /** Server name for SNI, defaults to host when that is not an IP address */
+    servername?: string;
+    /** Ignore STARTTLS even when the server advertises it */
+    ignoreTLS?: boolean;
+    /** Force STARTTLS, fail when the server does not support it */
+    requireTLS?: boolean;
+    /** Continue unencrypted when the STARTTLS upgrade fails */
+    opportunisticTLS?: boolean;
+    /** Name of the client server, sent with EHLO/HELO, CRLF is stripped */
+    name?: string;
+    /** Outbound address to bind to */
+    localAddress?: string;
+    /** Time to wait in ms for the connection to establish, defaults to 2 minutes */
+    connectionTimeout?: number;
+    /** Time to wait in ms until the greeting is received, defaults to 30 seconds */
+    greetingTimeout?: number;
+    /** Time of inactivity in ms until the connection is closed, defaults to 10 minutes */
+    socketTimeout?: number;
+    /** Time to wait in ms for the DNS requests to be resolved, defaults to 30 seconds */
+    dnsTimeout?: number;
+    /** Use LMTP instead of SMTP */
+    lmtp?: boolean;
+    /** Bunyan compatible logger interface, true for the default console logger */
+    logger?: shared.ExternalLogger | boolean;
+    /** Pass SMTP traffic, including the message data, to the logger */
+    debug?: boolean;
+    /** Pass SMTP commands and responses to the logger */
+    transactionLog?: boolean;
+    /** Options for tls.connect */
+    tls?: tls.ConnectionOptions;
+    /** Existing socket to use instead of creating a new one, not connected yet */
+    socket?: net.Socket;
+    /** Already opened connection to use instead of creating a new one */
+    connection?: net.Socket;
+    /** Count loopback interfaces when checking which address families are usable */
+    allowInternalNetworkInterfaces?: boolean;
+    /** Logger component name, defaults to 'smtp-connection' */
+    component?: string;
+    /** Custom authentication handlers keyed by method name */
+    customAuth?: SMTPConnectionCustomAuthHandlers;
+}
+/**
+ * User and password credentials resolved for a SASL mechanism
+ */
+export interface SMTPConnectionCredentials {
+    user?: string;
+    pass?: string;
+    /** Extra options for the authentication method, copied from the auth object */
+    options?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Authentication data for login()
+ */
+export interface SMTPConnectionAuth {
+    /** Authentication type, informational */
+    type?: string;
+    /** SASL method to use, false or unset picks the first supported one (PLAIN if none is advertised) */
+    method?: string | false;
+    user?: string;
+    pass?: string;
+    /** Extra options for the authentication method */
+    options?: {
+        [key: string]: any;
+    };
+    /** XOAuth2 token generator, selects XOAUTH2 when no method is set */
+    oauth2?: XOAuth2;
+    /** Credentials for the SASL mechanism, filled in from user and pass when missing */
+    credentials?: SMTPConnectionCredentials;
+    /** Custom authentication handlers receive the auth object as is, so it may carry any other value */
+    [key: string]: any;
+}
+/**
+ * A parsed server reply, handed to the sendCommand callback of a custom authentication handler
+ */
+export interface SMTPConnectionCustomAuthResponse {
+    /** The command that was sent */
+    command: string;
+    /** Raw server response */
+    response: string;
+    /** Numeric status code, 0 if the response did not start with one */
+    status: number;
+    /** Enhanced status code, if any */
+    code?: string;
+    /** Response text without the status codes */
+    text: string;
+}
+/**
+ * Callback for a command sent by a custom authentication handler
+ */
+export type SMTPConnectionCustomAuthCommandCallback = (err: Error | null, data: SMTPConnectionCustomAuthResponse) => void;
+/**
+ * The object a custom authentication handler is run with
+ */
+export interface SMTPConnectionCustomAuthContext {
+    /** The auth object handed to login() */
+    auth: SMTPConnectionAuth;
+    /** Selected authentication method name */
+    method: string;
+    /** SMTP extensions the server advertised */
+    extensions: string[];
+    /** SASL methods the server advertised */
+    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;
+    /** 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
+ */
+export type SMTPConnectionCustomAuthHandler = (ctx: SMTPConnectionCustomAuthContext) => void | Promise<unknown>;
+/**
+ * An envelope address, either a plain string or an object with an address property
+ */
+export interface SMTPEnvelopeAddress {
+    address?: string;
+    name?: string;
+}
+/**
+ * DSN parameters for the envelope (RFC 3461)
+ */
+export interface SMTPEnvelopeDsn {
+    /** Return either 'HDRS' (headers) or 'FULL' (body) with the notification */
+    ret?: string | null;
+    /** Alias of ret */
+    return?: string;
+    /** Envelope identifier, sent as ENVID */
+    envid?: string | null;
+    /** Alias of envid */
+    id?: string;
+    /** When to notify: 'NEVER', or any combination of 'SUCCESS', 'FAILURE' and 'DELAY' */
+    notify?: string | string[] | null;
+    /** Original recipient, sent as ORCPT */
+    recipient?: string;
+    /** Alias of recipient, in the 'rfc822;address' form */
+    orcpt?: string | null;
+}
+/**
+ * Envelope object accepted by send()
+ */
+export interface SMTPEnvelope {
+    /** Sender address */
+    from?: string | SMTPEnvelopeAddress;
+    /** Recipient address or addresses */
+    to?: string | SMTPEnvelopeAddress | Array<string | SMTPEnvelopeAddress>;
+    /** Message size in bytes, sent as the SIZE parameter when the server supports it */
+    size?: number | string;
+    /** DSN parameters, sent when the server supports the DSN extension */
+    dsn?: SMTPEnvelopeDsn;
+    /** Declare BODY=8BITMIME when the server supports it */
+    use8BitMime?: boolean;
+    /** RFC 8689: send the REQUIRETLS parameter, requires a TLS connection and server support */
+    requireTLSExtensionEnabled?: boolean;
+}
+/**
+ * The envelope as tracked by the connection while a message is being sent. The from and to
+ * values are normalized to strings and the recipient bookkeeping is added by _setEnvelope
+ */
+export interface SMTPConnectionEnvelope extends SMTPEnvelope {
+    from?: string;
+    to?: string[];
+    /** Recipients still waiting for RCPT TO */
+    rcptQueue: string[];
+    /** Recipients the server rejected */
+    rejected: string[];
+    /** Errors for the rejected recipients */
+    rejectedErrors: NodemailerError[];
+    /** Recipients the server accepted */
+    accepted: string[];
+}
+/**
+ * Result of a sent message
+ */
+export interface SMTPConnectionSendInfo {
+    /** Recipients the server accepted */
+    accepted: string[];
+    /** Recipients the server rejected */
+    rejected: string[];
+    /** EHLO response lines, without the greeting line */
+    ehlo?: string[];
+    /** Errors for the rejected recipients */
+    rejectedErrors?: NodemailerError[];
+    /** Time in ms spent on the envelope commands */
+    envelopeTime?: number;
+    /** Time in ms spent on streaming the message */
+    messageTime?: number;
+    /** Size of the encoded message in bytes */
+    messageSize?: number;
+    /** Final server response for the message */
+    response?: string;
+}
+/**
+ * Callback for send()
+ */
+export type SMTPConnectionSendCallback = (err: NodemailerError | null, info?: SMTPConnectionSendInfo) => void;
+/**
+ * Callback for login() and reset(), the result is true on success
+ */
+export type SMTPConnectionCallback = (err: NodemailerError | null, result?: boolean) => void;
+/**
+ * Callback for the message data response, yields the server response text
+ */
+export type SMTPConnectionResponseCallback = (err: NodemailerError | null, response?: string) => void;
+/**
+ * Callback for connect(), run once the SMTP handshake is finished
+ */
+export type SMTPConnectionConnectCallback = (err?: NodemailerError) => void;
+/**
+ * Options handed to net.connect or tls.connect, resolved hostname values are merged in
+ */
+export interface SMTPConnectionConnectOptions extends tls.ConnectionOptions {
+    port: number;
+    host: string;
+    /** Outbound address to bind to */
+    localAddress?: string;
+    /** Count loopback interfaces when resolving the hostname */
+    allowInternalNetworkInterfaces?: boolean;
+    /** DNS lookup timeout in ms */
+    timeout?: number;
+}
+/**
+ * A queued handler for the next server response
+ */
+export type SMTPConnectionResponseAction = (str: string) => void;
+/**
+ * Generates a SMTP connection object
+ *
+ * Optional options object takes the following possible properties:
+ *
+ *  * **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
+ *  * **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)
+ *  * **connectionTimeout** - how many milliseconds to wait for the connection to establish (defaults to 2 minutes)
+ *  * **socketTimeout** - Time of inactivity until the connection is closed (defaults to 10 minutes)
+ *  * **dnsTimeout** - Time to wait in ms for the DNS requests to be resolved (defaults to 30 seconds)
+ *  * **lmtp** - if true, uses LMTP instead of SMTP protocol
+ *  * **logger** - bunyan compatible logger interface
+ *  * **debug** - if true pass SMTP traffic to the logger
+ *  * **tls** - options for createCredentials
+ *  * **socket** - existing socket to use instead of creating a new one (see: http://nodejs.org/api/net.html#net_class_net_socket)
+ *  * **secured** - boolean indicates that the provided socket has already been upgraded to tls
+ *
+ * @constructor
+ * @namespace SMTP Client module
+ * @param [options] Option properties
+ */
+declare class SMTPConnection extends EventEmitter {
+    id: string;
+    stage: string;
+    options: SMTPConnectionOptions;
+    secureConnection: boolean;
+    alreadySecured: boolean;
+    port: number;
+    host: string;
+    servername: string | false;
+    allowInternalNetworkInterfaces: boolean;
+    name: string;
+    logger: shared.Logger;
+    customAuth: Map<string, SMTPConnectionCustomAuthHandler>;
+    /**
+     * Expose version nr, just for the reference
+     */
+    version: string;
+    /**
+     * If true, then the user is authenticated
+     */
+    authenticated: boolean;
+    /**
+     * If set to true, this instance is no longer active
+     * @private
+     */
+    destroyed: boolean;
+    /**
+     * Defines if the current connection is secure or not. If not,
+     * STARTTLS can be used if available
+     * @private
+     */
+    secure: boolean;
+    /**
+     * Store incomplete messages coming from the server
+     * @private
+     */
+    _remainder: string;
+    /**
+     * Unprocessed responses from the server
+     */
+    _responseQueue: string[];
+    lastServerResponse: string | false;
+    /**
+     * The socket connecting to the server
+     * @public
+     */
+    _socket: net.Socket | false | null;
+    /**
+     * Lists supported auth mechanisms
+     * @private
+     */
+    _supportedAuth: string[];
+    /**
+     * Set to true, if EHLO response includes "AUTH".
+     * If false then authentication is not tried
+     */
+    allowsAuth: boolean;
+    /**
+     * Includes current envelope (from, to)
+     * @private
+     */
+    _envelope: SMTPConnectionEnvelope | false;
+    /**
+     * Lists supported extensions
+     * @private
+     */
+    _supportedExtensions: string[];
+    /**
+     * Defines the maximum allowed size for a single message
+     * @private
+     */
+    _maxAllowedSize: number;
+    /**
+     * Function queue to run if a data chunk comes from the server
+     * @private
+     */
+    _responseActions: SMTPConnectionResponseAction[];
+    _recipientQueue: string[];
+    /**
+     * Timeout variable for waiting the greeting
+     * @private
+     */
+    _greetingTimeout: NodeJS.Timeout | false;
+    /**
+     * Timeout variable for waiting the connection to start
+     * @private
+     */
+    _connectionTimeout: NodeJS.Timeout | false;
+    /**
+     * If the socket is deemed already closed
+     * @private
+     */
+    _destroyed: boolean;
+    /**
+     * If the socket is already being closed
+     * @private
+     */
+    _closing: boolean;
+    /**
+     * Message DATA stream currently piped to the socket, if any. Tracked so
+     * close() can unpipe it before tearing the socket down.
+     * @private
+     */
+    _currentDataStream: DataStream | false;
+    /**
+     * Callbacks for socket's listeners
+     */
+    _onSocketData: (chunk: Buffer) => void;
+    _onSocketError: (error: Error) => void;
+    _onSocketClose: () => void;
+    _onSocketEnd: () => void;
+    _onSocketTimeout: () => void;
+    /**
+     * Connection-phase error handler (supports fallback to alternative addresses)
+     */
+    _onConnectionSocketError: (err: Error) => void;
+    /**
+     * Connection attempt counter for fallback race condition protection
+     * @private
+     */
+    _connectionAttemptId: number;
+    /**
+     * Alternative resolved addresses to try when the connection fails, set by connect()
+     * @private
+     */
+    _fallbackAddresses?: string[];
+    /**
+     * Options of the current connection attempt, set by connect()
+     * @private
+     */
+    _connectOpts?: SMTPConnectionConnectOptions;
+    /**
+     * Authentication data, set by login()
+     * @private
+     */
+    _auth: SMTPConnectionAuth;
+    /**
+     * Selected SASL method, set by login()
+     * @private
+     */
+    _authMethod: string | false;
+    /**
+     * True while the STARTTLS upgrade is in progress
+     * @private
+     */
+    upgrading?: boolean;
+    /**
+     * EHLO response lines, without the greeting line
+     * @private
+     */
+    _ehloLines?: string[];
+    /**
+     * True if SMTPUTF8 was declared for the current envelope
+     * @private
+     */
+    _usingSmtpUtf8?: boolean;
+    /**
+     * True if BODY=8BITMIME was declared for the current envelope
+     * @private
+     */
+    _using8BitMime?: boolean;
+    constructor(options?: SMTPConnectionOptions);
+    /**
+     * Creates a connection to a SMTP server and sets up connection
+     * listener
+     */
+    connect(connectCallback?: SMTPConnectionConnectCallback): void;
+    /**
+     * Resolves the hostname and applies resolved values to opts,
+     * then calls the provided callback with the resolved data
+     *
+     * @param opts Connection options (modified in place)
+     * @param callback Called with resolved data on success
+     */
+    _resolveAndConnect(opts: SMTPConnectionConnectOptions, callback: (resolved: shared.ResolvedHostname) => void): void;
+    /**
+     * Attempts to connect to the specified host address
+     *
+     * @param opts Connection options
+     * @param secure Whether to use TLS
+     */
+    _connectToHost(opts: SMTPConnectionConnectOptions, secure: boolean): void;
+    /**
+     * Sets up connection timeout and error handlers
+     */
+    _setupConnectionHandlers(): void;
+    /**
+     * Handles connection errors with fallback to alternative addresses
+     *
+     * @param err Error object or message
+     * @param code Error code
+     */
+    _onConnectionError(err: Error | string, code: string): void;
+    /**
+     * Sends QUIT
+     */
+    quit(): void;
+    /**
+     * Closes the connection to the server
+     */
+    close(): void;
+    /**
+     * Authenticate user
+     */
+    login(authData: SMTPConnectionAuth | undefined, callback: SMTPConnectionCallback): void;
+    /**
+     * Sends a message
+     *
+     * @param envelope Envelope object, {from: addr, to: [addr]}
+     * @param message String, Buffer or a Stream
+     * @param callback Callback to return once sending is completed
+     */
+    send(envelope: SMTPEnvelope, message: string | Buffer | Readable, done: SMTPConnectionSendCallback): void;
+    /**
+     * Resets connection state
+     *
+     * @param callback Callback to return once connection is reset
+     */
+    reset(callback: SMTPConnectionCallback): void;
+    /**
+     * Connection listener that is run when the connection to
+     * the server is opened
+     *
+     * @event
+     */
+    _onConnect(): void;
+    /**
+     * 'data' listener for data coming from the server
+     *
+     * @event
+     * @param chunk Data chunk coming from the server
+     */
+    _onData(chunk: Buffer): void;
+    /**
+     * 'error' listener for the socket
+     *
+     * @event
+     * @param err Error object
+     * @param type Error name
+     */
+    _onError(err: NodemailerError | string, type: string | false, data: string | false, command: string | false): void;
+    _formatError(message: Error | string, type?: string | false, response?: string | false, command?: string | false): NodemailerError;
+    /**
+     * 'close' listener for the socket
+     *
+     * @event
+     */
+    _onClose(): void;
+    /**
+     * 'end' listener for the socket
+     *
+     * @event
+     */
+    _onEnd(): void;
+    /**
+     * 'timeout' listener for the socket
+     *
+     * @event
+     */
+    _onTimeout(): void;
+    /**
+     * Destroys the client, emits 'end'
+     */
+    _destroy(): void;
+    /**
+     * Upgrades the connection to TLS
+     *
+     * @param callback Callback function to run when the connection
+     *        has been secured
+     */
+    _upgradeConnection(callback: (err: Error | null, secured?: boolean) => void): void;
+    /**
+     * Processes queued responses from the server
+     */
+    _processResponse(): boolean | void;
+    /**
+     * Send a command to the server, append \r\n
+     *
+     * @param str String to be sent to the server
+     * @param logStr Optional string to be used for logging instead of the actual string
+     */
+    _sendCommand(str: string, logStr?: string): void;
+    /**
+     * Initiates a new message by submitting envelope data, starting with
+     * MAIL FROM: command
+     *
+     * @param envelope Envelope object in the form of
+     *        {from:'...', to:['...']}
+     *        or
+     *        {from:{address:'...',name:'...'}, to:[address:'...',name:'...']}
+     */
+    _setEnvelope(envelope: SMTPEnvelope | undefined, callback: SMTPConnectionSendCallback): void;
+    _setDsnEnvelope(params: SMTPEnvelopeDsn): SMTPEnvelopeDsn;
+    _getDsnRcptToArgs(): string;
+    _createSendStream(callback: SMTPConnectionResponseCallback): DataStream;
+    /** ACTIONS **/
+    /**
+     * Will be run after the connection is created and the server sends
+     * a greeting. If the incoming message starts with 220 initiate
+     * SMTP session by sending EHLO command
+     *
+     * @param str Message from the server
+     */
+    _actionGreeting(str: string): void;
+    /**
+     * Handles server response for LHLO command. If it yielded in
+     * error, emit 'error', otherwise treat this as an EHLO response
+     *
+     * @param str Message from the server
+     */
+    _actionLHLO(str: string): void;
+    /**
+     * Handles server response for EHLO command. If it yielded in
+     * error, try HELO instead, otherwise initiate TLS negotiation
+     * if STARTTLS is supported by the server or move into the
+     * authentication phase.
+     *
+     * @param str Message from the server
+     */
+    _actionEHLO(str: string): void;
+    /**
+     * Handles server response for HELO command. If it yielded in
+     * error, emit 'error', otherwise move into the authentication phase.
+     *
+     * @param str Message from the server
+     */
+    _actionHELO(str: string): void;
+    /**
+     * Handles server response for STARTTLS command. If there's an error
+     * try HELO instead, otherwise initiate TLS upgrade. If the upgrade
+     * succeedes restart the EHLO
+     *
+     * @param str Message from the server
+     */
+    _actionSTARTTLS(str: string): void;
+    /**
+     * Handle the response for AUTH LOGIN command. We are expecting
+     * '334 VXNlcm5hbWU6' (base64 for 'Username:'). Data to be sent as
+     * response needs to be base64 encoded username. We do not need
+     * exact match but settle with 334 response in general as some
+     * hosts invalidly use a longer message than VXNlcm5hbWU6
+     *
+     * @param str Message from the server
+     */
+    _actionAUTH_LOGIN_USER(str: string, callback: SMTPConnectionCallback): void;
+    /**
+     * Handle the response for AUTH CRAM-MD5 command. We are expecting
+     * '334 <challenge string>'. Data to be sent as response needs to be
+     * base64 decoded challenge string, MD5 hashed using the password as
+     * a HMAC key, prefixed by the username and a space, and finally all
+     * base64 encoded again.
+     *
+     * @param str Message from the server
+     */
+    _actionAUTH_CRAM_MD5(str: string, callback: SMTPConnectionCallback): void;
+    /**
+     * Handles the response to CRAM-MD5 authentication, if there's no error,
+     * the user can be considered logged in. Start waiting for a message to send
+     *
+     * @param str Message from the server
+     */
+    _actionAUTH_CRAM_MD5_PASS(str: string, callback: SMTPConnectionCallback): void;
+    /**
+     * Handle the response for AUTH LOGIN command. We are expecting
+     * '334 UGFzc3dvcmQ6' (base64 for 'Password:'). Data to be sent as
+     * response needs to be base64 encoded password.
+     *
+     * @param str Message from the server
+     */
+    _actionAUTH_LOGIN_PASS(str: string, callback: SMTPConnectionCallback): void;
+    /**
+     * Handles the response for authentication, if there's no error,
+     * the user can be considered logged in. Start waiting for a message to send
+     *
+     * @param str Message from the server
+     */
+    _actionAUTHComplete(str: string, isRetry: boolean | SMTPConnectionCallback, callback?: SMTPConnectionCallback): void;
+    /**
+     * Handle response for a MAIL FROM: command
+     *
+     * @param str Message from the server
+     */
+    _actionMAIL(str: string, callback: SMTPConnectionSendCallback): void;
+    /**
+     * Handle response for a RCPT TO: command
+     *
+     * @param str Message from the server
+     */
+    _actionRCPT(str: string, callback: SMTPConnectionSendCallback): void;
+    /**
+     * Handle response for a DATA command
+     *
+     * @param str Message from the server
+     */
+    _actionDATA(str: string, callback: SMTPConnectionSendCallback): void;
+    /**
+     * Handle response for a DATA stream when using SMTP
+     * We expect a single response that defines if the sending succeeded or failed
+     *
+     * @param str Message from the server
+     */
+    _actionSMTPStream(str: string, callback: SMTPConnectionResponseCallback): void;
+    /**
+     * Handle response for a DATA stream
+     * We expect a separate response for every recipient. All recipients can either
+     * succeed or fail separately
+     *
+     * @param recipient The recipient this response applies to
+     * @param final Is this the final recipient?
+     * @param str Message from the server
+     */
+    _actionLMTPStream(recipient: string, final: boolean, str: string, callback: SMTPConnectionResponseCallback): void;
+    _handleXOauth2Token(isRetry: boolean, callback: SMTPConnectionCallback): void;
+    /**
+     *
+     * @param command
+     * @private
+     */
+    _isDestroyedMessage(command: string): string | undefined;
+    _getHostname(): string;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `SMTPConnection.Options` style references keep working
+ */
+declare namespace SMTPConnection {
+    type Options = SMTPConnectionOptions;
+    type AuthenticationType = SMTPConnectionAuth;
+    type Credentials = SMTPConnectionCredentials;
+    type Envelope = SMTPEnvelope;
+    type DSNOptions = SMTPEnvelopeDsn;
+    type SentMessageInfo = SMTPConnectionSendInfo;
+    type CustomAuthenticationContext = SMTPConnectionCustomAuthContext;
+    type CustomAuthenticationResponse = SMTPConnectionCustomAuthResponse;
+    type CustomAuthenticationHandlers = SMTPConnectionCustomAuthHandlers;
+}
+export default SMTPConnection;