@mavogel/awscdk-rootmail 0.1.4 → 0.1.6

package/node_modules/nodemailer/dist/esm/smtp-connection/index.js

@@ -13,6 +13,9 @@ const SOCKET_TIMEOUT = 10 * 60 * 1000; // how much to wait for socket inactivity
 const GREETING_TIMEOUT = 30 * 1000; // how much to wait after connection is established but SMTP greeting is not receieved
 const DNS_TIMEOUT = 30 * 1000; // how much to wait for resolveHostname
 const TEARDOWN_NOOP = () => { }; // reusable no-op handler for absorbing errors during socket teardown
+// how many bytes a single server response may occupy while it is still being received.
+// Generous compared to any real reply, it only stops a peer that never completes one
+const MAX_RESPONSE_SIZE = 1024 * 1024;
 /**
  * Re-interpret a server response stored in fake 8-bit byte-container form
  * (the result of chunk.toString('binary') in _onData) as UTF-8.
@@ -41,11 +44,19 @@ function decodeServerResponse(str) {
  * Called with the byte-container form the queue holds (see _onData): the check only looks
  * at leading ASCII digits and '-' of the last line, and a UTF-8 continuation byte is never
  * 0x0A, so line boundaries and the tested prefix are the same before and after decoding.
- * The last line is read with lastIndexOf rather than split() because a queue entry grows
- * with every chunk appended to it and only its final line matters.
+ * The last line is read with lastIndexOf rather than split() because a queue entry may hold
+ * a whole multiline reply and only its final line matters.
  */
 function isPartialResponse(str) {
-    return /^\d+-/.test(str.slice(str.lastIndexOf('\n') + 1));
+    return isPartialLine(str.slice(str.lastIndexOf('\n') + 1));
+}
+/**
+ * True when a single reply line is a continuation ("250-..."). Used where the line is
+ * already known to be one line, which skips the scan isPartialResponse needs to find the
+ * last line of a whole reply.
+ */
+function isPartialLine(line) {
+    return /^\d+-/.test(line);
 }
 /**
  * Generates a SMTP connection object
@@ -62,6 +73,7 @@ function isPartialResponse(str) {
  *  * **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)
+ *  * **maxResponseSize** - Largest single server response to accept in bytes (defaults to 1 MB)
  *  * **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
@@ -108,6 +120,7 @@ class SMTPConnection extends EventEmitter {
         this.secure = !!this.secureConnection;
         this._remainder = '';
         this._responseQueue = [];
+        this._responsePartial = false;
         this.lastServerResponse = false;
         this._socket = false;
         this._supportedAuth = [];
@@ -225,6 +238,7 @@ class SMTPConnection extends EventEmitter {
      *
      * @param opts Connection options (modified in place)
      * @param callback Called with resolved data on success
+     * @internal
      */
     _resolveAndConnect(opts, callback) {
         return shared.resolveHostname(opts, (err, resolved) => {
@@ -250,6 +264,7 @@ class SMTPConnection extends EventEmitter {
      *
      * @param opts Connection options
      * @param secure Whether to use TLS
+     * @internal
      */
     _connectToHost(opts, secure) {
         // If the client was closed while DNS resolution was in flight, do not open
@@ -282,6 +297,7 @@ class SMTPConnection extends EventEmitter {
     }
     /**
      * Sets up connection timeout and error handlers
+     * @internal
      */
     _setupConnectionHandlers() {
         this._connectionTimeout = setTimeout(() => {
@@ -294,6 +310,7 @@ class SMTPConnection extends EventEmitter {
      *
      * @param err Error object or message
      * @param code Error code
+     * @internal
      */
     _onConnectionError(err, code) {
         clearTimeout(this._connectionTimeout);
@@ -617,6 +634,7 @@ class SMTPConnection extends EventEmitter {
      * the server is opened
      *
      * @event
+     * @internal
      */
     _onConnect() {
         const socket = this._socket;
@@ -665,39 +683,71 @@ class SMTPConnection extends EventEmitter {
      *
      * @event
      * @param chunk Data chunk coming from the server
+     * @internal
      */
     _onData(chunk) {
         if (this._destroyed || !chunk || !chunk.length) {
             return;
         }
-        let data = chunk.toString('binary');
-        let lines = (this._remainder + data).split(/\r?\n/);
-        let lastline;
+        const maxResponseSize = this.options.maxResponseSize || MAX_RESPONSE_SIZE;
+        const data = chunk.toString('binary');
+        // A chunk without a line break only extends the line currently being received, so
+        // keep it in the remainder and leave that string unflattened. Splitting the whole
+        // remainder again on every chunk would rescan everything buffered for that line so
+        // far, which is quadratic in the length of a line the peer never terminates
+        if (!data.includes('\n')) {
+            this._remainder += data;
+            if (this._remainder.length > maxResponseSize) {
+                return this._onResponseTooLarge();
+            }
+            return;
+        }
+        const lines = (this._remainder + data).split(/\r?\n/);
         this._remainder = lines.pop();
         for (let i = 0, len = lines.length; i < len; i++) {
-            if (this._responseQueue.length) {
-                lastline = this._responseQueue[this._responseQueue.length - 1];
-                if (isPartialResponse(lastline)) {
-                    this._responseQueue[this._responseQueue.length - 1] += '\n' + lines[i];
-                    continue;
-                }
+            if (this._responsePartial) {
+                this._responseQueue[this._responseQueue.length - 1] += '\n' + lines[i];
             }
-            this._responseQueue.push(lines[i]);
-        }
-        if (this._responseQueue.length) {
-            lastline = this._responseQueue[this._responseQueue.length - 1];
-            if (isPartialResponse(lastline)) {
-                return;
+            else {
+                this._responseQueue.push(lines[i]);
             }
+            // The line just added is the last line of that queue entry, so it alone decides
+            // whether the reply is still partial. Looking for the last line of the accumulated
+            // entry instead would rescan a string that grows with every continuation line,
+            // which is quadratic in the size of the reply
+            this._responsePartial = isPartialLine(lines[i]);
+            // Checked as each line lands, so a peer that never completes a reply cannot keep
+            // buffering, and the limit does not depend on how it split its bytes into chunks
+            if (this._responsePartial && this._responseQueue[this._responseQueue.length - 1].length > maxResponseSize) {
+                return this._onResponseTooLarge();
+            }
+        }
+        if (this._remainder.length > maxResponseSize) {
+            return this._onResponseTooLarge();
+        }
+        if (this._responsePartial) {
+            return;
         }
         this._processResponse();
     }
+    /**
+     * Drops a connection whose peer keeps extending a reply it never completes, releasing
+     * whatever was buffered for that reply
+     * @internal
+     */
+    _onResponseTooLarge() {
+        this._remainder = '';
+        this._responseQueue = [];
+        this._responsePartial = false;
+        this._onError(new Error('Server response exceeds maximum allowed size'), 'EPROTOCOL', false, 'CONN');
+    }
     /**
      * 'error' listener for the socket
      *
      * @event
      * @param err Error object
      * @param type Error name
+     * @internal
      */
     _onError(err, type, data, command) {
         clearTimeout(this._connectionTimeout);
@@ -719,6 +769,7 @@ class SMTPConnection extends EventEmitter {
         this.emit('error', err);
         this.close();
     }
+    /** @internal */
     _formatError(message, type, response, command) {
         let err;
         if (/Error\]$/i.test(Object.prototype.toString.call(message))) {
@@ -747,6 +798,7 @@ class SMTPConnection extends EventEmitter {
      * 'close' listener for the socket
      *
      * @event
+     * @internal
      */
     _onClose() {
         let serverResponse = false;
@@ -776,6 +828,7 @@ class SMTPConnection extends EventEmitter {
      * 'end' listener for the socket
      *
      * @event
+     * @internal
      */
     _onEnd() {
         if (this._socket && !this._socket.destroyed) {
@@ -788,12 +841,14 @@ class SMTPConnection extends EventEmitter {
      * 'timeout' listener for the socket
      *
      * @event
+     * @internal
      */
     _onTimeout() {
         return this._onError(new Error('Timeout'), 'ETIMEDOUT', false, 'CONN');
     }
     /**
      * Destroys the client, emits 'end'
+     * @internal
      */
     _destroy() {
         if (this._destroyed) {
@@ -815,6 +870,7 @@ class SMTPConnection extends EventEmitter {
      *
      * @param callback Callback function to run when the connection
      *        has been secured
+     * @internal
      */
     _upgradeConnection(callback) {
         // RFC 3207 section 6: the client MUST discard any knowledge obtained from
@@ -825,6 +881,7 @@ class SMTPConnection extends EventEmitter {
         // part of the secured EHLO capabilities). STARTTLS response injection.
         this._remainder = '';
         this._responseQueue = [];
+        this._responsePartial = false;
         // do not remove all listeners or it breaks node v0.10 as there's
         // apparently a 'finish' event set that would be cleared as well
         // we can safely keep 'error', 'end', 'close' etc. events
@@ -875,6 +932,7 @@ class SMTPConnection extends EventEmitter {
     }
     /**
      * Processes queued responses from the server
+     * @internal
      */
     _processResponse() {
         if (!this._responseQueue.length) {
@@ -914,6 +972,7 @@ class SMTPConnection extends EventEmitter {
      *
      * @param str String to be sent to the server
      * @param logStr Optional string to be used for logging instead of the actual string
+     * @internal
      */
     _sendCommand(str, logStr) {
         if (this._destroyed) {
@@ -939,6 +998,7 @@ class SMTPConnection extends EventEmitter {
      *        {from:'...', to:['...']}
      *        or
      *        {from:{address:'...',name:'...'}, to:[address:'...',name:'...']}
+     * @internal
      */
     _setEnvelope(envelope, callback) {
         const args = [];
@@ -1035,6 +1095,7 @@ class SMTPConnection extends EventEmitter {
         }
         this._sendCommand('MAIL FROM:<' + this._envelope.from + '>' + (args.length ? ' ' + args.join(' ') : ''));
     }
+    /** @internal */
     _setDsnEnvelope(params) {
         let ret = (params.ret || params.return || '').toString().toUpperCase() || null;
         if (ret) {
@@ -1077,6 +1138,7 @@ class SMTPConnection extends EventEmitter {
             orcpt
         };
     }
+    /** @internal */
     _getDsnRcptToArgs() {
         const envelope = this._envelope;
         const args = [];
@@ -1092,6 +1154,7 @@ class SMTPConnection extends EventEmitter {
         }
         return args.length ? ' ' + args.join(' ') : '';
     }
+    /** @internal */
     _createSendStream(callback) {
         const envelope = this._envelope;
         const dataStream = new DataStream();
@@ -1143,6 +1206,7 @@ class SMTPConnection extends EventEmitter {
      * SMTP session by sending EHLO command
      *
      * @param str Message from the server
+     * @internal
      */
     _actionGreeting(str) {
         clearTimeout(this._greetingTimeout);
@@ -1164,6 +1228,7 @@ class SMTPConnection extends EventEmitter {
      * error, emit 'error', otherwise treat this as an EHLO response
      *
      * @param str Message from the server
+     * @internal
      */
     _actionLHLO(str) {
         if (str.charAt(0) !== '2') {
@@ -1179,6 +1244,7 @@ class SMTPConnection extends EventEmitter {
      * authentication phase.
      *
      * @param str Message from the server
+     * @internal
      */
     _actionEHLO(str) {
         let match;
@@ -1259,6 +1325,7 @@ class SMTPConnection extends EventEmitter {
      * error, emit 'error', otherwise move into the authentication phase.
      *
      * @param str Message from the server
+     * @internal
      */
     _actionHELO(str) {
         if (str.charAt(0) !== '2') {
@@ -1275,6 +1342,7 @@ class SMTPConnection extends EventEmitter {
      * succeedes restart the EHLO
      *
      * @param str Message from the server
+     * @internal
      */
     _actionSTARTTLS(str) {
         if (str.charAt(0) !== '2') {
@@ -1320,6 +1388,7 @@ class SMTPConnection extends EventEmitter {
      * hosts invalidly use a longer message than VXNlcm5hbWU6
      *
      * @param str Message from the server
+     * @internal
      */
     _actionAUTH_LOGIN_USER(str, callback) {
         if (!/^334[ -]/.test(str)) {
@@ -1340,6 +1409,7 @@ class SMTPConnection extends EventEmitter {
      * base64 encoded again.
      *
      * @param str Message from the server
+     * @internal
      */
     _actionAUTH_CRAM_MD5(str, callback) {
         const challengeMatch = str.match(/^334\s+(.+)$/);
@@ -1363,6 +1433,7 @@ class SMTPConnection extends EventEmitter {
      * the user can be considered logged in. Start waiting for a message to send
      *
      * @param str Message from the server
+     * @internal
      */
     _actionAUTH_CRAM_MD5_PASS(str, callback) {
         if (!str.match(/^235\s+/)) {
@@ -1383,6 +1454,7 @@ class SMTPConnection extends EventEmitter {
      * response needs to be base64 encoded password.
      *
      * @param str Message from the server
+     * @internal
      */
     _actionAUTH_LOGIN_PASS(str, callback) {
         if (!/^334[ -]/.test(str)) {
@@ -1401,6 +1473,7 @@ class SMTPConnection extends EventEmitter {
      * the user can be considered logged in. Start waiting for a message to send
      *
      * @param str Message from the server
+     * @internal
      */
     _actionAUTHComplete(str, isRetry, callback) {
         if (!callback && typeof isRetry === 'function') {
@@ -1442,6 +1515,7 @@ class SMTPConnection extends EventEmitter {
      * Handle response for a MAIL FROM: command
      *
      * @param str Message from the server
+     * @internal
      */
     _actionMAIL(str, callback) {
         const envelope = this._envelope;
@@ -1469,6 +1543,7 @@ class SMTPConnection extends EventEmitter {
      * Handle response for a RCPT TO: command
      *
      * @param str Message from the server
+     * @internal
      */
     _actionRCPT(str, callback) {
         const envelope = this._envelope;
@@ -1515,6 +1590,7 @@ class SMTPConnection extends EventEmitter {
      * Handle response for a DATA command
      *
      * @param str Message from the server
+     * @internal
      */
     _actionDATA(str, callback) {
         const envelope = this._envelope;
@@ -1540,6 +1616,7 @@ class SMTPConnection extends EventEmitter {
      * We expect a single response that defines if the sending succeeded or failed
      *
      * @param str Message from the server
+     * @internal
      */
     _actionSMTPStream(str, callback) {
         if (Number(str.charAt(0)) !== 2) {
@@ -1555,6 +1632,7 @@ class SMTPConnection extends EventEmitter {
      * @param recipient The recipient this response applies to
      * @param final Is this the final recipient?
      * @param str Message from the server
+     * @internal
      */
     _actionLMTPStream(recipient, final, str, callback) {
         const envelope = this._envelope;
@@ -1575,6 +1653,7 @@ class SMTPConnection extends EventEmitter {
             return callback(null, str);
         }
     }
+    /** @internal */
     _handleXOauth2Token(isRetry, callback) {
         this._auth.oauth2.getToken(isRetry, (err, accessToken) => {
             if (err) {
@@ -1597,7 +1676,7 @@ class SMTPConnection extends EventEmitter {
     /**
      *
      * @param command
-     * @private
+     * @internal
      */
     _isDestroyedMessage(command) {
         if (this._destroyed) {
@@ -1612,6 +1691,7 @@ class SMTPConnection extends EventEmitter {
             }
         }
     }
+    /** @internal */
     _getHostname() {
         // defaul hostname is machine hostname or [IP]
         let defaultHostname;

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

@@ -1,5 +1,4 @@
 import { EventEmitter } from 'node:events';
-import PoolResource from './pool-resource.js';
 import * as shared from '../shared/index.js';
 import type { SMTPTransportOptions, SMTPTransportGetSocketCallback, SMTPTransportSendCallback, SMTPSentMessageInfo } from '../smtp-transport/index.js';
 import type MailMessage from '../mailer/mail-message.js';
@@ -9,17 +8,17 @@ import type { default as Mail, SendMailOptions, VerifyCallback } from '../mailer
  */
 export interface SMTPPoolOptions extends SMTPTransportOptions {
     /** Set to true to get this pooled transport from createTransport */
-    pool?: boolean;
+    pool?: boolean | undefined;
     /** Maximum number of open connections, defaults to 5 */
-    maxConnections?: number;
+    maxConnections?: number | undefined;
     /** Number of messages a connection sends before it is closed and replaced, defaults to 100 */
-    maxMessages?: number;
+    maxMessages?: number | undefined;
     /** Maximum number of messages to send in rateDelta milliseconds, unlimited when not set */
-    rateLimit?: number;
+    rateLimit?: number | undefined;
     /** Time window for rateLimit in milliseconds, defaults to 1000 */
-    rateDelta?: number;
+    rateDelta?: number | undefined;
     /** How many times a message is requeued when its connection closes while sending, unlimited when not set or negative */
-    maxRequeues?: number;
+    maxRequeues?: number | undefined;
 }
 /**
  * The pool options once the constructor has applied the defaults
@@ -47,7 +46,7 @@ export interface SMTPPoolQueueEntry {
     /** Callback to run once the message is sent or failed */
     callback: SMTPPoolSendCallback;
     /** Message-ID value without the angle brackets, set when the entry is assigned to a connection */
-    messageId?: string;
+    messageId?: string | undefined;
 }
 /**
  * Rate limiter state of the pool
@@ -77,16 +76,11 @@ declare class SMTPPool extends EventEmitter {
     logger: shared.Logger;
     name: string;
     version: string;
-    _rateLimit: SMTPPoolRateLimit;
-    _closed: boolean;
-    _queue: SMTPPoolQueueEntry[];
-    _connections: PoolResource[];
-    _connectionCounter: number;
     idling: boolean;
     /**
      * The Mail instance using this transport, assigned by Mail
      */
-    mailer?: Mail<SMTPPoolSentMessageInfo>;
+    mailer?: Mail<SMTPPoolSentMessageInfo> | undefined;
     constructor(options?: SMTPPoolOptions | string);
     /**
      * Placeholder function for creating proxy sockets. This method immediatelly returns
@@ -108,38 +102,6 @@ declare class SMTPPool extends EventEmitter {
      * is closed later
      */
     close(): void;
-    /**
-     * Check the queue and available connections. If there is a message to be sent and there is
-     * an available connection, then use this connection to send the mail
-     */
-    _processMessages(): void;
-    /**
-     * Creates a new pool resource
-     */
-    _createConnection(): PoolResource;
-    _shouldRequeuOnConnectionClose(queueEntry: SMTPPoolQueueEntry): boolean;
-    _failDeliveryOnConnectionClose(connection: PoolResource): void;
-    _requeueEntryOnConnectionClose(connection: PoolResource): void;
-    /**
-     * Continue to process message if the pool hasn't closed
-     */
-    _continueProcessing(): void;
-    /**
-     * Remove resource from pool
-     *
-     * @param connection The PoolResource to remove
-     */
-    _removeConnection(connection: PoolResource): void;
-    /**
-     * Checks if connections have hit current rate limit and if so, queues the availability callback
-     *
-     * @param callback Callback function to run once rate limiter has been cleared
-     */
-    _checkRateLimit(callback: () => void): void;
-    /**
-     * Clears current rate limit limitation and runs paused callback
-     */
-    _clearRateLimit(): void;
     /**
      * Returns true if there are free slots in the queue
      */

package/node_modules/nodemailer/dist/esm/smtp-pool/index.js

@@ -100,8 +100,10 @@ class SMTPPool extends EventEmitter {
         let connection;
         const len = this._connections.length;
         this._closed = true;
-        // clear rate limit timer if it exists
-        clearTimeout(this._rateLimit.timeout);
+        // release connections gated by the rate limiter so they become
+        // available and are torn down below instead of leaking with a
+        // cleared timer that never fires
+        this._clearRateLimit();
         if (!len && !this._queue.length) {
             return;
         }
@@ -153,6 +155,7 @@ class SMTPPool extends EventEmitter {
     /**
      * Check the queue and available connections. If there is a message to be sent and there is
      * an available connection, then use this connection to send the mail
+     * @internal
      */
     _processMessages() {
         // do nothing if already closed
@@ -217,6 +220,7 @@ class SMTPPool extends EventEmitter {
     }
     /**
      * Creates a new pool resource
+     * @internal
      */
     _createConnection() {
         const connection = new PoolResource(this);
@@ -309,12 +313,14 @@ class SMTPPool extends EventEmitter {
         this._connections.push(connection);
         return connection;
     }
+    /** @internal */
     _shouldRequeuOnConnectionClose(queueEntry) {
         if (this.options.maxRequeues === undefined || this.options.maxRequeues < 0) {
             return true;
         }
         return queueEntry.requeueAttempts < this.options.maxRequeues;
     }
+    /** @internal */
     _failDeliveryOnConnectionClose(connection) {
         if (connection.queueEntry && connection.queueEntry.callback) {
             try {
@@ -331,6 +337,7 @@ class SMTPPool extends EventEmitter {
             connection.queueEntry = false;
         }
     }
+    /** @internal */
     _requeueEntryOnConnectionClose(connection) {
         connection.queueEntry.requeueAttempts += 1;
         this.logger.debug({
@@ -344,6 +351,7 @@ class SMTPPool extends EventEmitter {
     }
     /**
      * Continue to process message if the pool hasn't closed
+     * @internal
      */
     _continueProcessing() {
         if (this._closed) {
@@ -357,6 +365,7 @@ class SMTPPool extends EventEmitter {
      * Remove resource from pool
      *
      * @param connection The PoolResource to remove
+     * @internal
      */
     _removeConnection(connection) {
         const index = this._connections.indexOf(connection);
@@ -368,6 +377,7 @@ class SMTPPool extends EventEmitter {
      * Checks if connections have hit current rate limit and if so, queues the availability callback
      *
      * @param callback Callback function to run once rate limiter has been cleared
+     * @internal
      */
     _checkRateLimit(callback) {
         if (!this._rateLimit.limit) {
@@ -388,6 +398,7 @@ class SMTPPool extends EventEmitter {
     }
     /**
      * Clears current rate limit limitation and runs paused callback
+     * @internal
      */
     _clearRateLimit() {
         clearTimeout(this._rateLimit.timeout);

package/node_modules/nodemailer/dist/esm/smtp-pool/pool-resource.d.ts

@@ -26,9 +26,7 @@ export default class PoolResource extends EventEmitter {
     /**
      * Authentication data for the connection, set when the pool options include auth
      */
-    auth?: SMTPTransportAuth;
-    _connection: boolean;
-    _connected: boolean;
+    auth?: SMTPTransportAuth | undefined;
     messages: number;
     available: boolean;
     /**
@@ -42,7 +40,7 @@ export default class PoolResource extends EventEmitter {
     /**
      * The queue entry being sent, assigned by the pool. False once it has been handled
      */
-    queueEntry?: SMTPPoolQueueEntry | false;
+    queueEntry?: SMTPPoolQueueEntry | false | undefined;
     constructor(pool: SMTPPool);
     /**
      * Initiates a connection to the SMTP server

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

@@ -12,19 +12,19 @@ import type { MimeNodeEnvelope } from '../mime-node/index.js';
  */
 export interface SMTPTransportAuthOptions extends XOAuth2Options {
     /** 'OAuth2' selects XOAUTH2, anything else is a password login, 'LOGIN' when not set */
-    type?: string;
+    type?: string | undefined;
     /** Username */
-    user?: string;
+    user?: string | undefined;
     /** Password */
-    pass?: string;
+    pass?: string | undefined;
     /** SASL method to use, e.g. 'PLAIN', 'LOGIN' or 'CRAM-MD5' */
-    method?: string;
+    method?: string | undefined;
     /** Extra options for the authentication method, handed to a custom SASL handler */
     options?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** Service identifier, an OAuth2 login needs either this or a user */
-    service?: string;
+    service?: string | undefined;
 }
 /**
  * Authentication data built by getAuth() and handed to SMTPConnection#login
@@ -50,21 +50,21 @@ export type SMTPTransportGetSocket = (options: SMTPTransportOptions, callback: S
  */
 export interface SMTPTransportOptions extends SMTPConnectionOptions, TransportOptions {
     /** Well-known service name, e.g. 'Gmail', fills in host, port and secure */
-    service?: string;
+    service?: string | undefined;
     /** Connection url, e.g. 'smtps://user:pass@smtp.example.com', parsed into options */
-    url?: string;
+    url?: string | undefined;
     /** Authentication settings, no authentication when not set */
-    auth?: SMTPTransportAuthOptions;
+    auth?: SMTPTransportAuthOptions | undefined;
     /** Custom socket provider, e.g. for connecting through a proxy, replaces the getSocket method */
-    getSocket?: SMTPTransportGetSocket;
+    getSocket?: SMTPTransportGetSocket | undefined;
     /** Authenticate even when the server does not advertise AUTH, and fail verify() when it does but no credentials were given */
-    forceAuth?: boolean;
+    forceAuth?: boolean | undefined;
     /** Default SASL method for the password logins when the auth settings do not name one */
-    authMethod?: string;
+    authMethod?: string | undefined;
     /** Logger component name, defaults to 'smtp-transport' */
-    component?: string;
+    component?: string | undefined;
     /** Set to true to get a pooled transport from createTransport, this transport does not read it */
-    pool?: boolean;
+    pool?: boolean | undefined;
 }
 /**
  * Result of a sent message, the connection result plus the envelope and the Message-ID
@@ -97,11 +97,11 @@ declare class SMTPTransport extends EventEmitter {
     /**
      * Transport level authentication data, set when the options include auth
      */
-    auth?: SMTPTransportAuth | false;
+    auth?: SMTPTransportAuth | false | undefined;
     /**
      * The Mail instance using this transport, assigned by Mail
      */
-    mailer?: Mail<SMTPSentMessageInfo>;
+    mailer?: Mail<SMTPSentMessageInfo> | undefined;
     constructor(options?: SMTPTransportOptions | string);
     /**
      * Placeholder function for creating proxy sockets. This method immediatelly returns