@mavogel/awscdk-rootmail 0.1.24 → 0.1.25

package/node_modules/libmime/dist/cjs/charsets.js

@@ -0,0 +1,213 @@
+"use strict";
+// Charset name aliases, keyed by the lowercased alias, mapped to the canonical name
+Object.defineProperty(exports, "__esModule", { value: true });
+const charsets = {
+    '866': 'IBM866',
+    'unicode-1-1-utf-8': 'UTF-8',
+    'utf-8': 'UTF-8',
+    utf8: 'UTF-8',
+    cp866: 'IBM866',
+    csibm866: 'IBM866',
+    ibm866: 'IBM866',
+    csisolatin2: 'ISO-8859-2',
+    'iso-8859-2': 'ISO-8859-2',
+    'iso-ir-101': 'ISO-8859-2',
+    'iso8859-2': 'ISO-8859-2',
+    iso88592: 'ISO-8859-2',
+    'iso_8859-2': 'ISO-8859-2',
+    'iso_8859-2:1987': 'ISO-8859-2',
+    l2: 'ISO-8859-2',
+    latin2: 'ISO-8859-2',
+    csisolatin3: 'ISO-8859-3',
+    'iso-8859-3': 'ISO-8859-3',
+    'iso-ir-109': 'ISO-8859-3',
+    'iso8859-3': 'ISO-8859-3',
+    iso88593: 'ISO-8859-3',
+    'iso_8859-3': 'ISO-8859-3',
+    'iso_8859-3:1988': 'ISO-8859-3',
+    l3: 'ISO-8859-3',
+    latin3: 'ISO-8859-3',
+    csisolatin4: 'ISO-8859-4',
+    'iso-8859-4': 'ISO-8859-4',
+    'iso-ir-110': 'ISO-8859-4',
+    'iso8859-4': 'ISO-8859-4',
+    iso88594: 'ISO-8859-4',
+    'iso_8859-4': 'ISO-8859-4',
+    'iso_8859-4:1988': 'ISO-8859-4',
+    l4: 'ISO-8859-4',
+    latin4: 'ISO-8859-4',
+    csisolatincyrillic: 'ISO-8859-5',
+    cyrillic: 'ISO-8859-5',
+    'iso-8859-5': 'ISO-8859-5',
+    'iso-ir-144': 'ISO-8859-5',
+    'iso8859-5': 'ISO-8859-5',
+    iso88595: 'ISO-8859-5',
+    'iso_8859-5': 'ISO-8859-5',
+    'iso_8859-5:1988': 'ISO-8859-5',
+    arabic: 'ISO-8859-6',
+    'asmo-708': 'ISO-8859-6',
+    csiso88596e: 'ISO-8859-6',
+    csiso88596i: 'ISO-8859-6',
+    csisolatinarabic: 'ISO-8859-6',
+    'ecma-114': 'ISO-8859-6',
+    'iso-8859-6': 'ISO-8859-6',
+    'iso-8859-6-e': 'ISO-8859-6',
+    'iso-8859-6-i': 'ISO-8859-6',
+    'iso-ir-127': 'ISO-8859-6',
+    'iso8859-6': 'ISO-8859-6',
+    iso88596: 'ISO-8859-6',
+    'iso_8859-6': 'ISO-8859-6',
+    'iso_8859-6:1987': 'ISO-8859-6',
+    csisolatingreek: 'ISO-8859-7',
+    'ecma-118': 'ISO-8859-7',
+    elot_928: 'ISO-8859-7',
+    greek: 'ISO-8859-7',
+    greek8: 'ISO-8859-7',
+    'iso-8859-7': 'ISO-8859-7',
+    'iso-ir-126': 'ISO-8859-7',
+    'iso8859-7': 'ISO-8859-7',
+    iso88597: 'ISO-8859-7',
+    'iso_8859-7': 'ISO-8859-7',
+    'iso_8859-7:1987': 'ISO-8859-7',
+    sun_eu_greek: 'ISO-8859-7',
+    csiso88598e: 'ISO-8859-8',
+    csisolatinhebrew: 'ISO-8859-8',
+    hebrew: 'ISO-8859-8',
+    'iso-8859-8': 'ISO-8859-8',
+    'iso-8859-8-e': 'ISO-8859-8',
+    'iso-8859-8-i': 'ISO-8859-8',
+    'iso-ir-138': 'ISO-8859-8',
+    'iso8859-8': 'ISO-8859-8',
+    iso88598: 'ISO-8859-8',
+    'iso_8859-8': 'ISO-8859-8',
+    'iso_8859-8:1988': 'ISO-8859-8',
+    visual: 'ISO-8859-8',
+    csisolatin6: 'ISO-8859-10',
+    'iso-8859-10': 'ISO-8859-10',
+    'iso-ir-157': 'ISO-8859-10',
+    'iso8859-10': 'ISO-8859-10',
+    iso885910: 'ISO-8859-10',
+    l6: 'ISO-8859-10',
+    latin6: 'ISO-8859-10',
+    'iso-8859-13': 'ISO-8859-13',
+    'iso8859-13': 'ISO-8859-13',
+    iso885913: 'ISO-8859-13',
+    'iso-8859-14': 'ISO-8859-14',
+    'iso8859-14': 'ISO-8859-14',
+    iso885914: 'ISO-8859-14',
+    csisolatin9: 'ISO-8859-15',
+    'iso-8859-15': 'ISO-8859-15',
+    'iso8859-15': 'ISO-8859-15',
+    iso885915: 'ISO-8859-15',
+    'iso_8859-15': 'ISO-8859-15',
+    l9: 'ISO-8859-15',
+    'iso-8859-16': 'ISO-8859-16',
+    cskoi8r: 'KOI8-R',
+    koi: 'KOI8-R',
+    koi8: 'KOI8-R',
+    'koi8-r': 'KOI8-R',
+    koi8_r: 'KOI8-R',
+    'koi8-ru': 'KOI8-U',
+    'koi8-u': 'KOI8-U',
+    csmacintosh: 'macintosh',
+    mac: 'macintosh',
+    macintosh: 'macintosh',
+    'x-mac-roman': 'macintosh',
+    'dos-874': 'windows-874',
+    'iso-8859-11': 'windows-874',
+    'iso8859-11': 'windows-874',
+    iso885911: 'windows-874',
+    'tis-620': 'windows-874',
+    'windows-874': 'windows-874',
+    cp1250: 'windows-1250',
+    'windows-1250': 'windows-1250',
+    'x-cp1250': 'windows-1250',
+    cp1251: 'windows-1251',
+    'windows-1251': 'windows-1251',
+    'x-cp1251': 'windows-1251',
+    'ansi_x3.4-1968': 'windows-1252',
+    ascii: 'windows-1252',
+    cp1252: 'windows-1252',
+    cp819: 'windows-1252',
+    csisolatin1: 'windows-1252',
+    ibm819: 'windows-1252',
+    'iso-8859-1': 'windows-1252',
+    'iso-ir-100': 'windows-1252',
+    'iso8859-1': 'windows-1252',
+    iso88591: 'windows-1252',
+    'iso_8859-1': 'windows-1252',
+    'iso_8859-1:1987': 'windows-1252',
+    l1: 'windows-1252',
+    latin1: 'windows-1252',
+    'us-ascii': 'windows-1252',
+    'windows-1252': 'windows-1252',
+    'x-cp1252': 'windows-1252',
+    cp1253: 'windows-1253',
+    'windows-1253': 'windows-1253',
+    'x-cp1253': 'windows-1253',
+    cp1254: 'windows-1254',
+    csisolatin5: 'windows-1254',
+    'iso-8859-9': 'windows-1254',
+    'iso-ir-148': 'windows-1254',
+    'iso8859-9': 'windows-1254',
+    iso88599: 'windows-1254',
+    'iso_8859-9': 'windows-1254',
+    'iso_8859-9:1989': 'windows-1254',
+    l5: 'windows-1254',
+    latin5: 'windows-1254',
+    'windows-1254': 'windows-1254',
+    'x-cp1254': 'windows-1254',
+    cp1255: 'windows-1255',
+    'windows-1255': 'windows-1255',
+    'x-cp1255': 'windows-1255',
+    cp1256: 'windows-1256',
+    'windows-1256': 'windows-1256',
+    'x-cp1256': 'windows-1256',
+    cp1257: 'windows-1257',
+    'windows-1257': 'windows-1257',
+    'x-cp1257': 'windows-1257',
+    cp1258: 'windows-1258',
+    'windows-1258': 'windows-1258',
+    'x-cp1258': 'windows-1258',
+    chinese: 'GBK',
+    csgb2312: 'GBK',
+    csiso58gb231280: 'GBK',
+    gb2312: 'GBK',
+    gb_2312: 'GBK',
+    'gb_2312-80': 'GBK',
+    gbk: 'GBK',
+    'iso-ir-58': 'GBK',
+    'x-gbk': 'GBK',
+    gb18030: 'gb18030',
+    big5: 'Big5',
+    'big5-hkscs': 'Big5',
+    'cn-big5': 'Big5',
+    csbig5: 'Big5',
+    'x-x-big5': 'Big5',
+    cseucpkdfmtjapanese: 'EUC-JP',
+    'euc-jp': 'EUC-JP',
+    'x-euc-jp': 'EUC-JP',
+    csshiftjis: 'Shift_JIS',
+    ms932: 'Shift_JIS',
+    ms_kanji: 'Shift_JIS',
+    'shift-jis': 'Shift_JIS',
+    shift_jis: 'Shift_JIS',
+    sjis: 'Shift_JIS',
+    'windows-31j': 'Shift_JIS',
+    'x-sjis': 'Shift_JIS',
+    cseuckr: 'EUC-KR',
+    csksc56011987: 'EUC-KR',
+    'euc-kr': 'EUC-KR',
+    'iso-ir-149': 'EUC-KR',
+    korean: 'EUC-KR',
+    'ks_c_5601-1987': 'EUC-KR',
+    'ks_c_5601-1989': 'EUC-KR',
+    ksc5601: 'EUC-KR',
+    ksc_5601: 'EUC-KR',
+    'windows-949': 'EUC-KR',
+    'utf-16be': 'UTF-16BE',
+    'utf-16': 'UTF-16LE',
+    'utf-16le': 'UTF-16LE'
+};
+exports.default = charsets;
+module.exports = exports.default;

package/node_modules/libmime/dist/cjs/get-charset-name.d.ts

@@ -0,0 +1 @@
+export declare const getCharsetName: (charset: unknown) => string | false;

package/node_modules/libmime/dist/cjs/get-charset-name.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCharsetName = void 0;
+// https://nodejs.org/api/util.html#encodings-supported-by-default-with-full-icu-data
+// NB! iso-8859-16 not supported
+const CHARSETS = [
+    '866',
+    'ansi_x3.4-1968',
+    'arabic',
+    'ascii',
+    'asmo-708',
+    'big5',
+    'big5-hkscs',
+    'chinese',
+    'cn-big5',
+    'cp1250',
+    'cp1251',
+    'cp1252',
+    'cp1253',
+    'cp1254',
+    'cp1255',
+    'cp1256',
+    'cp1257',
+    'cp1258',
+    'cp819',
+    'cp866',
+    'csbig5',
+    'cseuckr',
+    'cseucpkdfmtjapanese',
+    'csgb2312',
+    'csibm866',
+    'csiso2022jp',
+    'csiso58gb231280',
+    'csiso88596e',
+    'csiso88596i',
+    'csiso88598e',
+    'csiso88598i',
+    'csisolatin1',
+    'csisolatin2',
+    'csisolatin3',
+    'csisolatin4',
+    'csisolatin5',
+    'csisolatin6',
+    'csisolatin9',
+    'csisolatinarabic',
+    'csisolatincyrillic',
+    'csisolatingreek',
+    'csisolatinhebrew',
+    'cskoi8r',
+    'csksc56011987',
+    'csmacintosh',
+    'csshiftjis',
+    'cyrillic',
+    'dos-874',
+    'ecma-114',
+    'ecma-118',
+    'elot_928',
+    'euc-jp',
+    'euc-kr',
+    'gb18030',
+    'gb2312',
+    'gb_2312',
+    'gb_2312-80',
+    'gbk',
+    'greek',
+    'greek8',
+    'hebrew',
+    'ibm819',
+    'ibm866',
+    'iso-2022-jp',
+    'iso-8859-1',
+    'iso8859-1',
+    'iso88591',
+    'iso_8859-1',
+    'iso_8859-1:1987',
+    'iso-8859-10',
+    'iso8859-10',
+    'iso885910',
+    'iso-8859-11',
+    'iso8859-11',
+    'iso885911',
+    'iso-8859-13',
+    'iso8859-13',
+    'iso885913',
+    'iso-8859-14',
+    'iso8859-14',
+    'iso885914',
+    'iso-8859-15',
+    'iso8859-15',
+    'iso885915',
+    'iso_8859-15',
+    'iso-8859-2',
+    'iso8859-2',
+    'iso88592',
+    'iso_8859-2',
+    'iso_8859-2:1987',
+    'iso-8859-3',
+    'iso8859-3',
+    'iso88593',
+    'iso_8859-3',
+    'iso_8859-3:1988',
+    'iso-8859-4',
+    'iso8859-4',
+    'iso88594',
+    'iso_8859-4',
+    'iso_8859-4:1988',
+    'iso-8859-5',
+    'iso8859-5',
+    'iso88595',
+    'iso_8859-5',
+    'iso_8859-5:1988',
+    'iso-8859-6',
+    'iso8859-6',
+    'iso88596',
+    'iso_8859-6',
+    'iso_8859-6:1987',
+    'iso-8859-6-e',
+    'iso-8859-6-i',
+    'iso-8859-7',
+    'iso8859-7',
+    'iso88597',
+    'iso_8859-7',
+    'iso_8859-7:1987',
+    'iso-8859-8',
+    'iso8859-8',
+    'iso88598',
+    'iso_8859-8',
+    'iso_8859-8:1988',
+    'iso-8859-8-e',
+    'iso-8859-8-i',
+    'iso-8859-9',
+    'iso8859-9',
+    'iso88599',
+    'iso_8859-9',
+    'iso_8859-9:1989',
+    'iso-ir-100',
+    'iso-ir-101',
+    'iso-ir-109',
+    'iso-ir-110',
+    'iso-ir-126',
+    'iso-ir-127',
+    'iso-ir-138',
+    'iso-ir-144',
+    'iso-ir-148',
+    'iso-ir-149',
+    'iso-ir-157',
+    'iso-ir-58',
+    'koi',
+    'koi8',
+    'koi8-r',
+    'koi8_r',
+    'koi8-ru',
+    'koi8-u',
+    'korean',
+    'ksc5601',
+    'ksc_5601',
+    'ks_c_5601-1987',
+    'ks_c_5601-1989',
+    'l1',
+    'l2',
+    'l3',
+    'l4',
+    'l5',
+    'l6',
+    'l9',
+    'latin1',
+    'latin2',
+    'latin3',
+    'latin4',
+    'latin5',
+    'latin6',
+    'logical',
+    'mac',
+    'macintosh',
+    'ms932',
+    'ms_kanji',
+    'shift_jis',
+    'shift-jis',
+    'sjis',
+    'sun_eu_greek',
+    'tis-620',
+    'unicode-1-1-utf-8',
+    'us-ascii',
+    'utf-16',
+    'utf-16be',
+    'utf-16le',
+    'utf-8',
+    'utf8',
+    'visual',
+    'windows-1250',
+    'windows-1251',
+    'windows-1252',
+    'windows-1253',
+    'windows-1254',
+    'windows-1255',
+    'windows-1256',
+    'windows-1257',
+    'windows-1258',
+    'windows-31j',
+    'windows-874',
+    'windows-949',
+    'x-cp1250',
+    'x-cp1251',
+    'x-cp1252',
+    'x-cp1253',
+    'x-cp1254',
+    'x-cp1255',
+    'x-cp1256',
+    'x-cp1257',
+    'x-cp1258',
+    'x-euc-jp',
+    'x-gbk',
+    'x-mac-cyrillic',
+    'x-mac-roman',
+    'x-mac-ukrainian',
+    'x-sjis',
+    'x-x-big5'
+];
+const CHARSET_MAP = new Map(CHARSETS.map(charset => [charset.replace(/[-_]+/g, ''), charset]));
+const getCharsetName = (charset) => {
+    let charsetKey = (charset || '').toString().toLowerCase().trim().replace(/[-_]+/g, '');
+    return CHARSET_MAP.get(charsetKey) || false;
+};
+exports.getCharsetName = getCharsetName;

package/node_modules/libmime/dist/cjs/libmime.d.ts

@@ -0,0 +1,218 @@
+import { Buffer } from 'node:buffer';
+import type { HeaderLine, HeaderObject, HeaderParam, LibmimeConfig, ParsedHeaderValue, StructuredHeaderValue } from './types.js';
+import type * as types from './types.js';
+declare class Libmime {
+    config: LibmimeConfig;
+    constructor(config?: LibmimeConfig);
+    /**
+     * 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 non-ASCII text does.
+     *
+     * @param {String} value String to be tested
+     * @param {Boolean} [isParam] Set to true if the value is a header parameter value
+     * @returns {Boolean} true if it is a plaintext string
+     */
+    isPlainText(value: unknown, isParam?: boolean): boolean;
+    private isPlainParamValue;
+    /**
+     * 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 {String} str String to be tested
+     * @param {Number} lineLength Max line length to check for
+     * @returns {Boolean} Returns true if there is at least one line longer than lineLength chars
+     */
+    hasLongerLines(str: string, lineLength: number): boolean;
+    /**
+     * Decodes a string from a format=flowed soft wrapping.
+     *
+     * @param {String} str Plaintext string with format=flowed to decode
+     * @param {Boolean} [delSp] If true, delete leading spaces (delsp=yes)
+     * @return {String} Mime decoded string
+     */
+    decodeFlowed(input: unknown, delSp?: boolean): string;
+    /**
+     * Adds soft line breaks to content marked with format=flowed to
+     * ensure that no line in the message is never longer than lineLength
+     *
+     * @param {String} str Plaintext string that requires wrapping
+     * @param {Number} [lineLength=76] Maximum length of a line
+     * @return {String} String with forced line breaks
+     */
+    encodeFlowed(str: string, lineLength?: number): string;
+    /**
+     * Encodes a string or an Buffer to an UTF-8 MIME Word (rfc2047)
+     *
+     * @param {String|Buffer} data String to be encoded
+     * @param {String} mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+     * @param {Number} [maxLength=0] If set, split mime words into several chunks if needed
+     * @return {String} Single or several mime words joined together
+     */
+    encodeWord(data: string | Buffer, mimeWordEncoding?: string, maxLength?: number): string;
+    /**
+     * Normalizes a charset name to its canonical form, resolving common aliases and
+     * invalid names. For example `iso-8859-8-i` and `iso-8859-8-e` become `ISO-8859-8`
+     * and `win-1257` becomes `windows-1257`. Unknown charsets are returned uppercased.
+     * Missing or non-string input defaults to `UTF-8`.
+     *
+     * @param {String} charset Charset name to normalize
+     * @return {String} Canonical charset name
+     */
+    normalizeCharset(charset?: unknown): string;
+    /**
+     * Decodes the inner payload of a single mime encoded-word into a unicode string.
+     * Expects the three components of `=?charset?encoding?text?=` already separated.
+     *
+     * @param {String} charset Charset name from the encoded-word (may include an RFC 2231 language tag, which is ignored)
+     * @param {String} encoding Encoding indicator, either 'Q' or 'B' (case insensitive)
+     * @param {String} str Encoded payload between the second `?` and the trailing `?=`
+     * @return {String} Decoded unicode string
+     */
+    decodeWord(charset: string, encoding: string, str: string): string;
+    /**
+     * Finds word sequences with non ascii text and converts these to mime words
+     *
+     * @param {String|Buffer} data String to be encoded
+     * @param {String} mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+     * @param {Number} [maxLength=0] If set, split mime words into several chunks if needed
+     * @param {String} [fromCharset='UTF-8'] Source character set
+     * @return {String} String with possible mime words
+     */
+    encodeWords(data: string | Buffer, mimeWordEncoding?: string, maxLength?: number | string, fromCharset?: string): string;
+    /**
+     * Decode a string that might include one or several mime words
+     *
+     * @param {String} str String including some mime words that will be decoded
+     * @return {String} Decoded unicode string
+     */
+    decodeWords(str: unknown): string;
+    getHex(c: number | undefined): string | false;
+    /**
+     * Splits a string by :
+     * The result is not mime word decoded, you need to do your own decoding based
+     * on the rules for the specific header key
+     *
+     * @param {String} headerLine Single header line, might include linebreaks as well if folded
+     * @return {Object} An object of {key, value}
+     */
+    decodeHeader(headerLine: unknown): HeaderLine;
+    /**
+     * Parses a block of header lines. Does not decode mime words as every
+     * header might have its own rules (eg. formatted email addresses and such)
+     *
+     * @param {String} headers Headers string
+     * @return {Object} An object of headers, where header keys are object keys and every value is an Array of the values for that key
+     */
+    decodeHeaders(headers: string): HeaderObject;
+    /**
+     * 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 {Object} structured Parsed header value
+     * @return {String} joined header value
+     */
+    buildHeaderValue(structured: StructuredHeaderValue): string;
+    /**
+     * Parses a header value with key=value arguments into a structured
+     * object.
+     *
+     *   parseHeaderValue('text/plain; CHARSET=UTF-8') ->
+     *   {
+     *     'value': 'text/plain',
+     *     'params': {
+     *       'charset': 'UTF-8'
+     *     }
+     *   }
+     *
+     * The result also carries a non-enumerable `decodedParams` array that names the params
+     * assembled from rfc2231 segments (title*=, title*0*=, title*0=). Those values are already
+     * decoded, so a caller that runs decodeWords() over the params has to leave them out
+     *
+     * @param {String} str Header value
+     * @return {Object} Header value as a parsed structure
+     */
+    parseHeaderValue(str: string): ParsedHeaderValue;
+    /**
+     * 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 {String} key Parameter name (eg. 'filename')
+     * @param {String|Buffer} data String to be encoded
+     * @param {Number} [maxLength=50] Max length for generated chunks
+     * @param {String} [fromCharset='UTF-8'] Source character set
+     * @return {Array} A list of encoded keys and headers
+     */
+    buildHeaderParam(key: string, data: unknown, maxLength?: number, fromCharset?: string): HeaderParam[];
+    /**
+     * Returns file extension for a content type string. If no suitable extensions
+     * are found, 'bin' is used as the default extension
+     *
+     * @param {String} mimeType Content type to be checked for
+     * @return {String} File extension
+     */
+    detectExtension(input: unknown): 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 {String} extension Extension (or filename) to be checked for
+     * @return {String} Content type
+     */
+    detectMimeType(input: unknown): string;
+    /**
+     * Folds long lines, useful for folding header lines (afterSpace=false) and
+     * flowed text (afterSpace=true)
+     *
+     * @param {String} str String to be folded
+     * @param {Number} [lineLength=76] Maximum length of a line
+     * @param {Boolean} afterSpace If true, leave a space in the end of a line
+     * @return {String} String with folded lines
+     */
+    foldLines(input: unknown, lineLength?: number, afterSpace?: boolean): string;
+    /**
+     * Splits a mime encoded string. Needed for dividing mime words into smaller chunks
+     *
+     * @param {String} str Mime encoded string to be split up
+     * @param {Number} maxlen Maximum length of characters for one part (minimum 12)
+     * @return {Array} Split string
+     */
+    splitMimeEncodedString(str: string, maxlen?: number): string[];
+    encodeURICharComponent(chr: string): string;
+    safeEncodeURIComponent(input: unknown): string;
+}
+/**
+ * The shared instance, the default export of the package. The class is attached to it as `Libmime`,
+ * so `require('libmime').Libmime` keeps working
+ */
+declare const libmime: Libmime & {
+    Libmime: typeof Libmime;
+};
+type LibmimeInstance = Libmime;
+declare namespace libmime {
+    type Libmime = LibmimeInstance;
+    type HeaderLine = types.HeaderLine;
+    type HeaderObject = types.HeaderObject;
+    type HeaderParam = types.HeaderParam;
+    type LibmimeConfig = types.LibmimeConfig;
+    type MimeWordEncoding = types.MimeWordEncoding;
+    type ParsedHeaderValue = types.ParsedHeaderValue;
+    type StructuredHeader = types.StructuredHeader;
+    type StructuredHeaderValue = types.StructuredHeaderValue;
+}
+export = libmime;