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

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

@@ -0,0 +1,36 @@
+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 | undefined;
+    /** Collect the canonicalized body and emit it with the 'hash' event */
+    debug?: boolean | undefined;
+}
+/**
+ * Passes the message body through unchanged and hashes its relaxed
+ * canonicalization (RFC 6376 section 3.4.4) on the side: whitespace at the end
+ * of a line is dropped, runs of whitespace within a line become a single space,
+ * every line ends with CRLF, empty lines at the end of the body are ignored and
+ * a non-empty body always ends with CRLF. Bytes are canonicalized as they arrive,
+ * so a line of any length costs constant memory.
+ */
+declare class RelaxedBody extends Transform {
+    bodyHash: crypto.Hash;
+    /** Bytes of the original body seen so far */
+    byteLength: number;
+    debug: boolean | undefined;
+    constructor(options?: RelaxedBodyOptions);
+    updateHash(chunk: Buffer, final?: boolean): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `RelaxedBody.Options` style references keep working
+ */
+declare namespace RelaxedBody {
+    type Options = RelaxedBodyOptions;
+}
+/** The same alias as a module level export, for `import * as RelaxedBody` and `import RelaxedBody = require()` */
+export type { RelaxedBodyOptions as Options };
+export default RelaxedBody;

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

@@ -0,0 +1,148 @@
+"use strict";
+// streams through a message body and calculates relaxed body hash
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const CHAR_CR = 0x0d;
+const CHAR_LF = 0x0a;
+const CHAR_SPACE = 0x20;
+const CHAR_TAB = 0x09;
+const CRLF = Buffer.from('\r\n');
+// a run of empty lines is hashed from this buffer in slices
+const EMPTY_LINES = Buffer.alloc(4096, CRLF);
+/**
+ * Passes the message body through unchanged and hashes its relaxed
+ * canonicalization (RFC 6376 section 3.4.4) on the side: whitespace at the end
+ * of a line is dropped, runs of whitespace within a line become a single space,
+ * every line ends with CRLF, empty lines at the end of the body are ignored and
+ * a non-empty body always ends with CRLF. Bytes are canonicalized as they arrive,
+ * so a line of any length costs constant memory.
+ */
+class RelaxedBody extends node_stream_1.Transform {
+    constructor(options) {
+        super();
+        options = options || {};
+        this.bodyHash = node_crypto_1.default.createHash(options.hashAlgo || 'sha256');
+        this.byteLength = 0;
+        this.debug = options.debug;
+        this._debugBody = options.debug ? [] : false;
+        this._lineHasContent = false;
+        this._pendingWsp = false;
+        this._pendingCr = false;
+        this._pendingEmptyLines = 0;
+    }
+    /** @internal */
+    _hashCanonical(data) {
+        if (!data.length) {
+            return;
+        }
+        this.bodyHash.update(data);
+        if (this._debugBody) {
+            this._debugBody.push(Buffer.from(data));
+        }
+    }
+    /** @internal */
+    _hashEmptyLines() {
+        while (this._pendingEmptyLines > 0) {
+            const count = Math.min(this._pendingEmptyLines, EMPTY_LINES.length / 2);
+            this._hashCanonical(EMPTY_LINES.subarray(0, count * 2));
+            this._pendingEmptyLines -= count;
+        }
+    }
+    /**
+     * 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) {
+            if (this._pendingEmptyLines) {
+                // the first content byte of a line is where the empty lines before it
+                // become part of the body, so hash what is in the buffer before them
+                this._hashCanonical(out.subarray(0, outPos));
+                outPos = 0;
+                this._hashEmptyLines();
+            }
+            this._lineHasContent = true;
+        }
+        if (this._pendingWsp) {
+            out[outPos++] = CHAR_SPACE;
+            this._pendingWsp = false;
+        }
+        out[outPos++] = c;
+        return outPos;
+    }
+    updateHash(chunk, final) {
+        // every byte contributes itself at most once, plus a CR for a bare LF
+        // and, once per chunk, a pending space and CR carried over from before
+        const out = Buffer.allocUnsafe(chunk.length * 2 + 2);
+        let outPos = 0;
+        for (let i = 0; i < chunk.length; i++) {
+            const c = chunk[i];
+            if (c === CHAR_LF) {
+                // end of line, a CR right before it and any trailing whitespace are dropped
+                if (this._lineHasContent) {
+                    out[outPos++] = CHAR_CR;
+                    out[outPos++] = CHAR_LF;
+                    this._lineHasContent = false;
+                }
+                else {
+                    this._pendingEmptyLines++;
+                }
+                this._pendingWsp = false;
+                this._pendingCr = false;
+                continue;
+            }
+            if (this._pendingCr) {
+                // not followed by LF, so the CR is content
+                outPos = this._emitContent(out, outPos, CHAR_CR);
+                this._pendingCr = false;
+            }
+            if (c === CHAR_CR) {
+                this._pendingCr = true;
+            }
+            else if (c === CHAR_SPACE || c === CHAR_TAB) {
+                this._pendingWsp = true;
+            }
+            else {
+                outPos = this._emitContent(out, outPos, c);
+            }
+        }
+        if (final && this._pendingCr) {
+            // a CR at the very end of the body is content
+            outPos = this._emitContent(out, outPos, CHAR_CR);
+            this._pendingCr = false;
+        }
+        this._hashCanonical(out.subarray(0, outPos));
+    }
+    /** @internal */
+    _transform(chunk, encoding, callback) {
+        if (!chunk || !chunk.length) {
+            return callback();
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, encoding);
+        }
+        this.updateHash(chunk);
+        this.byteLength += chunk.length;
+        this.push(chunk);
+        callback();
+    }
+    /** @internal */
+    _flush(callback) {
+        this.updateHash(Buffer.alloc(0), true);
+        if (this._lineHasContent) {
+            // the body does not end with a line break, add one
+            this._hashCanonical(CRLF);
+        }
+        this.emit('hash', this.bodyHash.digest('base64'), this.debug ? Buffer.concat(this._debugBody) : false);
+        callback();
+    }
+}
+exports.default = RelaxedBody;
+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/dkim/sign.d.ts

@@ -0,0 +1,52 @@
+import crypto from 'node:crypto';
+import type { NodemailerError } from '../errors.js';
+import type { MessageParserHeaderLine } from './message-parser.js';
+/**
+ * Private key accepted by crypto.Sign#sign: a PEM string, a Buffer, a KeyObject or an
+ * object with the key and its passphrase
+ */
+export type DKIMPrivateKey = crypto.KeyLike | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput;
+/**
+ * Options for the DKIM signature header generator
+ */
+export interface DKIMKey {
+    /** Domain name to be signed for */
+    domainName?: string | undefined;
+    /** DKIM key selector to use */
+    keySelector?: string | undefined;
+    /** DKIM private key to use */
+    privateKey?: DKIMPrivateKey | undefined;
+}
+export interface DKIMSignOptions extends DKIMKey {
+    /** Colon separated list of header field names to sign, defaults to the RFC4871 list */
+    headerFieldNames?: string | undefined;
+    /** Colon separated list of header field names to leave out of the signature */
+    skipFields?: string | undefined;
+}
+/**
+ * Canonicalized headers and the list of field names that went into them
+ */
+export interface DKIMRelaxedHeaders {
+    /** Relaxed header lines, each terminated with CRLF, one character per byte ('binary' encoding) */
+    headers: string;
+    /** Colon separated list of the field names that were included */
+    fieldNames: string;
+}
+/**
+ * Returns DKIM signature header line
+ *
+ * @param headers Parsed headers object from MessageParser
+ * @param hashAlgo Hash algorithm the body hash was calculated with, for example "sha256"
+ * @param bodyHash Base64 encoded hash of the message
+ * @param options DKIM options
+ * @param options.domainName Domain name to be signed for
+ * @param options.keySelector DKIM key selector to use
+ * @param options.privateKey DKIM private key to use
+ * @return Complete header line
+ */
+declare function sign(headers: MessageParserHeaderLine[], hashAlgo: string, bodyHash: string, options?: DKIMSignOptions): string | false;
+declare namespace sign {
+    var relaxedHeaders: (headers: MessageParserHeaderLine[], fieldNames?: string, skipFields?: string) => DKIMRelaxedHeaders;
+    var unsupportedHashAlgoError: (hashAlgo: string) => NodemailerError;
+}
+export default sign;

package/dist/node_modules/nodemailer/dist/cjs/dkim/sign.js

@@ -0,0 +1,165 @@
+"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 punycode = __importStar(require("../punycode/index.js"));
+const mimeFuncs = __importStar(require("../mime-funcs/index.js"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const errors = __importStar(require("../errors.js"));
+/**
+ * Error for a hashAlgo value the crypto module does not know
+ */
+function unsupportedHashAlgoError(hashAlgo) {
+    const err = new Error('Unsupported DKIM hash algorithm "' + hashAlgo + '"');
+    err.code = errors.ECONFIG;
+    return err;
+}
+/**
+ * Returns DKIM signature header line
+ *
+ * @param headers Parsed headers object from MessageParser
+ * @param hashAlgo Hash algorithm the body hash was calculated with, for example "sha256"
+ * @param bodyHash Base64 encoded hash of the message
+ * @param options DKIM options
+ * @param options.domainName Domain name to be signed for
+ * @param options.keySelector DKIM key selector to use
+ * @param options.privateKey DKIM private key to use
+ * @return Complete header line
+ */
+function sign(headers, hashAlgo, bodyHash, options) {
+    options = options || {};
+    // all listed fields from RFC4871 #5.5
+    const defaultFieldNames = 'From:Sender:Reply-To:Subject:Date:Message-ID:To:' +
+        'Cc:MIME-Version:Content-Type:Content-Transfer-Encoding:Content-ID:' +
+        'Content-Description:Resent-Date:Resent-From:Resent-Sender:' +
+        'Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References:' +
+        'List-Id:List-Help:List-Unsubscribe:List-Subscribe:List-Post:' +
+        'List-Owner:List-Archive';
+    const fieldNames = options.headerFieldNames || defaultFieldNames;
+    const canonicalizedHeaderData = relaxedHeaders(headers, fieldNames, options.skipFields);
+    const dkimHeader = generateDKIMHeader(options.domainName, options.keySelector, canonicalizedHeaderData.fieldNames, hashAlgo, bodyHash);
+    canonicalizedHeaderData.headers += 'dkim-signature:' + relaxedHeaderLine(dkimHeader);
+    let signer;
+    try {
+        signer = node_crypto_1.default.createSign(('rsa-' + hashAlgo).toUpperCase());
+    }
+    catch (_E) {
+        throw unsupportedHashAlgoError(hashAlgo);
+    }
+    // the header lines are 'binary' strings, so this reproduces the original header bytes
+    signer.update(canonicalizedHeaderData.headers, 'latin1');
+    let signature;
+    try {
+        signature = signer.sign(options.privateKey, 'base64');
+    }
+    catch (_E) {
+        return false;
+    }
+    return dkimHeader + signature.replace(/(^.{73}|.{75}(?!\r?\n|\r))/g, '$&\r\n ').trim();
+}
+sign.relaxedHeaders = relaxedHeaders;
+sign.unsupportedHashAlgoError = unsupportedHashAlgoError;
+exports.default = sign;
+function generateDKIMHeader(domainName, keySelector, fieldNames, hashAlgo, bodyHash) {
+    // the caller supplied tag values are interpolated straight into the tag list, and none of
+    // them has any way to carry a control char, DEL, or one of the delimiters that would close
+    // the value and open a tag of its own
+    const cleanTagValue = (value) => (value || '').toString().replace(/[\x00-\x1f\x7f;=]/g, '');
+    const dkim = [
+        'v=1',
+        'a=rsa-' + hashAlgo,
+        'c=relaxed/relaxed',
+        'd=' + punycode.toASCII(cleanTagValue(domainName)),
+        'q=dns/txt',
+        's=' + cleanTagValue(keySelector),
+        'bh=' + bodyHash,
+        'h=' + cleanTagValue(fieldNames)
+    ].join('; ');
+    return mimeFuncs.foldLines('DKIM-Signature: ' + dkim, 76) + ';\r\n b=';
+}
+function relaxedHeaders(headers, fieldNames, skipFields) {
+    const includedFields = new Set();
+    const skip = new Set();
+    const headerFields = new Map();
+    (skipFields || '')
+        .toLowerCase()
+        .split(':')
+        .forEach(field => {
+        skip.add(field.trim());
+    });
+    (fieldNames || '')
+        .toLowerCase()
+        .split(':')
+        .filter(field => !skip.has(field.trim()))
+        .forEach(field => {
+        includedFields.add(field.trim());
+    });
+    for (let i = headers.length - 1; i >= 0; i--) {
+        const line = headers[i];
+        // only include the first value from bottom to top
+        if (includedFields.has(line.key) && !headerFields.has(line.key)) {
+            headerFields.set(line.key, relaxedHeaderLine(line.line));
+        }
+    }
+    const headersList = [];
+    const fields = [];
+    includedFields.forEach(field => {
+        if (headerFields.has(field)) {
+            fields.push(field);
+            headersList.push(field + ':' + headerFields.get(field));
+        }
+    });
+    return {
+        headers: headersList.join('\r\n') + '\r\n',
+        fieldNames: fields.join(':')
+    };
+}
+/**
+ * Relaxed canonicalization of a header field value (RFC 6376 section 3.4.2): unfold, turn
+ * every run of SP and HTAB into a single SP and drop the whitespace next to the colon and
+ * at the end. Only SP and HTAB count as whitespace, so bytes that decode to other space
+ * characters, such as a non-breaking space in a UTF-8 header, stay as they are
+ */
+function relaxedHeaderLine(line) {
+    return line
+        .substr(line.indexOf(':') + 1)
+        .replace(/\r?\n/g, '')
+        .replace(/[ \t]+/g, ' ')
+        .replace(/^ | $/g, '');
+}
+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/errors.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Nodemailer Error Codes
+ *
+ * Centralized error code definitions for consistent error handling.
+ *
+ * Usage:
+ *   import * as errors from './errors.js';
+ *   const err: NodemailerError = new Error('Connection closed');
+ *   err.code = errors.ECONNECTION;
+ */
+/**
+ * Error code descriptions for documentation and debugging
+ */
+export declare const ERROR_CODES: {
+    readonly ECONNECTION: "Connection closed unexpectedly";
+    readonly ETIMEDOUT: "Connection or operation timed out";
+    readonly ESOCKET: "Socket-level error";
+    readonly EDNS: "DNS resolution failed";
+    readonly ETLS: "TLS handshake or STARTTLS failed";
+    readonly EREQUIRETLS: "REQUIRETLS not supported by server (RFC 8689)";
+    readonly EPROTOCOL: "Invalid SMTP server response";
+    readonly EENVELOPE: "Invalid mail envelope (sender or recipients)";
+    readonly EMESSAGE: "Message delivery error";
+    readonly ESTREAM: "Stream processing error";
+    readonly EAUTH: "Authentication failed";
+    readonly ENOAUTH: "Authentication credentials not provided";
+    readonly EOAUTH2: "OAuth2 token generation or refresh error";
+    readonly EMAXLIMIT: "Pool resource limit reached (max messages per connection)";
+    readonly EMAXRECIPIENTS: "Recipient count exceeds maxRecipients";
+    readonly ESENDMAIL: "Sendmail command error";
+    readonly ESES: "AWS SES transport error";
+    readonly ECONFIG: "Invalid configuration";
+    readonly EPROXY: "Proxy connection error";
+    readonly EFILEACCESS: "File access rejected (disableFileAccess is set)";
+    readonly EURLACCESS: "URL access rejected (disableUrlAccess is set)";
+    readonly EFETCH: "HTTP fetch error";
+};
+/**
+ * Union of all known Nodemailer error codes
+ */
+export type ErrorCode = keyof typeof ERROR_CODES;
+export declare const ECONNECTION = "ECONNECTION";
+export declare const ETIMEDOUT = "ETIMEDOUT";
+export declare const ESOCKET = "ESOCKET";
+export declare const EDNS = "EDNS";
+export declare const ETLS = "ETLS";
+export declare const EREQUIRETLS = "EREQUIRETLS";
+export declare const EPROTOCOL = "EPROTOCOL";
+export declare const EENVELOPE = "EENVELOPE";
+export declare const EMESSAGE = "EMESSAGE";
+export declare const ESTREAM = "ESTREAM";
+export declare const EAUTH = "EAUTH";
+export declare const ENOAUTH = "ENOAUTH";
+export declare const EOAUTH2 = "EOAUTH2";
+export declare const EMAXLIMIT = "EMAXLIMIT";
+export declare const EMAXRECIPIENTS = "EMAXRECIPIENTS";
+export declare const ESENDMAIL = "ESENDMAIL";
+export declare const ESES = "ESES";
+export declare const ECONFIG = "ECONFIG";
+export declare const EPROXY = "EPROXY";
+export declare const EFILEACCESS = "EFILEACCESS";
+export declare const EURLACCESS = "EURLACCESS";
+export declare const EFETCH = "EFETCH";
+/**
+ * An Error together with the properties Nodemailer attaches to the errors it
+ * hands to callers. Every property is optional, the set that is present
+ * depends on where the error originated. Socket level errors keep the errno
+ * and syscall fields Node.js sets on them.
+ */
+export interface NodemailerError extends NodeJS.ErrnoException {
+    /** Nodemailer error code, see ERROR_CODES */
+    code?: string | undefined;
+    /** SMTP command that was in flight when the server replied with an error */
+    command?: string | undefined;
+    /** Raw SMTP server response */
+    response?: string | undefined;
+    /** Numeric SMTP response code */
+    responseCode?: number | undefined;
+    /** URL of the resource that could not be fetched */
+    sourceUrl?: string | undefined;
+    /** Recipient address the error applies to */
+    recipient?: string | undefined;
+    /** Recipient addresses rejected by the server */
+    rejected?: string[] | undefined;
+    /** Per-recipient errors for the rejected addresses */
+    rejectedErrors?: NodemailerError[] | undefined;
+}
+/**
+ * Node style callback: called with an error, or with null and the result
+ */
+export type Callback<T> = (err: NodemailerError | null, result: T) => void;
+/**
+ * Callback as the library calls it on its error paths: with an error alone, or with null and
+ * the result. The public signatures use Callback, internally the error paths cast to this
+ */
+export type ResultCallback<T> = (err: NodemailerError | null, result?: T) => void;

package/dist/node_modules/nodemailer/dist/cjs/errors.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Nodemailer Error Codes
+ *
+ * Centralized error code definitions for consistent error handling.
+ *
+ * Usage:
+ *   import * as errors from './errors.js';
+ *   const err: NodemailerError = new Error('Connection closed');
+ *   err.code = errors.ECONNECTION;
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EFETCH = exports.EURLACCESS = exports.EFILEACCESS = exports.EPROXY = exports.ECONFIG = exports.ESES = exports.ESENDMAIL = exports.EMAXRECIPIENTS = exports.EMAXLIMIT = exports.EOAUTH2 = exports.ENOAUTH = exports.EAUTH = exports.ESTREAM = exports.EMESSAGE = exports.EENVELOPE = exports.EPROTOCOL = exports.EREQUIRETLS = exports.ETLS = exports.EDNS = exports.ESOCKET = exports.ETIMEDOUT = exports.ECONNECTION = exports.ERROR_CODES = void 0;
+/**
+ * Error code descriptions for documentation and debugging
+ */
+exports.ERROR_CODES = {
+    // Connection errors
+    ECONNECTION: 'Connection closed unexpectedly',
+    ETIMEDOUT: 'Connection or operation timed out',
+    ESOCKET: 'Socket-level error',
+    EDNS: 'DNS resolution failed',
+    // TLS/Security errors
+    ETLS: 'TLS handshake or STARTTLS failed',
+    EREQUIRETLS: 'REQUIRETLS not supported by server (RFC 8689)',
+    // Protocol errors
+    EPROTOCOL: 'Invalid SMTP server response',
+    EENVELOPE: 'Invalid mail envelope (sender or recipients)',
+    EMESSAGE: 'Message delivery error',
+    ESTREAM: 'Stream processing error',
+    // Authentication errors
+    EAUTH: 'Authentication failed',
+    ENOAUTH: 'Authentication credentials not provided',
+    EOAUTH2: 'OAuth2 token generation or refresh error',
+    // Resource errors
+    EMAXLIMIT: 'Pool resource limit reached (max messages per connection)',
+    EMAXRECIPIENTS: 'Recipient count exceeds maxRecipients',
+    // Transport-specific errors
+    ESENDMAIL: 'Sendmail command error',
+    ESES: 'AWS SES transport error',
+    // Configuration and access errors
+    ECONFIG: 'Invalid configuration',
+    EPROXY: 'Proxy connection error',
+    EFILEACCESS: 'File access rejected (disableFileAccess is set)',
+    EURLACCESS: 'URL access rejected (disableUrlAccess is set)',
+    EFETCH: 'HTTP fetch error'
+};
+// Error codes as string constants
+exports.ECONNECTION = 'ECONNECTION';
+exports.ETIMEDOUT = 'ETIMEDOUT';
+exports.ESOCKET = 'ESOCKET';
+exports.EDNS = 'EDNS';
+exports.ETLS = 'ETLS';
+exports.EREQUIRETLS = 'EREQUIRETLS';
+exports.EPROTOCOL = 'EPROTOCOL';
+exports.EENVELOPE = 'EENVELOPE';
+exports.EMESSAGE = 'EMESSAGE';
+exports.ESTREAM = 'ESTREAM';
+exports.EAUTH = 'EAUTH';
+exports.ENOAUTH = 'ENOAUTH';
+exports.EOAUTH2 = 'EOAUTH2';
+exports.EMAXLIMIT = 'EMAXLIMIT';
+exports.EMAXRECIPIENTS = 'EMAXRECIPIENTS';
+exports.ESENDMAIL = 'ESENDMAIL';
+exports.ESES = 'ESES';
+exports.ECONFIG = 'ECONFIG';
+exports.EPROXY = 'EPROXY';
+exports.EFILEACCESS = 'EFILEACCESS';
+exports.EURLACCESS = 'EURLACCESS';
+exports.EFETCH = 'EFETCH';

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

@@ -0,0 +1,107 @@
+/**
+ * Options for the Cookies jar
+ */
+export interface CookiesOptions {
+    /** Lifetime in seconds for cookies that do not set their own expiration (default 1800) */
+    sessionTimeout?: number | string | undefined;
+}
+/**
+ * A cookie as parsed from a 'Set-Cookie:' header and kept in the jar
+ */
+export interface Cookie {
+    name?: string | undefined;
+    value?: string | undefined;
+    domain?: string | undefined;
+    path?: string | undefined;
+    expires?: Date | undefined;
+    secure?: boolean | undefined;
+    httponly?: boolean | undefined;
+}
+type CookieEntry = Cookie;
+/**
+ * Creates a biskviit cookie jar for managing cookie values in memory
+ *
+ * @constructor
+ * @param [options] Optional options object
+ */
+declare class Cookies {
+    options: CookiesOptions;
+    cookies: Cookie[];
+    constructor(options?: CookiesOptions);
+    /**
+     * Stores a cookie string to the cookie storage
+     *
+     * @param cookieStr Value from the 'Set-Cookie:' header
+     * @param url Current URL
+     */
+    set(cookieStr: string, url?: string): boolean;
+    /**
+     * Returns cookie string for the 'Cookie:' header.
+     *
+     * @param url URL to check for
+     * @returns Cookie header or empty string if no matches were found
+     */
+    get(url?: string): string;
+    /**
+     * Lists all valied cookie objects for the specified URL
+     *
+     * @param url URL to check for
+     * @returns An array of cookie objects
+     */
+    list(url?: string): Cookie[];
+    /**
+     * Parses cookie string from the 'Set-Cookie:' header
+     *
+     * @param cookieStr String from the 'Set-Cookie:' header
+     * @returns Cookie object
+     */
+    parse(cookieStr?: string): Cookie;
+    /**
+     * Checks if a cookie object is valid for a specified URL
+     *
+     * @param cookie Cookie object
+     * @param url URL to check for
+     * @returns true if cookie is valid for specifiec URL
+     */
+    match(cookie: Cookie, url?: string): boolean;
+    /**
+     * Adds (or updates/removes if needed) a cookie object to the cookie storage
+     *
+     * @param cookie Cookie value to be stored
+     */
+    add(cookie: Cookie): boolean;
+    /**
+     * Checks if two cookie objects are the same
+     *
+     * @param a Cookie to check against
+     * @param b Cookie to check against
+     * @returns True, if the cookies are the same
+     */
+    compare(a: Cookie, b: Cookie): boolean;
+    /**
+     * Checks if a cookie is expired
+     *
+     * @param cookie Cookie object to check against
+     * @returns True, if the cookie is expired
+     */
+    isExpired(cookie: Cookie): boolean;
+    /**
+     * Returns the default path for an URL path argument, the default-path of
+     * RFC 6265 section 5.1.4. A cookie that carries no Path attribute is scoped
+     * to the directory of the URL it was set from
+     *
+     * @param pathname
+     * @returns Default path
+     */
+    getPath(pathname?: string | null): string;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `Cookies.Cookie` style references keep working
+ */
+declare namespace Cookies {
+    type Options = CookiesOptions;
+    type Cookie = CookieEntry;
+}
+/** The same alias as a module level export, for `import * as Cookies` and `import Cookies = require()` */
+export type { CookiesOptions as Options };
+export default Cookies;