@nocobase/plugin-workflow-mailer 2.3.0-beta.13 → 2.3.0-beta.15

package/dist/node_modules/nodemailer/dist/cjs/mailer/mail-message.d.ts

@@ -0,0 +1,97 @@
+import MimeNode, { type MimeNodePreparedHeaderValue } from '../mime-node/index.js';
+import type { MailComposerOptions } from '../mail-composer/index.js';
+import type { DKIMOptions } from '../dkim/index.js';
+import type { SMTPEnvelopeDsn } from '../smtp-connection/index.js';
+import type { SMTPTransportAuthOptions } from '../smtp-transport/index.js';
+import type { SESSendEmailRequest } from '../ses-transport/index.js';
+import type { NodemailerError } from '../errors.js';
+import type { ResolveContentOptions } from '../shared/index.js';
+import type Mail from './index.js';
+import type { SentMessageInfo } from './index.js';
+/**
+ * The message data accepted by sendMail. MailComposerOptions describes the fields the MIME
+ * tree is built from, the fields below are the ones the mailer reads on top of those
+ */
+export interface SendMailOptions extends MailComposerOptions {
+    /** DKIM signing options for this message, used instead of the ones of the transporter */
+    dkim?: DKIMOptions | undefined;
+    /** Extra DKIM options for this message, merged over the options of the signer. The SES transport sets skipFields here, the option is not meant for callers */
+    _dkim?: DKIMOptions | undefined;
+    /** Recipients allowed on this message, 0 disables the limit, defaults to 100000 */
+    maxRecipients?: number | undefined;
+    /** SMTP transports: DSN parameters for the envelope, sent when the server supports the DSN extension */
+    dsn?: SMTPEnvelopeDsn | undefined;
+    /** SMTP transports: RFC 8689, send the REQUIRETLS parameter with MAIL FROM */
+    requireTLSExtensionEnabled?: boolean | undefined;
+    /** SMTP transports: per-message authentication settings, used instead of the transport level auth */
+    auth?: SMTPTransportAuthOptions | undefined;
+    /** SES transport: extra SendEmailCommand parameters merged into the API call */
+    ses?: SESSendEmailRequest | undefined;
+}
+/**
+ * Default message fields, the third argument of createTransport. Applied to every message
+ * for the fields the message does not set itself, the headers are merged one by one
+ */
+export type MailDefaults = SendMailOptions;
+/**
+ * The message data as held by a MailMessage: the options the caller passed to sendMail with
+ * the transporter defaults applied. resolveAll rewrites the content and address fields in
+ * place and normalize adds the envelope, the Message-ID and the normalized headers
+ */
+export interface MailMessageData extends SendMailOptions {
+    /** Header values flattened to strings and keyed by lowercase header name, set by normalize */
+    normalizedHeaders?: {
+        [key: string]: string;
+    } | undefined;
+}
+/**
+ * Callback for resolveAll and normalize, receives the message data with every content value
+ * resolved
+ */
+export type MailMessageDataCallback = (err: NodemailerError | null, data: MailMessageData) => void;
+/**
+ * Callback for resolveContent, receives the resolved content value
+ */
+export type MailMessageContentCallback = (err: NodemailerError | null, value?: any) => void;
+/**
+ * A single prepared List-* header value, emitted as is
+ */
+export interface MailMessageListHeaderValue extends MimeNodePreparedHeaderValue {
+    prepared: boolean;
+    foldLines: boolean;
+    value: string;
+}
+/**
+ * A List-* header as built from the list value, one prepared value per list entry
+ */
+export interface MailMessageListHeader {
+    /** Header key, 'list-' followed by the lowercase list key */
+    key: string;
+    value: MailMessageListHeaderValue[];
+}
+export default class MailMessage<T = SentMessageInfo> {
+    mailer: Mail<T>;
+    data: MailMessageData;
+    /**
+     * The compiled MIME tree. Set once the compile step is done, so it is null while the
+     * 'compile' plugins run and set by the time the 'stream' plugins and the transport see
+     * the message. Declared as always set, the way @types/nodemailer declared it, since the
+     * plugins that read it are the ones that run after it is set
+     */
+    message: MimeNode;
+    constructor(mailer: Mail<T>, data?: SendMailOptions);
+    resolveContent(data: {
+        [key: string]: any;
+    }, key: string | number, callback: MailMessageContentCallback): void;
+    resolveContent(data: {
+        [key: string]: any;
+    }, key: string | number, options: ResolveContentOptions | false | undefined, callback: MailMessageContentCallback): void;
+    resolveContent(data: {
+        [key: string]: any;
+    }, key: string | number, options?: ResolveContentOptions | false): Promise<any>;
+    resolveAll(callback: MailMessageDataCallback): void;
+    normalize(callback: MailMessageDataCallback): void;
+    setMailerHeader(): void;
+    setPriorityHeaders(): void;
+    setListHeaders(): void;
+}

package/dist/node_modules/nodemailer/dist/cjs/mailer/mail-message.js

@@ -0,0 +1,342 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared = __importStar(require("../shared/index.js"));
+const index_js_1 = __importDefault(require("../mime-node/index.js"));
+const mimeFuncs = __importStar(require("../mime-funcs/index.js"));
+// Only an own key counts as already set. `key in obj` also matches every member of
+// Object.prototype, which silently drops a transporter default legitimately named
+// toString or constructor.
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+class MailMessage {
+    constructor(mailer, data) {
+        this.mailer = mailer;
+        this.data = {};
+        this.message = null;
+        data = data || {};
+        const options = mailer.options || {};
+        const defaults = mailer._defaults || {};
+        shared.copyOwnKeys(this.data, data);
+        this.data.headers = this.data.headers || {};
+        // Apply defaults. `_defaults` is caller supplied too, it is the second argument of
+        // createTransport, so it needs the same treatment as `data` above
+        shared.copyOwnKeys(this.data, defaults, key => hasOwn(this.data, key));
+        // headers is a special case. Allow setting individual default headers
+        shared.copyOwnKeys(this.data.headers, defaults.headers, key => hasOwn(this.data.headers, key));
+        // force specific keys from transporter options
+        ['disableFileAccess', 'disableUrlAccess', 'normalizeHeaderKey', 'maxRecipients'].forEach(key => {
+            if (key in options) {
+                this.data[key] = options[key];
+            }
+        });
+        // The access flags are a sandbox rather than a message field, so `defaults` counts as
+        // transporter configuration for them. For a transporter plugin it is the only channel
+        // there is, createTransport leaves `options` undefined for one, and the defaults copy
+        // above yields to anything the message already set, which let message data switch the
+        // sandbox back off. Closing is one way here, same as in resolveContent below: either
+        // side may switch a flag on, neither can switch off what the other closed.
+        ['disableFileAccess', 'disableUrlAccess'].forEach(key => {
+            if (!(key in options) && hasOwn(defaults, key)) {
+                this.data[key] = this.data[key] || defaults[key];
+            }
+        });
+    }
+    resolveContent(data, key, options, callback) {
+        // Most plugins call this with the legacy (data, key, callback) signature, which carries
+        // no access policy. The policy belongs to the message, so apply it here. Explicit
+        // options may only tighten it, never reopen what the transporter closed.
+        if (!callback && typeof options === 'function') {
+            callback = options;
+            options = false;
+        }
+        options = options || {};
+        const policy = {
+            disableFileAccess: this.data.disableFileAccess || options.disableFileAccess,
+            disableUrlAccess: this.data.disableUrlAccess || options.disableUrlAccess
+        };
+        return shared.resolveContent(data, key, policy, callback);
+    }
+    resolveAll(callback) {
+        const keys = [
+            [this.data, 'html'],
+            [this.data, 'text'],
+            [this.data, 'watchHtml'],
+            [this.data, 'amp'],
+            [this.data, 'icalEvent']
+        ];
+        if (this.data.alternatives && this.data.alternatives.length) {
+            this.data.alternatives.forEach((alternative, i) => {
+                keys.push([this.data.alternatives, i]);
+            });
+        }
+        if (this.data.attachments && this.data.attachments.length) {
+            this.data.attachments.forEach((attachment, i) => {
+                if (!attachment.filename) {
+                    // a backslash separates as well, so a Windows path does not put the sender's directories in the headers
+                    attachment.filename =
+                        (attachment.path || attachment.href || '').split(/[/\\]/).pop().split('?').shift() ||
+                            'attachment-' + (i + 1);
+                    if (attachment.filename.indexOf('.') < 0) {
+                        attachment.filename += '.' + mimeFuncs.detectExtension(attachment.contentType);
+                    }
+                }
+                if (!attachment.contentType) {
+                    attachment.contentType = mimeFuncs.detectMimeType(attachment.filename || attachment.path || attachment.href || 'bin');
+                }
+                keys.push([this.data.attachments, i]);
+            });
+        }
+        const mimeNode = new index_js_1.default();
+        const addressKeys = ['from', 'to', 'cc', 'bcc', 'sender', 'replyTo'];
+        addressKeys.forEach(address => {
+            let value;
+            if (this.message) {
+                value = [].concat(mimeNode._parseAddresses(this.message.getHeader(address === 'replyTo' ? 'reply-to' : address)) || []);
+            }
+            else if (this.data[address]) {
+                value = [].concat(mimeNode._parseAddresses(this.data[address]) || []);
+            }
+            if (value && value.length) {
+                this.data[address] = value;
+            }
+            else if (address in this.data) {
+                this.data[address] = null;
+            }
+        });
+        const singleKeys = ['from', 'sender'];
+        singleKeys.forEach(address => {
+            if (this.data[address]) {
+                this.data[address] = this.data[address].shift();
+            }
+        });
+        let pos = 0;
+        const resolveNext = () => {
+            if (pos >= keys.length) {
+                return callback(null, this.data);
+            }
+            const args = keys[pos++];
+            if (!args[0] || !args[0][args[1]]) {
+                return resolveNext();
+            }
+            shared.resolveContent(...args, { disableFileAccess: this.data.disableFileAccess, disableUrlAccess: this.data.disableUrlAccess }, (err, value) => {
+                if (err) {
+                    return callback(err);
+                }
+                const node = {
+                    content: value
+                };
+                if (args[0][args[1]] && typeof args[0][args[1]] === 'object' && !Buffer.isBuffer(args[0][args[1]])) {
+                    // The keys are the caller's, so copying them takes the same "__proto__"
+                    // rule as the constructor. `key in node` stays as the already-set test
+                    // here, unlike for the defaults: it also skips the Object.prototype
+                    // member names, and letting message data land a `toString` string on a
+                    // node only buys a TypeError the first time something stringifies it.
+                    shared.copyOwnKeys(node, args[0][args[1]], key => key in node || ['content', 'path', 'href', 'raw'].includes(key));
+                }
+                args[0][args[1]] = node;
+                resolveNext();
+            });
+        };
+        setImmediate(() => resolveNext());
+    }
+    normalize(callback) {
+        const envelope = this.message.getEnvelope();
+        const messageId = this.message.messageId();
+        this.resolveAll((err, data) => {
+            if (err) {
+                return callback(err);
+            }
+            data.envelope = envelope;
+            data.messageId = messageId;
+            ['html', 'text', 'watchHtml', 'amp'].forEach(key => {
+                if (data[key] && data[key].content) {
+                    if (typeof data[key].content === 'string') {
+                        data[key] = data[key].content;
+                    }
+                    else if (Buffer.isBuffer(data[key].content)) {
+                        data[key] = data[key].content.toString();
+                    }
+                }
+            });
+            if (data.icalEvent && Buffer.isBuffer(data.icalEvent.content)) {
+                data.icalEvent.content = data.icalEvent.content.toString('base64');
+                data.icalEvent.encoding = 'base64';
+            }
+            if (data.alternatives && data.alternatives.length) {
+                data.alternatives.forEach((alternative) => {
+                    if (alternative && alternative.content && Buffer.isBuffer(alternative.content)) {
+                        alternative.content = alternative.content.toString('base64');
+                        alternative.encoding = 'base64';
+                    }
+                });
+            }
+            if (data.attachments && data.attachments.length) {
+                data.attachments.forEach((attachment) => {
+                    if (attachment && attachment.content && Buffer.isBuffer(attachment.content)) {
+                        attachment.content = attachment.content.toString('base64');
+                        attachment.encoding = 'base64';
+                    }
+                });
+            }
+            data.normalizedHeaders = {};
+            Object.keys(data.headers || {}).forEach(key => {
+                if (shared.isProtoKey(key)) {
+                    return;
+                }
+                let value = [].concat(data.headers[key] || []).shift();
+                value = (value && value.value) || value;
+                if (value) {
+                    if (['references', 'in-reply-to', 'message-id', 'content-id'].includes(key)) {
+                        value = this.message._encodeHeaderValue(key, value);
+                    }
+                    data.normalizedHeaders[key] = value;
+                }
+            });
+            if (data.list && typeof data.list === 'object') {
+                const listHeaders = this._getListHeaders(data.list);
+                listHeaders.forEach(entry => {
+                    data.normalizedHeaders[entry.key] = entry.value.map(val => (val && val.value) || val).join(', ');
+                });
+            }
+            if (data.references) {
+                data.normalizedHeaders.references = this.message._encodeHeaderValue('references', data.references);
+            }
+            if (data.inReplyTo) {
+                data.normalizedHeaders['in-reply-to'] = this.message._encodeHeaderValue('in-reply-to', data.inReplyTo);
+            }
+            return callback(null, data);
+        });
+    }
+    setMailerHeader() {
+        if (!this.message || !this.data.xMailer) {
+            return;
+        }
+        this.message.setHeader('X-Mailer', this.data.xMailer);
+    }
+    setPriorityHeaders() {
+        if (!this.message || !this.data.priority) {
+            return;
+        }
+        switch ((this.data.priority || '').toString().toLowerCase()) {
+            case 'high':
+                this.message.setHeader('X-Priority', '1 (Highest)');
+                this.message.setHeader('X-MSMail-Priority', 'High');
+                this.message.setHeader('Importance', 'High');
+                break;
+            case 'low':
+                this.message.setHeader('X-Priority', '5 (Lowest)');
+                this.message.setHeader('X-MSMail-Priority', 'Low');
+                this.message.setHeader('Importance', 'Low');
+                break;
+            default:
+            // do not add anything, since all messages are 'Normal' by default
+        }
+    }
+    setListHeaders() {
+        if (!this.message || !this.data.list || typeof this.data.list !== 'object') {
+            return;
+        }
+        // add optional List-* headers
+        this._getListHeaders(this.data.list).forEach(listHeader => {
+            listHeader.value.forEach(value => {
+                this.message.addHeader(listHeader.key, value);
+            });
+        });
+    }
+    /** @internal */
+    _getListHeaders(listData) {
+        // make sure an url looks like <protocol:url>
+        return Object.keys(listData).map(key => ({
+            key: 'list-' + key.toLowerCase().trim(),
+            value: [].concat(listData[key] || []).map(value => ({
+                prepared: true,
+                foldLines: true,
+                value: []
+                    .concat(value || [])
+                    .map(value => {
+                    if (typeof value === 'string') {
+                        value = {
+                            url: value
+                        };
+                    }
+                    if (value && value.url) {
+                        // strip CR/LF so a comment can't inject extra header lines. DEL is neither
+                        // qtext nor ctext, so it can not be carried literally by either construct
+                        // and has to become an encoded word like any other non-plaintext value
+                        let comment = (value.comment || '').toString().replace(/\r?\n|\r/g, ' ');
+                        const needsEncoding = !mimeFuncs.isPlainText(comment) || /\x7f/.test(comment);
+                        if (key.toLowerCase().trim() === 'id') {
+                            // List-ID: "comment" <domain>, where an unescaped quote or a trailing
+                            // backslash in the comment would swallow the <domain> behind it
+                            comment = needsEncoding ? mimeFuncs.encodeWord(comment) : mimeFuncs.quoteString(comment);
+                            // List-ID expects a bare domain-like identifier, so strip the
+                            // scheme prefix that _formatListUrl adds or passes through
+                            return ((value.comment ? comment + ' ' : '') + this._formatListUrl(value.url).replace(/^<[^:]+:\/{0,2}/, '<'));
+                        }
+                        // List-*: <http://domain> (comment)
+                        // the ctext specials go out as quoted-pairs, otherwise a ")" closes the
+                        // comment early and leaves the rest as junk, an unpaired "(" opens a
+                        // nested comment that never closes, and a trailing backslash escapes
+                        // the closing ")" so the comment swallows whatever follows it
+                        comment = needsEncoding ? mimeFuncs.encodeWord(comment) : comment.replace(/[()\\]/g, '\\$&');
+                        return this._formatListUrl(value.url) + (value.comment ? ' (' + comment + ')' : '');
+                    }
+                    return '';
+                })
+                    .filter(value => value)
+                    .join(', ')
+            }))
+        }));
+    }
+    /** @internal */
+    _formatListUrl(url) {
+        // a url has no way to carry a control char or DEL, and the angle brackets around it
+        // are not a quoting construct, so anything left here lands in the header raw
+        url = url.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '').replace(/[\s<]+|[\s>]+/g, '');
+        if (/^(https?|mailto|ftp):/.test(url)) {
+            return '<' + url + '>';
+        }
+        if (/^[^@]+@[^@]+$/.test(url)) {
+            return '<mailto:' + url + '>';
+        }
+        return '<http://' + url + '>';
+    }
+}
+exports.default = MailMessage;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/node_modules/nodemailer/dist/cjs/mime-funcs/index.d.ts

@@ -0,0 +1,161 @@
+/**
+ * A header value split into the value token and its parameters, the result of parseHeaderValue
+ */
+export interface ParsedHeaderValue {
+    /** The value ahead of the parameters, for example the content type, an empty string when there is none */
+    value: string;
+    /** Parameter values keyed by lowercase parameter name */
+    params: Record<string, string>;
+}
+/**
+ * Header value structure accepted by buildHeaderValue
+ */
+export interface StructuredHeaderValue {
+    /** The value ahead of the parameters, for example the content type */
+    value: string | false;
+    /** Parameter values keyed by parameter name */
+    params?: Record<string, string> | undefined;
+}
+/**
+ * A single key=value pair of an rfc2231 encoded header parameter
+ */
+export interface EncodedHeaderParam {
+    /** Parameter name with the continuation suffix, for example title*0* */
+    key: string;
+    /** Parameter value of this part */
+    value: string;
+}
+/** The names @types/nodemailer used for the two types above */
+export type HeaderValue = StructuredHeaderValue;
+export type ParsedHeaderParam = EncodedHeaderParam;
+/**
+ * Checks if a value is plaintext string (uses only printable 7bit chars)
+ *
+ * When isParam is set the value is destined for a header parameter, so HT, CR and LF
+ * are not plaintext either: a header parameter has no way to carry them. HT is a valid
+ * fold point, so folding and unfolding a header would rewrite it as a space, and CR/LF
+ * cannot appear in a header value at all. DEL is neither a token character nor qtext,
+ * so it can not be carried bare or quoted. Such values have to go through the rfc2231
+ * parameter continuation encoding instead, the same way a quote already does.
+ *
+ * @param value String to be tested
+ * @param [isParam] Set to true if the value is a header parameter value
+ * @returns true if it is a plaintext string
+ */
+export declare function isPlainText(value: unknown, isParam?: boolean): boolean;
+/**
+ * Wraps a value into a quoted-string. Inside one a quote would end the string early
+ * and a backslash would escape whatever follows it, so both go out as quoted-pairs.
+ *
+ * @param value String to be quoted
+ * @returns The value as a quoted-string, quotes included
+ */
+export declare function quoteString(value?: string): string;
+/**
+ * Checks if a multi line string containes lines longer than the selected value.
+ *
+ * Useful when detecting if a mail message needs any processing at all:
+ * if only plaintext characters are used and lines are short, then there is
+ * no need to encode the values in any way. If the value is plaintext but has
+ * longer lines then allowed, then use format=flowed
+ *
+ * @param str Multi line string to check
+ * @param lineLength Max line length to check for
+ * @returns Returns true if there is at least one line longer than lineLength chars
+ */
+export declare function hasLongerLines(str: string, lineLength: number): boolean;
+/**
+ * Encodes a string or an Buffer to an UTF-8 MIME Word (rfc2047)
+ *
+ * @param data String to be encoded
+ * @param mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+ * @param [maxLength=0] If set, split mime words into several chunks if needed
+ * @return Single or several mime words joined together
+ */
+export declare function encodeWord(data: string | Buffer, mimeWordEncoding?: string, maxLength?: number): string;
+/**
+ * Finds word sequences with non ascii text and converts these to mime words
+ *
+ * @param value String to be encoded
+ * @param mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+ * @param [maxLength=0] If set, split mime words into several chunks if needed
+ * @param [encodeAll=false] If true and the value needs encoding then encodes entire string, not just the smallest match
+ * @return String with possible mime words
+ */
+export declare function encodeWords(value: string, mimeWordEncoding?: string, maxLength?: number, encodeAll?: boolean): string;
+/**
+ * Joins parsed header value together as 'value; param1=value1; param2=value2'
+ * PS: We are following RFC 822 for the list of special characters that we need to keep in quotes.
+ *      Refer: https://www.w3.org/Protocols/rfc1341/4_Content-Type.html
+ * @param structured Parsed header value
+ * @return joined header value
+ */
+export declare function buildHeaderValue(structured: StructuredHeaderValue): string;
+/**
+ * Encodes a string or an Buffer to an UTF-8 Parameter Value Continuation encoding (rfc2231)
+ * Useful for splitting long parameter values.
+ *
+ * For example
+ *      title="unicode string"
+ * becomes
+ *     title*0*=utf-8''unicode
+ *     title*1*=%20string
+ *
+ * @param key Parameter name the generated keys are built from, for example title
+ * @param data String to be encoded
+ * @param [maxLength=50] Max length for generated chunks
+ * @return A list of encoded keys and headers
+ */
+export declare function buildHeaderParam(key: string, data: string | Buffer, maxLength?: number): EncodedHeaderParam[];
+/**
+ * Parses a header value with key=value arguments into a structured
+ * object.
+ *
+ *   parseHeaderValue('content-type: text/plain; CHARSET='UTF-8'') ->
+ *   {
+ *     'value': 'text/plain',
+ *     'params': {
+ *       'charset': 'UTF-8'
+ *     }
+ *   }
+ *
+ * @param str Header value
+ * @return Header value as a parsed structure
+ */
+export declare function parseHeaderValue(str: string): ParsedHeaderValue;
+/**
+ * Returns file extension for a content type string. If no suitable extensions
+ * are found, 'bin' is used as the default extension
+ *
+ * @param mimeType Content type to be checked for
+ * @return File extension
+ */
+export declare function detectExtension(mimeType?: string | false): string;
+/**
+ * Returns content type for a file extension. If no suitable content types
+ * are found, 'application/octet-stream' is used as the default content type
+ *
+ * @param extension Extension to be checked for
+ * @return File extension
+ */
+export declare function detectMimeType(extension?: string | false): string;
+/**
+ * Folds long lines, useful for folding header lines (afterSpace=false) and
+ * flowed text (afterSpace=true)
+ *
+ * @param str String to be folded
+ * @param [lineLength=76] Maximum length of a line
+ * @param afterSpace If true, leave a space in th end of a line
+ * @return String with folded lines
+ */
+export declare function foldLines(str: string, lineLength?: number, afterSpace?: boolean): string;
+/**
+ * Splits a mime encoded string. Needed for dividing mime words into smaller chunks
+ *
+ * @param str Mime encoded string to be split up
+ * @param maxlen Maximum length of characters for one part (minimum 12)
+ * @return Split string
+ */
+export declare function splitMimeEncodedString(str: string, maxlen?: number): string[];
+export declare function encodeURICharComponent(chr: string): string;
+export declare function safeEncodeURIComponent(str: string): string;