nodemailer 10.0.10 → 10.0.12

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # CHANGELOG
 
+## [10.0.12](https://github.com/nodemailer/nodemailer/compare/v10.0.11...v10.0.12) (2026-09-28)
+
+
+### Bug Fixes
+
+* settle every send on a connection error, back off pool requeues, turn a bare CR into CRLF, bound fetch, honour requireTLS ([63ccd66](https://github.com/nodemailer/nodemailer/commit/63ccd66c894bbaac18c82084ee385bf6488226cf))
+
+## [10.0.11](https://github.com/nodemailer/nodemailer/compare/v10.0.10...v10.0.11) (2026-09-27)
+
+
+### Bug Fixes
+
+* **fetch:** report a form body that can not be encoded through the returned stream ([74d40bf](https://github.com/nodemailer/nodemailer/commit/74d40bf1e4553bc0568b471250a9251bcb569b00))
+* keep the CommonJS entry point and the services subpath compatible with the pre-TypeScript build ([52901ef](https://github.com/nodemailer/nodemailer/commit/52901ef3725ad179aa56276495a60f53b2c83516))
+* **qp:** keep wrap() terminating for short line lengths and a trailing incomplete escape ([8fa140b](https://github.com/nodemailer/nodemailer/commit/8fa140b11c62cb1202eac84d35bb3ba28bc3b1a1))
+* **smtp-connection:** fail a password login cleanly when the server offers only XOAUTH2 ([90abf7d](https://github.com/nodemailer/nodemailer/commit/90abf7d11db5ebfeb4292b62c1fff969741c7d33))
+* **types:** restore the layout of @types/nodemailer in the bundled declarations ([ac2e40f](https://github.com/nodemailer/nodemailer/commit/ac2e40ffc69427e0eb33ce3945fae76c4c828c8d))
+
 ## [10.0.10](https://github.com/nodemailer/nodemailer/compare/v10.0.9...v10.0.10) (2026-09-14)
 
 

package/README.md

@@ -72,7 +72,7 @@ let configOptions = {
 
 #### I have an issue with TypeScript types
 
-Nodemailer 10 and later are written in TypeScript and ship their own type definitions, so `@types/nodemailer` is no longer needed and should be removed from your project to avoid conflicting declarations. The type names follow the layout of the old definitions, so references such as `Mail.Options`, `SMTPTransport.Options` or `Transporter<SMTPTransport.SentMessageInfo>` keep compiling, and the most used types (`SendMailOptions`, `Transporter`, `SentMessageInfo`, `Attachment`, `Address`) are exported from the package root. For older Nodemailer versions, the community maintained [type definitions](https://www.npmjs.com/package/@types/nodemailer) still apply.
+Nodemailer 10 and later are written in TypeScript and ship their own type definitions, so `@types/nodemailer` is no longer needed and should be removed from your project to avoid conflicting declarations. The type names follow the layout of the old definitions, so references such as `Mail.Options`, `SMTPTransport.Options` or `Transporter<SMTPTransport.SentMessageInfo>` keep compiling, and the most used types (`SendMailOptions`, `Transporter`, `SentMessageInfo`, `Attachment`, `Address`) are exported from the package root. The modules under `nodemailer/lib/` are declared with a default export, so import a class as `import SMTPTransport from 'nodemailer/lib/smtp-transport'` (with `esModuleInterop` in a CommonJS project). The `import SMTPTransport = require(...)` and `import * as SMTPTransport from ...` forms still resolve the type aliases such as `SMTPTransport.Options`, but they refer to the module rather than to the class, so the class itself has to be imported with a default import. For older Nodemailer versions, the community maintained [type definitions](https://www.npmjs.com/package/@types/nodemailer) still apply.
 
 #### I have a different problem
 

package/dist/cjs/addressparser/index.d.ts

@@ -42,4 +42,19 @@ export type Address = MailboxAddress | GroupAddress;
  * @param options._depth Internal recursion depth counter (do not set manually)
  * @return An array of address objects
  */
-export default function addressparser(str?: string | null, options?: AddressParserOptions): Address[];
+declare function addressparser(str: string | null | undefined, options: AddressParserOptions & {
+    flatten: true;
+}): MailboxAddress[];
+declare function addressparser(str?: string | null, options?: AddressParserOptions): Address[];
+/**
+ * Type aliases in the layout of @types/nodemailer, so `addressparser.Address` style references keep working
+ */
+type AddressEntry = Address;
+declare namespace addressparser {
+    type Address = MailboxAddress;
+    type Group = GroupAddress;
+    type AddressOrGroup = AddressEntry;
+}
+/** The names @types/nodemailer used for the group entry and for the union of both entry types */
+export type { GroupAddress as Group, Address as AddressOrGroup };
+export default addressparser;

package/dist/cjs/addressparser/index.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addressparser;
 /**
  * Restores the quoting of a local part that was read out of a quoted string.
  *
@@ -583,22 +582,6 @@ class Tokenizer {
  * malicious input that could cause stack overflow.
  */
 const MAX_NESTED_GROUP_DEPTH = 50;
-/**
- * Parses structured e-mail addresses from an address field
- *
- * Example:
- *
- *    'Name <address@domain>'
- *
- * will be converted to
- *
- *     [{name: 'Name', address: 'address@domain'}]
- *
- * @param str Address field
- * @param options Optional options object
- * @param options._depth Internal recursion depth counter (do not set manually)
- * @return An array of address objects
- */
 function addressparser(str, options) {
     options = options || {};
     const depth = options._depth || 0;
@@ -667,5 +650,6 @@ function addressparser(str, options) {
     }
     return parsedAddresses;
 }
+exports.default = addressparser;
 module.exports = exports.default;
 Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/base64/index.js

@@ -25,7 +25,8 @@ function encode(buffer) {
  */
 function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = lineLength || 76;
+    // a negative length would step backwards through the input and never finish
+    lineLength = Math.max(Number(lineLength) || 76, 1);
     if (str.length <= lineLength) {
         return str;
     }

package/dist/cjs/dkim/index.d.ts

@@ -30,11 +30,23 @@ declare class DKIM {
     constructor(options: DKIMOptions);
     sign(input: Readable | Buffer | string, extraOptions?: DKIMOptions): DKIMSignedStream;
 }
+/** The signer options without any key material */
+export type DKIMOptionalOptions = Omit<DKIMOptions, 'keys' | 'domainName' | 'keySelector' | 'privateKey'>;
+/** The signer options for a single key given as domainName, keySelector and privateKey */
+export type DKIMSingleKeyOptions = Omit<DKIMOptions, 'keys'>;
+/** The signer options for one or more keys given through `keys` */
+export type DKIMMultipleKeysOptions = DKIMOptionalOptions & {
+    keys: DKIMKey | DKIMKey[];
+};
 /**
  * Type aliases in the layout of @types/nodemailer, so `DKIM.Options` style references keep working
  */
 declare namespace DKIM {
     type Options = DKIMOptions;
-    type SingleKeyOptions = Omit<DKIMOptions, 'keys'>;
+    type OptionalOptions = DKIMOptionalOptions;
+    type SingleKeyOptions = DKIMSingleKeyOptions;
+    type MultipleKeysOptions = DKIMMultipleKeysOptions;
 }
+/** The same aliases as module level exports, for `import * as DKIM` and `import DKIM = require()` */
+export type { DKIMOptions as Options, DKIMOptionalOptions as OptionalOptions, DKIMSingleKeyOptions as SingleKeyOptions, DKIMMultipleKeysOptions as MultipleKeysOptions };
 export default DKIM;

package/dist/cjs/dkim/index.js

@@ -90,13 +90,22 @@ class DKIMSigner {
                 return;
             }
             const key = this.keys[keyPos++];
-            const dkimField = (0, sign_js_1.default)(this.headers, this.hashAlgo, this.bodyHash, {
-                domainName: key.domainName,
-                keySelector: key.keySelector,
-                privateKey: key.privateKey,
-                headerFieldNames: this.options.headerFieldNames,
-                skipFields: this.options.skipFields
-            });
+            let dkimField;
+            try {
+                dkimField = (0, sign_js_1.default)(this.headers, this.hashAlgo, this.bodyHash, {
+                    domainName: key.domainName,
+                    keySelector: key.keySelector,
+                    privateKey: key.privateKey,
+                    headerFieldNames: this.options.headerFieldNames,
+                    skipFields: this.options.skipFields
+                });
+            }
+            catch (err) {
+                this.hasErrored = true;
+                this.cleanup();
+                this.output.emit('error', err);
+                return;
+            }
             if (dkimField) {
                 this.output.write(Buffer.from(dkimField + '\r\n'));
             }
@@ -196,7 +205,15 @@ class DKIM {
         }
         const signer = new DKIMSigner(options, this.keys, inputStream, output);
         setImmediate(() => {
-            signer.signStream();
+            try {
+                signer.signStream();
+            }
+            catch (_E) {
+                // the body hash is created here, an unknown hashAlgo throws inside this timer
+                // where nothing else could catch it
+                output.emit('error', sign_js_1.default.unsupportedHashAlgoError(signer.hashAlgo));
+                return;
+            }
             if (writeValue) {
                 setImmediate(() => {
                     inputStream.end(writeValue);

package/dist/cjs/dkim/message-parser.d.ts

@@ -13,7 +13,7 @@ export interface MessageParserHeaderLine {
  * from the rest of the body. Headers are emitted with the 'headers' event. Message
  * body is passed on as the resulting stream.
  */
-export default class MessageParser extends Transform {
+declare class MessageParser extends Transform {
     lastBytes: Buffer;
     headersParsed: boolean;
     headerBytes: number;
@@ -37,3 +37,12 @@ export default class MessageParser extends Transform {
     checkHeaders(data: Buffer): boolean;
     parseHeaders(): MessageParserHeaderLine[];
 }
+/**
+ * Type aliases in the layout of @types/nodemailer, so `MessageParser.Header` style references keep working
+ */
+declare namespace MessageParser {
+    type Header = MessageParserHeaderLine;
+}
+/** The same alias as a module level export, for `import * as MessageParser` and `import MessageParser = require()` */
+export type { MessageParserHeaderLine as Header };
+export default MessageParser;

package/dist/cjs/dkim/relaxed-body.d.ts

@@ -17,7 +17,7 @@ export interface RelaxedBodyOptions {
  * a non-empty body always ends with CRLF. Bytes are canonicalized as they arrive,
  * so a line of any length costs constant memory.
  */
-export default class RelaxedBody extends Transform {
+declare class RelaxedBody extends Transform {
     bodyHash: crypto.Hash;
     /** Bytes of the original body seen so far */
     byteLength: number;
@@ -25,3 +25,12 @@ export default class RelaxedBody extends Transform {
     constructor(options?: RelaxedBodyOptions);
     updateHash(chunk: Buffer, final?: boolean): void;
 }
+/**
+ * Type aliases in the layout of @types/nodemailer, so `RelaxedBody.Options` style references keep working
+ */
+declare namespace RelaxedBody {
+    type Options = RelaxedBodyOptions;
+}
+/** The same alias as a module level export, for `import * as RelaxedBody` and `import RelaxedBody = require()` */
+export type { RelaxedBodyOptions as Options };
+export default RelaxedBody;

package/dist/cjs/dkim/sign.d.ts

@@ -1,4 +1,5 @@
 import crypto from 'node:crypto';
+import type { NodemailerError } from '../errors.js';
 import type { MessageParserHeaderLine } from './message-parser.js';
 /**
  * Private key accepted by crypto.Sign#sign: a PEM string, a Buffer, a KeyObject or an
@@ -45,5 +46,6 @@ export interface DKIMRelaxedHeaders {
 declare function sign(headers: MessageParserHeaderLine[], hashAlgo: string, bodyHash: string, options?: DKIMSignOptions): string | false;
 declare namespace sign {
     var relaxedHeaders: (headers: MessageParserHeaderLine[], fieldNames?: string, skipFields?: string) => DKIMRelaxedHeaders;
+    var unsupportedHashAlgoError: (hashAlgo: string) => NodemailerError;
 }
 export default sign;

package/dist/cjs/dkim/sign.js

@@ -39,6 +39,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const punycode = __importStar(require("../punycode/index.js"));
 const mimeFuncs = __importStar(require("../mime-funcs/index.js"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
+const errors = __importStar(require("../errors.js"));
+/**
+ * Error for a hashAlgo value the crypto module does not know
+ */
+function unsupportedHashAlgoError(hashAlgo) {
+    const err = new Error('Unsupported DKIM hash algorithm "' + hashAlgo + '"');
+    err.code = errors.ECONFIG;
+    return err;
+}
 /**
  * Returns DKIM signature header line
  *
@@ -63,7 +72,13 @@ function sign(headers, hashAlgo, bodyHash, options) {
     const canonicalizedHeaderData = relaxedHeaders(headers, fieldNames, options.skipFields);
     const dkimHeader = generateDKIMHeader(options.domainName, options.keySelector, canonicalizedHeaderData.fieldNames, hashAlgo, bodyHash);
     canonicalizedHeaderData.headers += 'dkim-signature:' + relaxedHeaderLine(dkimHeader);
-    const signer = node_crypto_1.default.createSign(('rsa-' + hashAlgo).toUpperCase());
+    let signer;
+    try {
+        signer = node_crypto_1.default.createSign(('rsa-' + hashAlgo).toUpperCase());
+    }
+    catch (_E) {
+        throw unsupportedHashAlgoError(hashAlgo);
+    }
     // the header lines are 'binary' strings, so this reproduces the original header bytes
     signer.update(canonicalizedHeaderData.headers, 'latin1');
     let signature;
@@ -76,6 +91,7 @@ function sign(headers, hashAlgo, bodyHash, options) {
     return dkimHeader + signature.replace(/(^.{73}|.{75}(?!\r?\n|\r))/g, '$&\r\n ').trim();
 }
 sign.relaxedHeaders = relaxedHeaders;
+sign.unsupportedHashAlgoError = unsupportedHashAlgoError;
 exports.default = sign;
 function generateDKIMHeader(domainName, keySelector, fieldNames, hashAlgo, bodyHash) {
     // the caller supplied tag values are interpolated straight into the tag list, and none of

package/dist/cjs/errors.d.ts

@@ -64,9 +64,10 @@ export declare const EFETCH = "EFETCH";
 /**
  * An Error together with the properties Nodemailer attaches to the errors it
  * hands to callers. Every property is optional, the set that is present
- * depends on where the error originated.
+ * depends on where the error originated. Socket level errors keep the errno
+ * and syscall fields Node.js sets on them.
  */
-export interface NodemailerError extends Error {
+export interface NodemailerError extends NodeJS.ErrnoException {
     /** Nodemailer error code, see ERROR_CODES */
     code?: string | undefined;
     /** SMTP command that was in flight when the server replied with an error */

package/dist/cjs/fetch/cookies.d.ts

@@ -17,13 +17,14 @@ export interface Cookie {
     secure?: boolean | undefined;
     httponly?: boolean | undefined;
 }
+type CookieEntry = Cookie;
 /**
  * Creates a biskviit cookie jar for managing cookie values in memory
  *
  * @constructor
  * @param [options] Optional options object
  */
-export default class Cookies {
+declare class Cookies {
     options: CookiesOptions;
     cookies: Cookie[];
     constructor(options?: CookiesOptions);
@@ -94,3 +95,13 @@ export default class Cookies {
      */
     getPath(pathname?: string | null): string;
 }
+/**
+ * Type aliases in the layout of @types/nodemailer, so `Cookies.Cookie` style references keep working
+ */
+declare namespace Cookies {
+    type Options = CookiesOptions;
+    type Cookie = CookieEntry;
+}
+/** The same alias as a module level export, for `import * as Cookies` and `import Cookies = require()` */
+export type { CookiesOptions as Options };
+export default Cookies;

package/dist/cjs/fetch/index.d.ts

@@ -25,8 +25,10 @@ export interface FetchOptions {
     tls?: {
         [key: string]: any;
     } | undefined;
-    /** Request timeout in milliseconds */
+    /** Socket inactivity timeout in milliseconds, defaults to 60000, 0 disables it */
     timeout?: number | undefined;
+    /** Maximum size of the (decoded) response body in bytes, defaults to 64 MB, Infinity disables the limit */
+    maxBytes?: number | undefined;
     /** Maximum number of redirects to follow (default 5) */
     maxRedirects?: number | undefined;
     /** Resolve responses with a status code of 300 or above instead of emitting an error */
@@ -47,5 +49,17 @@ export interface FetchResponse extends PassThrough {
 declare function nmfetch(url: string, options?: FetchOptions): FetchResponse;
 declare namespace nmfetch {
     var Cookies: typeof import("./cookies.js").default;
+    var DEFAULT_TIMEOUT: number;
 }
+type CookiesJar = Cookies;
+/**
+ * Type aliases in the layout of @types/nodemailer, so `fetch.Options` style references keep working
+ */
+declare namespace nmfetch {
+    type Options = FetchOptions;
+    type WritableResponse = FetchResponse;
+    type Cookies = CookiesJar;
+}
+/** The same aliases as module level exports, for `import * as fetch` and `import fetch = require()` */
+export type { FetchOptions as Options, FetchResponse as WritableResponse, Cookies };
 export default nmfetch;

package/dist/cjs/fetch/index.js

@@ -47,6 +47,10 @@ const node_net_1 = __importDefault(require("node:net"));
 const errors = __importStar(require("../errors.js"));
 const objects_js_1 = require("../shared/objects.js");
 const MAX_REDIRECTS = 5;
+// a stalled server would otherwise hold the request, and whatever waits on it, open forever
+const DEFAULT_TIMEOUT = 60 * 1000;
+// the body is usually buffered in memory by the caller, so an unbounded download is refused
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
 // Only genuine TLS settings are taken from options.tls. That object reaches us straight
 // from a user supplied attachment (content.tls), so keys like host, port, path, socketPath
 // or lookup would otherwise repoint the request at a destination that never went through
@@ -193,14 +197,14 @@ function nmfetch(url, options) {
                         .join('&'));
                 }
                 catch (E) {
-                    if (finished) {
-                        return undefined;
-                    }
+                    // the caller attaches its error listener once nmfetch has returned, so
+                    // the error is emitted on the next tick and the stream is handed back
+                    // the way every other failure is reported
                     finished = true;
                     E.code = errors.EFETCH;
                     E.sourceUrl = url;
-                    fetchRes.emit('error', E);
-                    return undefined;
+                    setImmediate(() => fetchRes.emit('error', E));
+                    return fetchRes;
                 }
             }
             else {
@@ -252,28 +256,22 @@ function nmfetch(url, options) {
         });
         return fetchRes;
     }
-    if (options.timeout) {
-        req.setTimeout(options.timeout, () => {
-            if (finished) {
-                return;
-            }
-            finished = true;
-            req.abort();
-            const err = new Error('Request Timeout');
-            err.code = errors.EFETCH;
-            err.sourceUrl = url;
-            fetchRes.emit('error', err);
-        });
-    }
-    req.on('error', (err) => {
+    // reports the first failure of this request on fetchRes and releases the request
+    const fail = (err, sourceUrl = url) => {
         if (finished) {
             return;
         }
         finished = true;
         err.code = errors.EFETCH;
-        err.sourceUrl = url;
+        err.sourceUrl = sourceUrl;
         fetchRes.emit('error', err);
-    });
+        req.abort();
+    };
+    const timeout = typeof options.timeout === 'number' && options.timeout >= 0 ? options.timeout : DEFAULT_TIMEOUT;
+    if (timeout) {
+        req.setTimeout(timeout, () => fail(new Error('Request Timeout')));
+    }
+    req.on('error', (err) => fail(err));
     req.on('response', res => {
         let inflate;
         if (finished) {
@@ -294,13 +292,7 @@ function nmfetch(url, options) {
             // redirect
             options.redirects++;
             if (options.redirects > options.maxRedirects) {
-                finished = true;
-                const err = new Error('Maximum redirect count exceeded');
-                err.code = errors.EFETCH;
-                err.sourceUrl = url;
-                fetchRes.emit('error', err);
-                req.abort();
-                return;
+                return fail(new Error('Maximum redirect count exceeded'));
             }
             // redirect does not include POST body
             options.method = 'GET';
@@ -320,13 +312,7 @@ function nmfetch(url, options) {
                 // call: that call gets its own `finished` flag and no handle on this
                 // request, so this one would stay open and could emit a second error on
                 // the shared fetchRes once it times out. Callers listen with req.once().
-                finished = true;
-                const err = new Error('Unsupported protocol for URL ' + redirectUrl);
-                err.code = errors.EFETCH;
-                err.sourceUrl = redirectUrl;
-                fetchRes.emit('error', err);
-                req.abort();
-                return;
+                return fail(new Error('Unsupported protocol for URL ' + redirectUrl), redirectUrl);
             }
             // Do not forward credentials when the redirect leaves the original
             // security context: a different host, or a downgrade from https to
@@ -343,41 +329,33 @@ function nmfetch(url, options) {
                     }
                 });
             }
+            // this request is done with, release it so its socket and timeout do not
+            // outlive it and report a late error on the shared fetchRes
+            finished = true;
+            res.resume();
+            req.abort();
             return nmfetch(redirectUrl, options);
         }
         fetchRes.statusCode = res.statusCode;
         fetchRes.headers = res.headers;
         if (res.statusCode >= 300 && !options.allowErrorResponse) {
-            finished = true;
-            const err = new Error('Invalid status code ' + res.statusCode);
-            err.code = errors.EFETCH;
-            err.sourceUrl = url;
-            fetchRes.emit('error', err);
-            req.abort();
-            return;
+            return fail(new Error('Invalid status code ' + res.statusCode));
         }
-        res.on('error', (err) => {
-            if (finished) {
+        res.on('error', (err) => fail(err));
+        const maxBytes = typeof options.maxBytes === 'number' && options.maxBytes > 0 ? options.maxBytes : DEFAULT_MAX_BYTES;
+        const source = inflate || res;
+        let received = 0;
+        source.on('data', (chunk) => {
+            received += chunk.length;
+            if (received <= maxBytes || finished) {
                 return;
             }
-            finished = true;
-            err.code = errors.EFETCH;
-            err.sourceUrl = url;
-            fetchRes.emit('error', err);
-            req.abort();
+            source.unpipe(fetchRes);
+            fail(new Error('Response size exceeds the allowed ' + maxBytes + ' bytes'));
         });
         if (inflate) {
             res.pipe(inflate).pipe(fetchRes);
-            inflate.on('error', (err) => {
-                if (finished) {
-                    return;
-                }
-                finished = true;
-                err.code = errors.EFETCH;
-                err.sourceUrl = url;
-                fetchRes.emit('error', err);
-                req.abort();
-            });
+            inflate.on('error', (err) => fail(err));
         }
         else {
             res.pipe(fetchRes);
@@ -392,11 +370,7 @@ function nmfetch(url, options) {
                 req.write(body);
             }
             catch (err) {
-                finished = true;
-                err.code = errors.EFETCH;
-                err.sourceUrl = url;
-                fetchRes.emit('error', err);
-                return;
+                return fail(err);
             }
         }
         req.end();
@@ -404,6 +378,7 @@ function nmfetch(url, options) {
     return fetchRes;
 }
 nmfetch.Cookies = cookies_js_1.default;
+nmfetch.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
 exports.default = nmfetch;
 module.exports = exports.default;
 Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/json-transport/index.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '../shared/index.js';
 import type { MimeNodeEnvelope } from '../mime-node/index.js';
-import type { default as MailMessage, MailMessageData } from '../mailer/mail-message.js';
+import type MailMessage from '../mailer/mail-message.js';
 import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOptions } from '../mailer/index.js';
 /**
  * Options for the JSON transport
@@ -12,16 +12,23 @@ export interface JSONTransportOptions extends TransportOptions {
     skipEncoding?: boolean | undefined;
 }
 /**
- * The value the JSON transport hands to the send callback
+ * The value the JSON transport hands to the send callback. M is the type of the message
+ * field: a JSON string by default, the message object itself when skipEncoding is set
  */
-export interface JSONSentMessageInfo extends SentMessageInfo {
+export interface JSONSentMessageInfo<M = string> extends SentMessageInfo {
     /** The envelope the message was generated with */
     envelope: MimeNodeEnvelope;
     /** Message-ID value of the message */
     messageId: string;
     /** The normalized message as a JSON string, or as the object itself when skipEncoding is set */
-    message: string | MailMessageData;
+    message: M;
 }
+/**
+ * The value the JSON transport hands to the send callback when skipEncoding is set: the
+ * message field holds the message object. Typed loosely so that a transporter created with
+ * skipEncoding still fits a variable declared with the plain result type
+ */
+export type JSONSentMessageObjectInfo = JSONSentMessageInfo<any>;
 /**
  * Generates a Transport object to generate JSON output
  *
@@ -50,5 +57,8 @@ declare namespace JSONTransport {
     type Options = JSONTransportOptions;
     type MailOptions = SendMailOptions;
     type SentMessageInfo = JSONSentMessageInfo;
+    type SentMessageObjectInfo = JSONSentMessageObjectInfo;
 }
+/** The same aliases as module level exports, for `import * as JSONTransport` and `import JSONTransport = require()` */
+export type { JSONTransportOptions as Options, SendMailOptions as MailOptions, JSONSentMessageInfo as SentMessageInfo, JSONSentMessageObjectInfo as SentMessageObjectInfo };
 export default JSONTransport;

package/dist/cjs/json-transport/index.js

@@ -83,6 +83,8 @@ class JSONTransport {
                 }
                 delete data.envelope;
                 delete data.normalizedHeaders;
+                // the message field is the object itself with skipEncoding, the
+                // createTransport overload for that option types the result accordingly
                 return done(null, {
                     envelope,
                     messageId,

package/dist/cjs/mail-composer/index.d.ts

@@ -72,6 +72,11 @@ export type MailComposerListHeaderEntry = string | {
 export interface MailComposerListHeaders {
     [key: string]: MailComposerListHeaderEntry | (MailComposerListHeaderEntry | MailComposerListHeaderEntry[])[];
 }
+/**
+ * Encoding for the non-ascii header values: quoted-printable ('Q', the default) or base64
+ * ('B'). Only the first letter is read, so the short forms work as well
+ */
+export type MailComposerTextEncoding = 'quoted-printable' | 'base64' | 'Q' | 'B';
 /**
  * Mail options, the message data MailComposer builds the MIME tree from. The address
  * fields, subject, messageId, date, inReplyTo and references become headers of the root
@@ -114,7 +119,7 @@ export interface MailComposerOptions {
     /** Content-Transfer-Encoding to force for the text/* nodes that do not set their own */
     encoding?: string | undefined;
     /** Header string encoding, 'Q' (the default) or 'B', 'quoted-printable' and 'base64' are accepted as well */
-    textEncoding?: string | undefined;
+    textEncoding?: MailComposerTextEncoding | undefined;
     /** Pregenerated rfc822 message, used as is instead of building one */
     raw?: MimeNodeContent | undefined;
     /** Reject content that points to a URL */
@@ -129,8 +134,6 @@ export interface MailComposerOptions {
     baseBoundary?: string | undefined;
     /** 'win' for CRLF and 'linux' for LF line breaks in the generated message, kept as is when not set */
     newline?: string | undefined;
-    /** Keep the Bcc header in the generated message, listed for completeness, the transports set it on the message directly */
-    keepBcc?: boolean | undefined;
     /** Method to normalize header keys for custom caseing */
     normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** 'high', 'normal' or 'low', sets the priority headers, read by the mailer */
@@ -166,4 +169,6 @@ declare class MailComposer {
 declare namespace MailComposer {
     type Options = MailComposerOptions;
 }
+/** The same alias as a module level export, for `import * as MailComposer` and `import MailComposer = require()` */
+export type { MailComposerOptions as Options };
 export default MailComposer;