@nocobase/plugin-workflow-mailer 2.3.0-beta.12 → 2.3.0-beta.14

package/dist/node_modules/nodemailer/dist/esm/fetch/index.js

@@ -0,0 +1,344 @@
+import http from 'node:http';
+import https from 'node:https';
+import * as urllib from '../shared/url.js';
+import zlib from 'node:zlib';
+import { PassThrough } from 'node:stream';
+import Cookies from './cookies.js';
+import * as packageData from '../package-info.js';
+import net from 'node:net';
+import * as errors from '../errors.js';
+import { isProtoKey } from '../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
+// the URL checks below.
+//
+// The source of truth is the tls.connect() option list in the Node docs. A key missing
+// here is dropped silently, so extend this list rather than working around it.
+const TLS_OPTION_KEYS = [
+    'ALPNProtocols',
+    'ca',
+    'cert',
+    'checkServerIdentity',
+    'ciphers',
+    'crl',
+    'dhparam',
+    'ecdhCurve',
+    'honorCipherOrder',
+    'key',
+    'maxVersion',
+    'minVersion',
+    'passphrase',
+    'pfx',
+    'rejectUnauthorized',
+    'secureContext',
+    'secureOptions',
+    'secureProtocol',
+    'servername',
+    'sessionIdContext',
+    'sigalgs'
+];
+/**
+ * Resolves a URL only if it is one this module is willing to request.
+ *
+ * urllib.parse throws for a host that contains forbidden bytes, and it is called for
+ * every URL that reaches nmfetch, including ones that arrive from a message attachment
+ * or from a redirect Location header. An uncaught throw here takes the process down,
+ * so a URL that does not parse is reported the same way as one with a scheme we refuse.
+ *
+ * @param url URL to parse
+ * @returns Parsed URL, or false if it is not a usable http(s) URL
+ */
+function parseFetchUrl(url) {
+    let parsed;
+    try {
+        parsed = urllib.parse(url);
+    }
+    catch (_err) {
+        return false;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return false;
+    }
+    return parsed;
+}
+function nmfetch(url, options) {
+    options = options || {};
+    options.fetchRes = options.fetchRes || new PassThrough();
+    options.cookies = options.cookies || new Cookies();
+    options.redirects = options.redirects || 0;
+    options.maxRedirects = isNaN(options.maxRedirects) ? MAX_REDIRECTS : options.maxRedirects;
+    const fetchRes = options.fetchRes;
+    const parsed = parseFetchUrl(url);
+    if (!parsed) {
+        // Only http(s) URLs can be fetched. Any other scheme (file:, gopher:, a
+        // protocol-relative redirect target etc.) would otherwise be silently served over
+        // plain HTTP, possibly against an unintended host. Bail out before the cookie jar
+        // is touched so a refused URL can not seed it, and release a caller supplied body:
+        // this is the one exit that runs before the error handler below is attached to it,
+        // so an error on that stream would have nowhere to go and the fd or socket behind
+        // it would never be released.
+        if (options.body && typeof options.body.destroy === 'function') {
+            options.body.on('error', () => false);
+            options.body.destroy();
+        }
+        setImmediate(() => {
+            const err = new Error('Unsupported protocol for URL ' + url);
+            err.code = errors.EFETCH;
+            err.sourceUrl = url;
+            fetchRes.emit('error', err);
+        });
+        return fetchRes;
+    }
+    if (options.cookie) {
+        [].concat(options.cookie || []).forEach(cookie => {
+            options.cookies.set(cookie, url);
+        });
+        options.cookie = false;
+    }
+    let method = (options.method || '').toString().trim().toUpperCase() || 'GET';
+    let finished = false;
+    let cookies;
+    let body;
+    const handler = parsed.protocol === 'https:' ? https : http;
+    const headers = {
+        'accept-encoding': 'gzip,deflate',
+        'user-agent': 'nodemailer/' + packageData.version
+    };
+    Object.keys(options.headers || {}).forEach(key => {
+        // options.headers is the caller's httpHeaders, straight off an attachment
+        if (isProtoKey(key.toLowerCase().trim())) {
+            return;
+        }
+        headers[key.toLowerCase().trim()] = options.headers[key];
+    });
+    if (options.userAgent) {
+        headers['user-agent'] = options.userAgent;
+    }
+    if (parsed.auth) {
+        headers.Authorization = 'Basic ' + Buffer.from(parsed.auth).toString('base64');
+    }
+    if ((cookies = options.cookies.get(url))) {
+        headers.cookie = cookies;
+    }
+    if (options.body) {
+        if (options.contentType !== false) {
+            headers['Content-Type'] = options.contentType || 'application/x-www-form-urlencoded';
+        }
+        if (typeof options.body.pipe === 'function') {
+            // it's a stream
+            headers['Transfer-Encoding'] = 'chunked';
+            body = options.body;
+            body.on('error', (err) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                err.code = errors.EFETCH;
+                err.sourceUrl = url;
+                fetchRes.emit('error', err);
+            });
+        }
+        else {
+            if (options.body instanceof Buffer) {
+                body = options.body;
+            }
+            else if (typeof options.body === 'object') {
+                try {
+                    // encodeURIComponent can fail on invalid input (partial emoji etc.)
+                    body = Buffer.from(Object.keys(options.body)
+                        .map(key => {
+                        const value = options.body[key].toString().trim();
+                        return encodeURIComponent(key) + '=' + encodeURIComponent(value);
+                    })
+                        .join('&'));
+                }
+                catch (E) {
+                    // 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;
+                    setImmediate(() => fetchRes.emit('error', E));
+                    return fetchRes;
+                }
+            }
+            else {
+                body = Buffer.from(options.body.toString().trim());
+            }
+            headers['Content-Type'] = options.contentType || 'application/x-www-form-urlencoded';
+            headers['Content-Length'] = body.length;
+        }
+        // if method is not provided, use POST instead of GET
+        method = (options.method || '').toString().trim().toUpperCase() || 'POST';
+    }
+    let req;
+    const reqOptions = {
+        method,
+        host: parsed.hostname,
+        path: parsed.path,
+        port: parsed.port ? parsed.port : parsed.protocol === 'https:' ? 443 : 80,
+        headers,
+        // Validate TLS certificates by default. Callers that genuinely need to
+        // reach a self-signed/internal host opt out explicitly with
+        // options.tls = { rejectUnauthorized: false }.
+        rejectUnauthorized: true,
+        agent: false
+    };
+    if (options.tls) {
+        // see TLS_OPTION_KEYS
+        Object.keys(options.tls).forEach(key => {
+            if (TLS_OPTION_KEYS.includes(key)) {
+                reqOptions[key] = options.tls[key];
+            }
+        });
+    }
+    if (parsed.protocol === 'https:' &&
+        parsed.hostname &&
+        parsed.hostname !== reqOptions.host &&
+        !net.isIP(parsed.hostname) &&
+        !reqOptions.servername) {
+        reqOptions.servername = parsed.hostname;
+    }
+    try {
+        req = handler.request(reqOptions);
+    }
+    catch (E) {
+        finished = true;
+        setImmediate(() => {
+            E.code = errors.EFETCH;
+            E.sourceUrl = url;
+            fetchRes.emit('error', E);
+        });
+        return fetchRes;
+    }
+    // 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 = 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) {
+            return;
+        }
+        switch (res.headers['content-encoding']) {
+            case 'gzip':
+            case 'deflate':
+                inflate = zlib.createUnzip();
+                break;
+        }
+        if (res.headers['set-cookie']) {
+            [].concat(res.headers['set-cookie'] || []).forEach(cookie => {
+                options.cookies.set(cookie, url);
+            });
+        }
+        if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+            // redirect
+            options.redirects++;
+            if (options.redirects > options.maxRedirects) {
+                return fail(new Error('Maximum redirect count exceeded'));
+            }
+            // redirect does not include POST body
+            options.method = 'GET';
+            options.body = false;
+            let redirectUrl;
+            try {
+                redirectUrl = urllib.resolve(url, res.headers.location);
+            }
+            catch (_err) {
+                // the legacy resolver throws on a Location the WHATWG parser also refused,
+                // so fall through to the check below with what the server actually sent
+                redirectUrl = res.headers.location;
+            }
+            const redirectParsed = parseFetchUrl(redirectUrl);
+            if (!redirectParsed) {
+                // Refuse the redirect target here rather than leaving it to the recursive
+                // 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().
+                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
+            // http (which would otherwise put them on the wire in cleartext).
+            // Strip sensitive request headers so an attacker who controls the
+            // redirect target cannot harvest them.
+            const crossHost = redirectParsed.hostname !== parsed.hostname;
+            const downgrade = parsed.protocol === 'https:' && redirectParsed.protocol === 'http:';
+            if (options.headers && (crossHost || downgrade)) {
+                const sensitive = ['authorization', 'cookie', 'proxy-authorization'];
+                Object.keys(options.headers).forEach(key => {
+                    if (sensitive.includes(key.toLowerCase())) {
+                        delete options.headers[key];
+                    }
+                });
+            }
+            // 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) {
+            return fail(new Error('Invalid status code ' + res.statusCode));
+        }
+        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;
+            }
+            source.unpipe(fetchRes);
+            fail(new Error('Response size exceeds the allowed ' + maxBytes + ' bytes'));
+        });
+        if (inflate) {
+            res.pipe(inflate).pipe(fetchRes);
+            inflate.on('error', (err) => fail(err));
+        }
+        else {
+            res.pipe(fetchRes);
+        }
+    });
+    setImmediate(() => {
+        if (body) {
+            try {
+                if (typeof body.pipe === 'function') {
+                    return body.pipe(req);
+                }
+                req.write(body);
+            }
+            catch (err) {
+                return fail(err);
+            }
+        }
+        req.end();
+    });
+    return fetchRes;
+}
+nmfetch.Cookies = Cookies;
+nmfetch.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+export default nmfetch;

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

@@ -0,0 +1,64 @@
+import type { Logger } from '../shared/index.js';
+import type { MimeNodeEnvelope } from '../mime-node/index.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
+ */
+export interface JSONTransportOptions extends TransportOptions {
+    /** Selects this transport in createTransport */
+    jsonTransport?: boolean | undefined;
+    /** If true, the message is returned as an object instead of a JSON string */
+    skipEncoding?: boolean | undefined;
+}
+/**
+ * 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<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: 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
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+declare class JSONTransport {
+    mailer: Mail<JSONSentMessageInfo>;
+    options: JSONTransportOptions;
+    name: string;
+    version: string;
+    logger: Logger;
+    constructor(options?: JSONTransportOptions);
+    /**
+     * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
+     *
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail: MailMessage<JSONSentMessageInfo>, done: (err: Error | null, info?: JSONSentMessageInfo) => void): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `JSONTransport.Options` style references keep working
+ */
+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/node_modules/nodemailer/dist/esm/json-transport/index.js

@@ -0,0 +1,62 @@
+import * as packageData from '../package-info.js';
+import * as shared from '../shared/index.js';
+/**
+ * Generates a Transport object to generate JSON output
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+class JSONTransport {
+    constructor(options) {
+        options = options || {};
+        this.options = options;
+        this.name = 'JSONTransport';
+        this.version = packageData.version;
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'json-transport'
+        });
+    }
+    /**
+     * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
+     *
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail, done) {
+        // Sendmail strips this header line by itself. send() runs after the message was
+        // compiled, so mail.message is set
+        mail.message.keepBcc = true;
+        const envelope = mail.message.getEnvelope();
+        const messageId = mail.message.messageId();
+        const recipients = [].concat(envelope.to || []);
+        if (recipients.length > 3) {
+            recipients.push('...and ' + recipients.splice(2).length + ' more');
+        }
+        this.logger.info({
+            tnx: 'send',
+            messageId
+        }, 'Composing JSON structure of %s to <%s>', messageId, recipients.join(', '));
+        setImmediate(() => {
+            mail.normalize((err, data) => {
+                if (err) {
+                    this.logger.error({
+                        err,
+                        tnx: 'send',
+                        messageId
+                    }, 'Failed building JSON structure for %s. %s', messageId, err.message);
+                    return done(err);
+                }
+                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,
+                    message: this.options.skipEncoding ? data : JSON.stringify(data)
+                });
+            });
+        });
+    }
+}
+export default JSONTransport;

package/dist/node_modules/nodemailer/dist/esm/mail-composer/index.d.ts

@@ -0,0 +1,174 @@
+import MimeNode, { type MimeNodeAddressInput, type MimeNodeContent, type MimeNodeEnvelopeInput, type MimeNodeHeaders, type MimeNodeOptions } from '../mime-node/index.js';
+import type { Readable } from 'node:stream';
+import type { OutgoingHttpHeaders } from 'node:http';
+/**
+ * A content element, the shape of the text, html, watchHtml, amp and alternatives values.
+ * The content is either given in `content`, read from `path` or `href`, or `raw` supplies
+ * a pregenerated MIME part
+ */
+export interface MailComposerAlternative {
+    /** The content itself: a string, a Buffer, a readable stream or a content descriptor */
+    content?: MimeNodeContent | undefined;
+    /** File path, data URI or http(s) URL to read the content from */
+    path?: string | false | undefined;
+    /** URL or data URI to fetch the content from */
+    href?: string | false | undefined;
+    /** Request headers for a URL fetch */
+    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 | undefined;
+    /** Pregenerated MIME part, used as is instead of building the node */
+    raw?: MimeNodeContent | undefined;
+    /** Content type, detected from the filename, path or URL when not set */
+    contentType?: string | undefined;
+    /** Content-Transfer-Encoding for the node, false leaves the choice to the node */
+    contentTransferEncoding?: string | false | undefined;
+    /** Filename for the node, false suppresses the generated one */
+    filename?: string | false | undefined;
+    /** Additional headers for the node */
+    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 | undefined;
+    /** Content-Id for an embedded image, moves the attachment into the multipart/related node beside the html */
+    cid?: string | undefined;
+}
+/**
+ * The icalEvent value as an object
+ */
+export interface MailComposerIcalEvent extends MailComposerAlternative {
+    /** iCalendar method, PUBLISH by default */
+    method?: string | undefined;
+}
+/**
+ * The attachments as sorted by getAttachments
+ */
+export interface MailComposerAttachments {
+    /** Attachments for the multipart/mixed node, the icalEvent attachment included */
+    attached: MailComposerAttachment[];
+    /** Attachments with a cid, embedded in the multipart/related node beside the html */
+    related: MailComposerAttachment[];
+}
+/**
+ * A List-* header entry, a bare url or an url with a comment
+ */
+export type MailComposerListHeaderEntry = string | {
+    url: string;
+    comment?: string | undefined;
+};
+/**
+ * The list value: List-* headers keyed by the part after "List-" (help, unsubscribe,
+ * subscribe, post, owner, archive, id). An array emits one header per entry, an entry that
+ * is itself an array joins its values into one header
+ */
+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
+ * node. Some fields are read by the mailer that hands the data to MailComposer rather than
+ * by MailComposer itself, these are marked as such
+ */
+export interface MailComposerOptions {
+    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 | undefined;
+    /** Date header value, the current time when missing */
+    date?: Date | string | undefined;
+    /** Plaintext version of the message */
+    text?: string | Buffer | Readable | MailComposerAlternative | undefined;
+    /** HTML version of the message */
+    html?: string | Buffer | Readable | MailComposerAlternative | undefined;
+    /** Apple Watch specific HTML version of the message */
+    watchHtml?: string | Buffer | Readable | MailComposerAlternative | undefined;
+    /** AMP4EMAIL version of the message */
+    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 | undefined;
+    attachments?: MailComposerAttachment[] | undefined;
+    /** Further alternatives for the multipart/alternative node, after text, watchHtml, amp, html and the calendar event */
+    alternatives?: MailComposerAlternative[] | undefined;
+    /** Custom headers for the root node, the standard headers above override them */
+    headers?: MimeNodeHeaders | undefined;
+    /** List-* headers, read by the mailer */
+    list?: MailComposerListHeaders | undefined;
+    /** SMTP envelope to use instead of the one generated from the headers */
+    envelope?: MimeNodeEnvelopeInput | undefined;
+    /** 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?: MailComposerTextEncoding | undefined;
+    /** Pregenerated rfc822 message, used as is instead of building one */
+    raw?: MimeNodeContent | undefined;
+    /** Reject content that points to a URL */
+    disableUrlAccess?: boolean | undefined;
+    /** Reject content that points to a file path */
+    disableFileAccess?: boolean | undefined;
+    /** Convert data: images in the html into embedded attachments, read by the mailer */
+    attachDataUrls?: boolean | undefined;
+    /** Prefix for the generated multipart boundaries */
+    boundaryPrefix?: string | undefined;
+    /** Shared part of the unique multipart boundary */
+    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;
+    /** Method to normalize header keys for custom caseing */
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
+    /** 'high', 'normal' or 'low', sets the priority headers, read by the mailer */
+    priority?: string | undefined;
+    /** X-Mailer header value, false leaves the header out, read by the mailer */
+    xMailer?: string | false | undefined;
+}
+declare class MailComposer {
+    mail: MailComposerOptions;
+    message: MimeNode | false;
+    constructor(mail?: MailComposerOptions);
+    /**
+     * Builds MimeNode instance
+     */
+    compile(): MimeNode;
+    /**
+     * List all attachments. Resulting attachment objects can be used as input for MimeNode nodes
+     *
+     * @param findRelated If true separate related attachments from attached ones
+     * @returns An object of arrays (`related` and `attached`)
+     */
+    getAttachments(findRelated?: boolean): MailComposerAttachments;
+    /**
+     * 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[];
+}
+/**
+ * Type alias in the layout of the other modules (@types/nodemailer had no namespace for 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;