@mavogel/awscdk-rootmail 0.1.4 → 0.1.5

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

@@ -1,7 +1,6 @@
 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';
@@ -17,83 +16,83 @@ export type SMTPConnectionCustomAuthHandlers = {
  */
 export interface SMTPConnectionOptions {
     /** Port to connect to, defaults to 587, or to 465 when secure is set */
-    port?: number | string;
+    port?: number | string | undefined;
     /** Hostname or IP address to connect to, defaults to 'localhost' */
-    host?: string;
+    host?: string | undefined;
     /** Use TLS from the start */
-    secure?: boolean;
+    secure?: boolean | undefined;
     /** Marks the provided socket as already upgraded to TLS */
-    secured?: boolean;
+    secured?: boolean | undefined;
     /** Server name for SNI, defaults to host when that is not an IP address */
-    servername?: string;
+    servername?: string | undefined;
     /** Ignore STARTTLS even when the server advertises it */
-    ignoreTLS?: boolean;
+    ignoreTLS?: boolean | undefined;
     /** Force STARTTLS, fail when the server does not support it */
-    requireTLS?: boolean;
+    requireTLS?: boolean | undefined;
     /** Continue unencrypted when the STARTTLS upgrade fails */
-    opportunisticTLS?: boolean;
+    opportunisticTLS?: boolean | undefined;
     /** Name of the client server, sent with EHLO/HELO, CRLF is stripped */
-    name?: string;
+    name?: string | undefined;
     /** Outbound address to bind to */
-    localAddress?: string;
+    localAddress?: string | undefined;
     /** Time to wait in ms for the connection to establish, defaults to 2 minutes */
-    connectionTimeout?: number;
+    connectionTimeout?: number | undefined;
     /** Time to wait in ms until the greeting is received, defaults to 30 seconds */
-    greetingTimeout?: number;
+    greetingTimeout?: number | undefined;
     /** Time of inactivity in ms until the connection is closed, defaults to 10 minutes */
-    socketTimeout?: number;
+    socketTimeout?: number | undefined;
     /** Time to wait in ms for the DNS requests to be resolved, defaults to 30 seconds */
-    dnsTimeout?: number;
+    dnsTimeout?: number | undefined;
     /** Use LMTP instead of SMTP */
-    lmtp?: boolean;
+    lmtp?: boolean | undefined;
     /** Bunyan compatible logger interface, true for the default console logger */
-    logger?: shared.ExternalLogger | boolean;
+    logger?: shared.ExternalLogger | boolean | undefined;
     /** Pass SMTP traffic, including the message data, to the logger */
-    debug?: boolean;
+    debug?: boolean | undefined;
     /** Pass SMTP commands and responses to the logger */
-    transactionLog?: boolean;
+    transactionLog?: boolean | undefined;
     /** Options for tls.connect */
-    tls?: tls.ConnectionOptions;
+    tls?: tls.ConnectionOptions | undefined;
     /** Existing socket to use instead of creating a new one, not connected yet */
-    socket?: net.Socket;
+    socket?: net.Socket | undefined;
     /** Already opened connection to use instead of creating a new one */
-    connection?: net.Socket;
+    connection?: net.Socket | undefined;
     /** Count loopback interfaces when checking which address families are usable */
-    allowInternalNetworkInterfaces?: boolean;
+    allowInternalNetworkInterfaces?: boolean | undefined;
     /** Logger component name, defaults to 'smtp-connection' */
-    component?: string;
+    component?: string | undefined;
     /** Custom authentication handlers keyed by method name */
-    customAuth?: SMTPConnectionCustomAuthHandlers;
+    customAuth?: SMTPConnectionCustomAuthHandlers | undefined;
 }
 /**
  * User and password credentials resolved for a SASL mechanism
  */
 export interface SMTPConnectionCredentials {
-    user?: string;
-    pass?: string;
+    user?: string | undefined;
+    pass?: string | undefined;
     /** Extra options for the authentication method, copied from the auth object */
     options?: {
         [key: string]: any;
-    };
+    } | undefined;
 }
 /**
  * Authentication data for login()
  */
 export interface SMTPConnectionAuth {
     /** Authentication type, informational */
-    type?: string;
+    type?: string | undefined;
     /** SASL method to use, false or unset picks the first supported one (PLAIN if none is advertised) */
-    method?: string | false;
-    user?: string;
-    pass?: string;
+    method?: string | false | undefined;
+    user?: string | undefined;
+    pass?: string | undefined;
     /** Extra options for the authentication method */
     options?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** XOAuth2 token generator, selects XOAUTH2 when no method is set */
-    oauth2?: XOAuth2;
+    oauth2?: XOAuth2 | undefined;
     /** Credentials for the SASL mechanism, filled in from user and pass when missing */
-    credentials?: SMTPConnectionCredentials;
+    credentials?: SMTPConnectionCredentials | undefined;
     /** Custom authentication handlers receive the auth object as is, so it may carry any other value */
     [key: string]: any;
 }
@@ -108,7 +107,7 @@ export interface SMTPConnectionCustomAuthResponse {
     /** Numeric status code, 0 if the response did not start with one */
     status: number;
     /** Enhanced status code, if any */
-    code?: string;
+    code?: string | undefined;
     /** Response text without the status codes */
     text: string;
 }
@@ -145,52 +144,52 @@ export type SMTPConnectionCustomAuthHandler = (ctx: SMTPConnectionCustomAuthCont
  * An envelope address, either a plain string or an object with an address property
  */
 export interface SMTPEnvelopeAddress {
-    address?: string;
-    name?: string;
+    address?: string | undefined;
+    name?: string | undefined;
 }
 /**
  * DSN parameters for the envelope (RFC 3461)
  */
 export interface SMTPEnvelopeDsn {
     /** Return either 'HDRS' (headers) or 'FULL' (body) with the notification */
-    ret?: string | null;
+    ret?: string | null | undefined;
     /** Alias of ret */
-    return?: string;
+    return?: string | undefined;
     /** Envelope identifier, sent as ENVID */
-    envid?: string | null;
+    envid?: string | null | undefined;
     /** Alias of envid */
-    id?: string;
+    id?: string | undefined;
     /** When to notify: 'NEVER', or any combination of 'SUCCESS', 'FAILURE' and 'DELAY' */
-    notify?: string | string[] | null;
+    notify?: string | string[] | null | undefined;
     /** Original recipient, sent as ORCPT */
-    recipient?: string;
+    recipient?: string | undefined;
     /** Alias of recipient, in the 'rfc822;address' form */
-    orcpt?: string | null;
+    orcpt?: string | null | undefined;
 }
 /**
  * Envelope object accepted by send()
  */
 export interface SMTPEnvelope {
     /** Sender address */
-    from?: string | SMTPEnvelopeAddress;
+    from?: string | SMTPEnvelopeAddress | undefined;
     /** Recipient address or addresses */
-    to?: string | SMTPEnvelopeAddress | Array<string | SMTPEnvelopeAddress>;
+    to?: string | SMTPEnvelopeAddress | Array<string | SMTPEnvelopeAddress> | undefined;
     /** Message size in bytes, sent as the SIZE parameter when the server supports it */
-    size?: number | string;
+    size?: number | string | undefined;
     /** DSN parameters, sent when the server supports the DSN extension */
-    dsn?: SMTPEnvelopeDsn;
+    dsn?: SMTPEnvelopeDsn | undefined;
     /** Declare BODY=8BITMIME when the server supports it */
-    use8BitMime?: boolean;
+    use8BitMime?: boolean | undefined;
     /** RFC 8689: send the REQUIRETLS parameter, requires a TLS connection and server support */
-    requireTLSExtensionEnabled?: boolean;
+    requireTLSExtensionEnabled?: boolean | undefined;
 }
 /**
  * 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[];
+    from?: string | undefined;
+    to?: string[] | undefined;
     /** Recipients still waiting for RCPT TO */
     rcptQueue: string[];
     /** Recipients the server rejected */
@@ -209,17 +208,17 @@ export interface SMTPConnectionSendInfo {
     /** Recipients the server rejected */
     rejected: string[];
     /** EHLO response lines, without the greeting line */
-    ehlo?: string[];
+    ehlo?: string[] | undefined;
     /** Errors for the rejected recipients */
-    rejectedErrors?: NodemailerError[];
+    rejectedErrors?: NodemailerError[] | undefined;
     /** Time in ms spent on the envelope commands */
-    envelopeTime?: number;
+    envelopeTime?: number | undefined;
     /** Time in ms spent on streaming the message */
-    messageTime?: number;
+    messageTime?: number | undefined;
     /** Size of the encoded message in bytes */
-    messageSize?: number;
+    messageSize?: number | undefined;
     /** Final server response for the message */
-    response?: string;
+    response?: string | undefined;
 }
 /**
  * Callback for send()
@@ -244,11 +243,11 @@ export interface SMTPConnectionConnectOptions extends tls.ConnectionOptions {
     port: number;
     host: string;
     /** Outbound address to bind to */
-    localAddress?: string;
+    localAddress?: string | undefined;
     /** Count loopback interfaces when resolving the hostname */
-    allowInternalNetworkInterfaces?: boolean;
+    allowInternalNetworkInterfaces?: boolean | undefined;
     /** DNS lookup timeout in ms */
-    timeout?: number;
+    timeout?: number | undefined;
 }
 /**
  * A queued handler for the next server response
@@ -313,167 +312,28 @@ declare class SMTPConnection extends EventEmitter {
      * @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;
+    upgrading?: boolean | undefined;
     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
      */
@@ -500,207 +360,6 @@ declare class SMTPConnection extends EventEmitter {
      * @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