nodemailer 10.0.0 → 10.0.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## [10.0.1](https://github.com/nodemailer/nodemailer/compare/v10.0.0...v10.0.1) (2026-09-07)
+
+
+### Bug Fixes
+
+* **types:** accept an explicit undefined for optional properties ([209719d](https://github.com/nodemailer/nodemailer/commit/209719dd6a192656a6b18de265a3b4ac387208ff)), closes [#1853](https://github.com/nodemailer/nodemailer/issues/1853)
+* **types:** drop the internal members from the published declarations ([81e64ea](https://github.com/nodemailer/nodemailer/commit/81e64eaee70aabf867afef88d3733556c9fcc1cc))
+
 ## [10.0.0](https://github.com/nodemailer/nodemailer/compare/v9.1.1...v10.0.0) (2026-09-03)
 
 

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

@@ -3,9 +3,7 @@
  */
 export interface AddressParserOptions {
     /** Flatten groups into a single list of mailboxes */
-    flatten?: boolean;
-    /** Internal recursion depth counter (do not set manually) */
-    _depth?: number;
+    flatten?: boolean | undefined;
 }
 /**
  * A single mailbox. Either value may be an empty string when the input did not carry it

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

@@ -1,4 +1,4 @@
-import { Transform, type TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
 /**
  * Encodes a Buffer into a base64 encoded string
  *
@@ -19,7 +19,7 @@ export declare function wrap(str: string, lineLength?: number | false): string;
  */
 export interface EncoderOptions {
     /** Maximum length for lines, set to false to disable wrapping */
-    lineLength?: number | false;
+    lineLength?: number | false | undefined;
 }
 /**
  * Creates a transform stream for encoding data to base64 encoding
@@ -32,9 +32,5 @@ export declare class Encoder extends Transform {
     options: EncoderOptions;
     inputBytes: number;
     outputBytes: number;
-    _curLine: string;
-    _remainingBytes: Buffer | false;
     constructor(options?: EncoderOptions);
-    _transform(chunk: Buffer | string, encoding: BufferEncoding | 'buffer', done: TransformCallback): void;
-    _flush(done: TransformCallback): void;
 }

package/dist/cjs/base64/index.js

@@ -59,6 +59,7 @@ class Encoder extends node_stream_1.Transform {
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
+    /** @internal */
     _transform(chunk, encoding, done) {
         let buf = encoding !== 'buffer' ? Buffer.from(chunk, encoding) : chunk;
         if (!buf || !buf.length) {
@@ -100,6 +101,7 @@ class Encoder extends node_stream_1.Transform {
         }
         setImmediate(done);
     }
+    /** @internal */
     _flush(done) {
         if (this._remainingBytes && this._remainingBytes.length) {
             this._curLine += encode(this._remainingBytes);

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

@@ -9,13 +9,13 @@ export type { DKIMKey, DKIMPrivateKey, DKIMSignOptions };
  */
 export interface DKIMOptions extends DKIMSignOptions {
     /** One or more signing keys, used instead of the domainName, keySelector and privateKey options */
-    keys?: DKIMKey | DKIMKey[];
+    keys?: DKIMKey | DKIMKey[] | undefined;
     /** Directory for buffering large message bodies to disk, no buffering when not set */
-    cacheDir?: string | false;
+    cacheDir?: string | false | undefined;
     /** Body size in bytes from which the body is buffered to cacheDir, defaults to 10 MB */
-    cacheTreshold?: number;
+    cacheTreshold?: number | undefined;
     /** Hash algorithm for the body hash and the signature, defaults to sha256 */
-    hashAlgo?: string;
+    hashAlgo?: string | undefined;
 }
 /**
  * The signed message as returned by DKIM#sign

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

@@ -1,4 +1,4 @@
-import { Transform, type TransformCallback, type TransformOptions } from 'node:stream';
+import { Transform, type TransformOptions } from 'node:stream';
 /**
  * A header line as emitted with the 'headers' event
  */
@@ -35,7 +35,5 @@ export default class MessageParser extends Transform {
      * @return Returns true if headers are already found or false otherwise
      */
     checkHeaders(data: Buffer): boolean;
-    _transform(chunk: Buffer | string, encoding: BufferEncoding, callback: TransformCallback): void;
-    _flush(callback: TransformCallback): void;
     parseHeaders(): MessageParserHeaderLine[];
 }

package/dist/cjs/dkim/message-parser.js

@@ -90,6 +90,7 @@ class MessageParser extends node_stream_1.Transform {
         this.updateLastBytes(data);
         return false;
     }
+    /** @internal */
     _transform(chunk, encoding, callback) {
         if (!chunk || !chunk.length) {
             return callback();
@@ -110,6 +111,7 @@ class MessageParser extends node_stream_1.Transform {
         }
         setImmediate(callback);
     }
+    /** @internal */
     _flush(callback) {
         if (this.headerChunks) {
             // no empty line was seen, so the message consists of headers only

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

@@ -1,13 +1,13 @@
-import { Transform, type TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
 import crypto from 'node:crypto';
 /**
  * Options for the relaxed body hash stream
  */
 export interface RelaxedBodyOptions {
     /** Hash algorithm for the body hash, defaults to sha256 */
-    hashAlgo?: string;
+    hashAlgo?: string | undefined;
     /** Collect the canonicalized body and emit it with the 'hash' event */
-    debug?: boolean;
+    debug?: boolean | undefined;
 }
 /**
  * Passes the message body through unchanged and hashes its relaxed
@@ -22,25 +22,6 @@ export default class RelaxedBody extends Transform {
     /** Bytes of the original body seen so far */
     byteLength: number;
     debug: boolean | undefined;
-    _debugBody: Buffer[] | false;
-    /** The current line has bytes that survive canonicalization */
-    _lineHasContent: boolean;
-    /** Whitespace that ends up as a single space if more content follows on the line */
-    _pendingWsp: boolean;
-    /** A CR that is part of the line ending if LF follows, otherwise content */
-    _pendingCr: boolean;
-    /** Empty lines that are hashed only once a non-empty line follows them */
-    _pendingEmptyLines: number;
     constructor(options?: RelaxedBodyOptions);
-    _hashCanonical(data: Buffer): void;
-    _hashEmptyLines(): void;
-    /**
-     * Writes a content byte, with the space a pending run of whitespace collapses to,
-     * into the output buffer and returns the new write position. Kept a method rather
-     * than a closure so the write position stays a plain local in the byte loop
-     */
-    _emitContent(out: Buffer, outPos: number, c: number): number;
     updateHash(chunk: Buffer, final?: boolean): void;
-    _transform(chunk: Buffer | string, encoding: BufferEncoding, callback: TransformCallback): void;
-    _flush(callback: TransformCallback): void;
 }

package/dist/cjs/dkim/relaxed-body.js

@@ -34,6 +34,7 @@ class RelaxedBody extends node_stream_1.Transform {
         this._pendingCr = false;
         this._pendingEmptyLines = 0;
     }
+    /** @internal */
     _hashCanonical(data) {
         if (!data.length) {
             return;
@@ -43,6 +44,7 @@ class RelaxedBody extends node_stream_1.Transform {
             this._debugBody.push(Buffer.from(data));
         }
     }
+    /** @internal */
     _hashEmptyLines() {
         while (this._pendingEmptyLines > 0) {
             const count = Math.min(this._pendingEmptyLines, EMPTY_LINES.length / 2);
@@ -54,6 +56,7 @@ class RelaxedBody extends node_stream_1.Transform {
      * Writes a content byte, with the space a pending run of whitespace collapses to,
      * into the output buffer and returns the new write position. Kept a method rather
      * than a closure so the write position stays a plain local in the byte loop
+     * @internal
      */
     _emitContent(out, outPos, c) {
         if (!this._lineHasContent) {
@@ -116,6 +119,7 @@ class RelaxedBody extends node_stream_1.Transform {
         }
         this._hashCanonical(out.subarray(0, outPos));
     }
+    /** @internal */
     _transform(chunk, encoding, callback) {
         if (!chunk || !chunk.length) {
             return callback();
@@ -128,6 +132,7 @@ class RelaxedBody extends node_stream_1.Transform {
         this.push(chunk);
         callback();
     }
+    /** @internal */
     _flush(callback) {
         this.updateHash(Buffer.alloc(0), true);
         if (this._lineHasContent) {

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

@@ -10,17 +10,17 @@ export type DKIMPrivateKey = crypto.KeyLike | crypto.SignKeyObjectInput | crypto
  */
 export interface DKIMKey {
     /** Domain name to be signed for */
-    domainName?: string;
+    domainName?: string | undefined;
     /** DKIM key selector to use */
-    keySelector?: string;
+    keySelector?: string | undefined;
     /** DKIM private key to use */
-    privateKey?: DKIMPrivateKey;
+    privateKey?: DKIMPrivateKey | undefined;
 }
 export interface DKIMSignOptions extends DKIMKey {
     /** Colon separated list of header field names to sign, defaults to the RFC4871 list */
-    headerFieldNames?: string;
+    headerFieldNames?: string | undefined;
     /** Colon separated list of header field names to leave out of the signature */
-    skipFields?: string;
+    skipFields?: string | undefined;
 }
 /**
  * Canonicalized headers and the list of field names that went into them

package/dist/cjs/errors.d.ts

@@ -68,21 +68,21 @@ export declare const EFETCH = "EFETCH";
  */
 export interface NodemailerError extends Error {
     /** Nodemailer error code, see ERROR_CODES */
-    code?: string;
+    code?: string | undefined;
     /** SMTP command that was in flight when the server replied with an error */
-    command?: string;
+    command?: string | undefined;
     /** Raw SMTP server response */
-    response?: string;
+    response?: string | undefined;
     /** Numeric SMTP response code */
-    responseCode?: number;
+    responseCode?: number | undefined;
     /** URL of the resource that could not be fetched */
-    sourceUrl?: string;
+    sourceUrl?: string | undefined;
     /** Recipient address the error applies to */
-    recipient?: string;
+    recipient?: string | undefined;
     /** Recipient addresses rejected by the server */
-    rejected?: string[];
+    rejected?: string[] | undefined;
     /** Per-recipient errors for the rejected addresses */
-    rejectedErrors?: NodemailerError[];
+    rejectedErrors?: NodemailerError[] | undefined;
 }
 /**
  * Node style callback: called with an error, or with null and the result

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

@@ -3,19 +3,19 @@
  */
 export interface CookiesOptions {
     /** Lifetime in seconds for cookies that do not set their own expiration (default 1800) */
-    sessionTimeout?: number | string;
+    sessionTimeout?: number | string | undefined;
 }
 /**
  * A cookie as parsed from a 'Set-Cookie:' header and kept in the jar
  */
 export interface Cookie {
-    name?: string;
-    value?: string;
-    domain?: string;
-    path?: string;
-    expires?: Date;
-    secure?: boolean;
-    httponly?: boolean;
+    name?: string | undefined;
+    value?: string | undefined;
+    domain?: string | undefined;
+    path?: string | undefined;
+    expires?: Date | undefined;
+    secure?: boolean | undefined;
+    httponly?: boolean | undefined;
 }
 /**
  * Creates a biskviit cookie jar for managing cookie values in memory

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

@@ -6,43 +6,43 @@ import Cookies from './cookies.js';
  */
 export interface FetchOptions {
     /** HTTP method, defaults to GET, or to POST when a body is given */
-    method?: string;
+    method?: string | undefined;
     /** Request headers, keys are lowercased before use */
-    headers?: http.OutgoingHttpHeaders;
+    headers?: http.OutgoingHttpHeaders | undefined;
     /** Overrides the default User-Agent header */
-    userAgent?: string;
+    userAgent?: string | undefined;
     /** Cookie string(s) to seed the cookie jar with for this URL */
-    cookie?: string | string[] | false;
+    cookie?: string | string[] | false | undefined;
     /** Cookie jar shared across redirects, created when missing */
-    cookies?: Cookies;
+    cookies?: Cookies | undefined;
     /** Request body: a readable stream, a Buffer, a form object or a string */
     body?: Readable | Buffer | {
         [key: string]: any;
-    } | string | false;
+    } | string | false | undefined;
     /** Content-Type header for the body, false leaves it out for a stream body */
-    contentType?: string | false;
+    contentType?: string | false | undefined;
     /** TLS settings, only the keys listed in TLS_OPTION_KEYS are used */
     tls?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** Request timeout in milliseconds */
-    timeout?: number;
+    timeout?: number | undefined;
     /** Maximum number of redirects to follow (default 5) */
-    maxRedirects?: number;
+    maxRedirects?: number | undefined;
     /** Resolve responses with a status code of 300 or above instead of emitting an error */
-    allowErrorResponse?: boolean;
+    allowErrorResponse?: boolean | undefined;
     /** Redirects followed so far, set by nmfetch itself */
-    redirects?: number;
+    redirects?: number | undefined;
     /** Response stream shared across redirects, set by nmfetch itself */
-    fetchRes?: FetchResponse;
+    fetchRes?: FetchResponse | undefined;
 }
 /**
  * The stream nmfetch returns. The response body is piped into it, the status code and
  * headers of the final response are attached once they arrive
  */
 export interface FetchResponse extends PassThrough {
-    statusCode?: number;
-    headers?: http.IncomingHttpHeaders;
+    statusCode?: number | undefined;
+    headers?: http.IncomingHttpHeaders | undefined;
 }
 declare function nmfetch(url: string, options?: FetchOptions): FetchResponse;
 declare namespace nmfetch {

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

@@ -7,9 +7,9 @@ import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOption
  */
 export interface JSONTransportOptions extends TransportOptions {
     /** Selects this transport in createTransport */
-    jsonTransport?: boolean;
+    jsonTransport?: boolean | undefined;
     /** If true, the message is returned as an object instead of a JSON string */
-    skipEncoding?: boolean;
+    skipEncoding?: boolean | undefined;
 }
 /**
  * The value the JSON transport hands to the send callback

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

@@ -8,45 +8,45 @@ import type { OutgoingHttpHeaders } from 'node:http';
  */
 export interface MailComposerAlternative {
     /** The content itself: a string, a Buffer, a readable stream or a content descriptor */
-    content?: MimeNodeContent;
+    content?: MimeNodeContent | undefined;
     /** File path, data URI or http(s) URL to read the content from */
-    path?: string | false;
+    path?: string | false | undefined;
     /** URL or data URI to fetch the content from */
-    href?: string | false;
+    href?: string | false | undefined;
     /** Request headers for a URL fetch */
-    httpHeaders?: OutgoingHttpHeaders;
+    httpHeaders?: OutgoingHttpHeaders | undefined;
     /** TLS settings for a URL fetch, see nmfetch */
     tls?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** Encoding of a string `content`, decoded into a Buffer unless it is utf8 or ascii */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Pregenerated MIME part, used as is instead of building the node */
-    raw?: MimeNodeContent;
+    raw?: MimeNodeContent | undefined;
     /** Content type, detected from the filename, path or URL when not set */
-    contentType?: string;
+    contentType?: string | undefined;
     /** Content-Transfer-Encoding for the node, false leaves the choice to the node */
-    contentTransferEncoding?: string | false;
+    contentTransferEncoding?: string | false | undefined;
     /** Filename for the node, false suppresses the generated one */
-    filename?: string | false;
+    filename?: string | false | undefined;
     /** Additional headers for the node */
-    headers?: MimeNodeHeaders;
+    headers?: MimeNodeHeaders | undefined;
 }
 /**
  * An attachment, the shape of the attachments entries
  */
 export interface MailComposerAttachment extends MailComposerAlternative {
     /** Content-Disposition for the node, 'attachment' by default and 'inline' for a message node or an image with a cid */
-    contentDisposition?: string;
+    contentDisposition?: string | undefined;
     /** Content-Id for an embedded image, moves the attachment into the multipart/related node beside the html */
-    cid?: string;
+    cid?: string | undefined;
 }
 /**
  * The icalEvent value as an object
  */
 export interface MailComposerIcalEvent extends MailComposerAlternative {
     /** iCalendar method, PUBLISH by default */
-    method?: string;
+    method?: string | undefined;
 }
 /**
  * The attachments as sorted by getAttachments
@@ -62,7 +62,7 @@ export interface MailComposerAttachments {
  */
 export type MailComposerListHeaderEntry = string | {
     url: string;
-    comment?: string;
+    comment?: string | undefined;
 };
 /**
  * The list value: List-* headers keyed by the part after "List-" (help, unsubscribe,
@@ -79,75 +79,68 @@ export interface MailComposerListHeaders {
  * by MailComposer itself, these are marked as such
  */
 export interface MailComposerOptions {
-    from?: MimeNodeAddressInput;
-    sender?: MimeNodeAddressInput;
-    to?: MimeNodeAddressInput;
-    cc?: MimeNodeAddressInput;
-    bcc?: MimeNodeAddressInput;
-    replyTo?: MimeNodeAddressInput;
-    inReplyTo?: string;
-    references?: string | string[];
-    subject?: string;
+    from?: MimeNodeAddressInput | undefined;
+    sender?: MimeNodeAddressInput | undefined;
+    to?: MimeNodeAddressInput | undefined;
+    cc?: MimeNodeAddressInput | undefined;
+    bcc?: MimeNodeAddressInput | undefined;
+    replyTo?: MimeNodeAddressInput | undefined;
+    inReplyTo?: string | undefined;
+    references?: string | string[] | undefined;
+    subject?: string | undefined;
     /** Message-ID header value, generated when missing */
-    messageId?: string;
+    messageId?: string | undefined;
     /** Date header value, the current time when missing */
-    date?: Date | string;
+    date?: Date | string | undefined;
     /** Plaintext version of the message */
-    text?: string | Buffer | Readable | MailComposerAlternative;
+    text?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** HTML version of the message */
-    html?: string | Buffer | Readable | MailComposerAlternative;
+    html?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** Apple Watch specific HTML version of the message */
-    watchHtml?: string | Buffer | Readable | MailComposerAlternative;
+    watchHtml?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** AMP4EMAIL version of the message */
-    amp?: string | Buffer | Readable | MailComposerAlternative;
+    amp?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** iCalendar event, included both as a text/calendar alternative and as an application/ics attachment */
-    icalEvent?: string | Buffer | Readable | MailComposerIcalEvent;
-    attachments?: MailComposerAttachment[];
+    icalEvent?: string | Buffer | Readable | MailComposerIcalEvent | undefined;
+    attachments?: MailComposerAttachment[] | undefined;
     /** Further alternatives for the multipart/alternative node, after text, watchHtml, amp, html and the calendar event */
-    alternatives?: MailComposerAlternative[];
+    alternatives?: MailComposerAlternative[] | undefined;
     /** Custom headers for the root node, the standard headers above override them */
-    headers?: MimeNodeHeaders;
+    headers?: MimeNodeHeaders | undefined;
     /** List-* headers, read by the mailer */
-    list?: MailComposerListHeaders;
+    list?: MailComposerListHeaders | undefined;
     /** SMTP envelope to use instead of the one generated from the headers */
-    envelope?: MimeNodeEnvelopeInput;
+    envelope?: MimeNodeEnvelopeInput | undefined;
     /** Content-Transfer-Encoding to force for the text/* nodes that do not set their own */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Header string encoding, 'Q' (the default) or 'B', 'quoted-printable' and 'base64' are accepted as well */
-    textEncoding?: string;
+    textEncoding?: string | undefined;
     /** Pregenerated rfc822 message, used as is instead of building one */
-    raw?: MimeNodeContent;
+    raw?: MimeNodeContent | undefined;
     /** Reject content that points to a URL */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
     /** Reject content that points to a file path */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Convert data: images in the html into embedded attachments, read by the mailer */
-    attachDataUrls?: boolean;
+    attachDataUrls?: boolean | undefined;
     /** Prefix for the generated multipart boundaries */
-    boundaryPrefix?: string;
+    boundaryPrefix?: string | undefined;
     /** Shared part of the unique multipart boundary */
-    baseBoundary?: string;
+    baseBoundary?: string | undefined;
     /** 'win' for CRLF and 'linux' for LF line breaks in the generated message, kept as is when not set */
-    newline?: string;
+    newline?: string | undefined;
     /** Keep the Bcc header in the generated message, listed for completeness, the transports set it on the message directly */
-    keepBcc?: boolean;
+    keepBcc?: boolean | undefined;
     /** Method to normalize header keys for custom caseing */
-    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'];
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** 'high', 'normal' or 'low', sets the priority headers, read by the mailer */
-    priority?: string;
+    priority?: string | undefined;
     /** X-Mailer header value, false leaves the header out, read by the mailer */
-    xMailer?: string | false;
+    xMailer?: string | false | undefined;
 }
 declare class MailComposer {
     mail: MailComposerOptions;
     message: MimeNode | false;
-    _alternatives: MailComposerAlternative[];
-    _htmlNode: MailComposerAlternative | undefined;
-    _attachments: MailComposerAttachments;
-    _useRelated: boolean;
-    _useAlternative: boolean;
-    _useMixed: boolean | number;
-    _icalEvent: MailComposerIcalEvent | undefined;
     constructor(mail?: MailComposerOptions);
     /**
      * Builds MimeNode instance
@@ -160,60 +153,12 @@ declare class MailComposer {
      * @returns An object of arrays (`related` and `attached`)
      */
     getAttachments(findRelated?: boolean): MailComposerAttachments;
-    /**
-     * Returns the icalEvent value with `path`/`href`/data uri input normalized into
-     * a `content` entry, the same way as for regular attachments. The same event is
-     * included twice (as a text/calendar alternative and as an application/ics
-     * attachment), so the shared content object is marked to be resolved just once
-     * and the buffered result is reused by the second node.
-     *
-     * @returns Normalized icalEvent data
-     */
-    _getIcalEvent(): MailComposerIcalEvent;
     /**
      * List alternatives. Resulting objects can be used as input for MimeNode nodes
      *
      * @returns An array of alternative elements. Includes the `text` and `html` values as well
      */
     getAlternatives(): MailComposerAlternative[];
-    /**
-     * Builds multipart/mixed node. It should always contain different type of elements on the same level
-     * eg. text + attachments
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createMixed(parentNode?: MimeNode): MimeNode;
-    /**
-     * Builds multipart/alternative node. It should always contain same type of elements on the same level
-     * eg. text + html view of the same data
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createAlternative(parentNode?: MimeNode): MimeNode;
-    /**
-     * Builds multipart/related node. It should always contain html node with related attachments
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createRelated(parentNode?: MimeNode): MimeNode;
-    /**
-     * Creates a regular node with contents
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @param element Node data
-     * @returns MimeNode node element
-     */
-    _createContentNode(parentNode: MimeNode | false, element?: MailComposerAttachment): MimeNode;
-    /**
-     * Parses data uri and converts it to a Buffer
-     *
-     * @param element Content element
-     * @return Parsed element
-     */
-    _processDataUrl<T extends MailComposerAlternative>(element: T): T;
 }
 /**
  * Type alias in the layout of the other modules (@types/nodemailer had no namespace for MailComposer)

package/dist/cjs/mail-composer/index.js

@@ -219,6 +219,7 @@ class MailComposer {
      * and the buffered result is reused by the second node.
      *
      * @returns Normalized icalEvent data
+     * @internal
      */
     _getIcalEvent() {
         if (!this._icalEvent) {
@@ -383,6 +384,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createMixed(parentNode) {
         const node = parentNode
@@ -424,6 +426,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createAlternative(parentNode) {
         const node = parentNode
@@ -457,6 +460,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createRelated(parentNode) {
         const node = parentNode
@@ -485,6 +489,7 @@ class MailComposer {
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @param element Node data
      * @returns MimeNode node element
+     * @internal
      */
     _createContentNode(parentNode, element) {
         element = element || {};
@@ -545,6 +550,7 @@ class MailComposer {
      *
      * @param element Content element
      * @return Parsed element
+     * @internal
      */
     _processDataUrl(element) {
         const dataUrl = element.path || element.href;