@bobfrankston/mailx 1.0.1

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/mailer/index.d.ts

@@ -0,0 +1,283 @@
+/// <reference types="node" />
+
+import { EventEmitter } from "events";
+import { Socket } from "net";
+import { Readable } from "stream";
+import { Url } from "url";
+
+import { Transport, TransportOptions } from "../..";
+import * as shared from "../shared";
+
+import DKIM = require("../dkim");
+import MailMessage = require("./mail-message");
+import MimeNode = require("../mime-node");
+import SMTPConnection = require("../smtp-connection");
+import XOAuth2 = require("../xoauth2");
+
+declare namespace Mail {
+    type Headers =
+        | { [key: string]: string | string[] | { prepared: boolean; value: string } }
+        | Array<{ key: string; value: string }>;
+
+    type ListHeader = string | { url: string; comment: string };
+
+    interface ListHeaders {
+        [key: string]: ListHeader | ListHeader[] | ListHeader[][];
+    }
+
+    type TextEncoding = "quoted-printable" | "base64";
+
+    interface Address {
+        name: string;
+        address: string;
+    }
+
+    interface AttachmentLike {
+        /** String, Buffer or a Stream contents for the attachment */
+        content?: string | Buffer | Readable | undefined;
+        /** path to a file or an URL (data uris are allowed as well) if you want to stream the file instead of including it (better for larger attachments) */
+        path?: string | Url | undefined;
+    }
+
+    interface Attachment extends AttachmentLike {
+        /** filename to be reported as the name of the attached file, use of unicode is allowed. If you do not want to use a filename, set this value as false, otherwise a filename is generated automatically */
+        filename?: string | false | undefined;
+        /** optional content id for using inline images in HTML message source. Using cid sets the default contentDisposition to 'inline' and moves the attachment into a multipart/related mime node, so use it only if you actually want to use this attachment as an embedded image */
+        cid?: string | undefined;
+        /** If set and content is string, then encodes the content to a Buffer using the specified encoding. Example values: base64, hex, binary etc. Useful if you want to use binary attachments in a JSON formatted e-mail object */
+        encoding?: string | undefined;
+        /** optional content type for the attachment, if not set will be derived from the filename property */
+        contentType?: string | undefined;
+        /** optional transfer encoding for the attachment, if not set it will be derived from the contentType property. Example values: quoted-printable, base64. If it is unset then base64 encoding is used for the attachment. If it is set to false then previous default applies (base64 for most, 7bit for text). */
+        contentTransferEncoding?: "7bit" | "base64" | "quoted-printable" | false | undefined;
+        /** optional content disposition type for the attachment, defaults to ‘attachment’ */
+        contentDisposition?: "attachment" | "inline" | undefined;
+        /** is an object of additional headers */
+        headers?: Headers | undefined;
+        /** an optional value that overrides entire node content in the mime message. If used then all other options set for this node are ignored. */
+        raw?: string | Buffer | Readable | AttachmentLike | undefined;
+    }
+
+    interface AmpAttachment extends AttachmentLike {
+        /** is an alternative for content to load the AMP4EMAIL data from an URL */
+        href?: string | undefined;
+        /** defines optional content encoding, eg. ‘base64’ or ‘hex’. This only applies if the content is a string. By default an unicode string is assumed. */
+        encoding?: string | undefined;
+        /** optional content type for the attachment, if not set will be derived from the filename property */
+        contentType?: string | undefined;
+        /** an optional value that overrides entire node content in the mime message. If used then all other options set for this node are ignored. */
+        raw?: string | Buffer | Readable | AttachmentLike | undefined;
+    }
+
+    interface IcalAttachment extends AttachmentLike {
+        /** optional method, case insensitive, defaults to ‘publish’. Other possible values would be ‘request’, ‘reply’, ‘cancel’ or any other valid calendar method listed in RFC5546. This should match the METHOD: value in calendar event file. */
+        method?: string | undefined;
+        /** optional filename, defaults to ‘invite.ics’ */
+        filename?: string | false | undefined;
+        /** is an alternative for content to load the calendar data from an URL */
+        href?: string | undefined;
+        /** defines optional content encoding, eg. ‘base64’ or ‘hex’. This only applies if the content is a string. By default an unicode string is assumed. */
+        encoding?: string | undefined;
+    }
+
+    interface Connection {
+        connection: Socket;
+    }
+
+    interface Envelope {
+        /** the first address gets used as MAIL FROM address in SMTP */
+        from?: string | undefined;
+        /** addresses from this value get added to RCPT TO list */
+        to?: string | undefined;
+        /** addresses from this value get added to RCPT TO list */
+        cc?: string | undefined;
+        /** addresses from this value get added to RCPT TO list */
+        bcc?: string | undefined;
+    }
+
+    interface Options {
+        /** The e-mail address of the sender. All e-mail addresses can be plain 'sender@server.com' or formatted 'Sender Name <sender@server.com>' */
+        from?: string | Address | undefined;
+        /** An e-mail address that will appear on the Sender: field */
+        sender?: string | Address | undefined;
+        /** Comma separated list or an array of recipients e-mail addresses that will appear on the To: field */
+        to?: string | Address | Array<string | Address> | undefined;
+        /** Comma separated list or an array of recipients e-mail addresses that will appear on the Cc: field */
+        cc?: string | Address | Array<string | Address> | undefined;
+        /** Comma separated list or an array of recipients e-mail addresses that will appear on the Bcc: field */
+        bcc?: string | Address | Array<string | Address> | undefined;
+        /** Comma separated list or an array of e-mail addresses that will appear on the Reply-To: field */
+        replyTo?: string | Address | Array<string | Address> | undefined;
+        /** The message-id this message is replying */
+        inReplyTo?: string | Address | undefined;
+        /** Message-id list (an array or space separated string) */
+        references?: string | string[] | undefined;
+        /** The subject of the e-mail */
+        subject?: string | undefined;
+        /** The plaintext version of the message */
+        text?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** The HTML version of the message */
+        html?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** Apple Watch specific HTML version of the message, same usage as with text and html */
+        watchHtml?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** AMP4EMAIL specific HTML version of the message, same usage as with text and html. Make sure it is a full and valid AMP4EMAIL document, otherwise the displaying email client falls back to html and ignores the amp part */
+        amp?: string | Buffer | Readable | AmpAttachment | undefined;
+        /** iCalendar event, same usage as with text and html. Event method attribute defaults to ‘PUBLISH’ or define it yourself: {method: 'REQUEST', content: iCalString}. This value is added as an additional alternative to html or text. Only utf-8 content is allowed */
+        icalEvent?: string | Buffer | Readable | IcalAttachment | undefined;
+        /** An object or array of additional header fields */
+        headers?: Headers | undefined;
+        /** An object where key names are converted into list headers. List key help becomes List-Help header etc. */
+        list?: ListHeaders | undefined;
+        /** An array of attachment objects */
+        attachments?: Attachment[] | undefined;
+        /** An array of alternative text contents (in addition to text and html parts) */
+        alternatives?: Attachment[] | undefined;
+        /** optional SMTP envelope, if auto generated envelope is not suitable */
+        envelope?: Envelope | MimeNode.Envelope | undefined;
+        /** optional Message-Id value, random value will be generated if not set */
+        messageId?: string | undefined;
+        /** optional Date value, current UTC string will be used if not set */
+        date?: Date | string | undefined;
+        /** optional transfer encoding for the textual parts */
+        encoding?: string | undefined;
+        /** if set then overwrites entire message output with this value. The value is not parsed, so you should still set address headers or the envelope value for the message to work */
+        raw?: string | Buffer | Readable | AttachmentLike | undefined;
+        /** set explicitly which encoding to use for text parts (quoted-printable or base64). If not set then encoding is detected from text content (mostly ascii means quoted-printable, otherwise base64) */
+        textEncoding?: TextEncoding | undefined;
+        /** if set to true then fails with an error when a node tries to load content from URL */
+        disableUrlAccess?: boolean | undefined;
+        /** if set to true then fails with an error when a node tries to load content from a file */
+        disableFileAccess?: boolean | undefined;
+        /** is an object with DKIM options */
+        dkim?: DKIM.Options | undefined;
+        /** method to normalize header keys for custom caseing */
+        normalizeHeaderKey?(key: string): string;
+        priority?: "high" | "normal" | "low" | undefined;
+        /** if set to true then converts data:images in the HTML content of message to embedded attachments */
+        attachDataUrls?: boolean | undefined;
+        /**
+         * if set to false then removes x-mailer header, otherwise replaces the default x-mailer header value
+         */
+        xMailer?: false | string;
+    }
+
+    type PluginFunction<T = any> = (mail: MailMessage<T>, callback: (err?: Error | null) => void) => void;
+}
+
+/** Creates an object for exposing the Mail API */
+declare class Mail<T = any, DefaultTransportOptions = TransportOptions> extends EventEmitter {
+    options: Mail.Options;
+    meta: Map<string, any>;
+    dkim: DKIM;
+    transporter: Transport<T>;
+    logger: shared.Logger;
+
+    /** Usage: typeof transporter.MailMessage */
+    MailMessage: MailMessage<T>;
+
+    _defaults: DefaultTransportOptions;
+
+    constructor(transporter: Transport<T>, options?: TransportOptions, defaults?: DefaultTransportOptions);
+
+    /** Closes all connections in the pool. If there is a message being sent, the connection is closed later */
+    close(): void;
+
+    /** Returns true if there are free slots in the queue */
+    isIdle(): boolean;
+
+    /** Verifies SMTP configuration */
+    verify(callback: (err: Error | null, success: true) => void): void;
+    verify(): Promise<true>;
+
+    use(step: string, plugin: Mail.PluginFunction<T>): this;
+
+    /** Sends an email using the preselected transport object */
+    sendMail(
+        mailOptions: Mail.Options & Partial<DefaultTransportOptions>,
+        callback: (err: Error | null, info: T) => void,
+    ): void;
+    sendMail(mailOptions: Mail.Options, callback: (err: Error | null, info: T) => void): void;
+    sendMail(mailOptions: Mail.Options & Partial<DefaultTransportOptions>): Promise<T>;
+    sendMail(mailOptions: Mail.Options): Promise<T>;
+
+    getVersionString(): string;
+
+    /** Sets up proxy handler for a Nodemailer object */
+    setupProxy(proxyUrl: string): void;
+
+    set(
+        key: "oauth2_provision_cb",
+        value: (
+            user: string,
+            renew: boolean,
+            callback: (err: Error | null, accessToken?: string, expires?: number) => void,
+        ) => void,
+    ): Map<string, any>;
+    set(
+        key:
+            | "proxy_handler_http"
+            | "proxy_handler_https"
+            | "proxy_handler_socks"
+            | "proxy_handler_socks5"
+            | "proxy_handler_socks4"
+            | "proxy_handler_socks4a",
+        value: (
+            proxy: Url,
+            options: TransportOptions,
+            callback: (err: Error | null, socketOptions?: { connection: Socket }) => void,
+        ) => void,
+    ): Map<string, any>;
+    set(key: string, value: any): Map<string, any>;
+
+    get(
+        key: "oauth2_provision_cb",
+    ): (
+        user: string,
+        renew: boolean,
+        callback: (err: Error | null, accessToken: string, expires: number) => void,
+    ) => void;
+    get(
+        key:
+            | "proxy_handler_http"
+            | "proxy_handler_https"
+            | "proxy_handler_socks"
+            | "proxy_handler_socks5"
+            | "proxy_handler_socks4"
+            | "proxy_handler_socks4a",
+    ): (
+        proxy: Url,
+        options: TransportOptions,
+        callback: (err: Error | null, socketOptions: { connection: Socket }) => void,
+    ) => void;
+    get(key: string): any;
+
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "idle", listener: () => void): this;
+    addListener(event: "token", listener: (token: XOAuth2.Token) => void): this;
+
+    emit(event: "error", error: Error): boolean;
+    emit(event: "idle"): boolean;
+    emit(event: "token", token: XOAuth2.Token): boolean;
+
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "idle", listener: () => void): this;
+    on(event: "token", listener: (token: XOAuth2.Token) => void): this;
+
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: "idle", listener: () => void): this;
+    once(event: "token", listener: (token: XOAuth2.Token) => void): this;
+
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: "idle", listener: () => void): this;
+    prependListener(event: "end", listener: (token: XOAuth2.Token) => void): this;
+
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: "idle", listener: () => void): this;
+    prependOnceListener(event: "end", listener: (token: XOAuth2.Token) => void): this;
+
+    listeners(event: "error"): Array<(err: Error) => void>;
+    listeners(event: "idle"): Array<() => void>;
+    listeners(event: "end"): Array<(token: XOAuth2.Token) => void>;
+}
+
+export = Mail;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/mailer/mail-message.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+
+import { Readable } from "stream";
+
+import Mail = require(".");
+import MimeNode = require("../mime-node");
+
+declare class MailMessage<T = any> {
+    mailer: Mail<T>;
+    data: Mail.Options;
+    message: MimeNode;
+
+    constructor(mailer: Mail<T>, data: Mail.Options);
+
+    resolveContent(
+        data: object | any[],
+        key: string | number,
+        callback: (err: Error | null, value?: any) => any,
+    ): Promise<any>;
+
+    resolveAll(callback: (err?: Error | null, data?: Mail.Options) => void): void;
+
+    normalize(callback: (err?: Error | null, data?: Mail.Options) => void): void;
+
+    setMailerHeader(): void;
+
+    setPriorityHeaders(): void;
+
+    setListHeaders(): void;
+}
+
+export = MailMessage;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/mime-funcs/index.d.ts

@@ -0,0 +1,87 @@
+export interface HeaderValue {
+    value: string;
+    params?: { [key: string]: string } | undefined;
+}
+
+export interface ParsedHeaderValue extends HeaderValue {
+    params: { [key: string]: string };
+}
+
+export interface ParsedHeaderParam {
+    key: string;
+    value: string;
+}
+
+/** Checks if a value is plaintext string (uses only printable 7bit chars) */
+export function isPlainText(value: string): boolean;
+
+/**
+ * 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
+ */
+export function hasLongerLines(str: string, lineLength: number): boolean;
+
+/** Encodes a string or an Buffer to an UTF-8 MIME Word (rfc2047) */
+export function encodeWord(data: Buffer | string, mimeWordEncoding?: "Q" | "B", maxLength?: number): string;
+
+/** Finds word sequences with non ascii text and converts these to mime words */
+export function encodeWords(value: string, mimeWordEncoding?: "Q" | "B", maxLength?: number): 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
+ */
+export function buildHeaderValue(structured: HeaderValue): 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
+ * ```
+ */
+export function buildHeaderParam(key: string, data: Buffer | string, maxLength?: number): ParsedHeaderParam[];
+
+/**
+ * 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'
+ *     }
+ *   }
+ * ```
+ */
+export 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 */
+export function detectExtension(mimeType: string): 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 */
+export function detectMimeType(extension: string): string;
+
+/** Folds long lines, useful for folding header lines (afterSpace=false) and flowed text (afterSpace=true) */
+export function foldLines(str: string, lineLength?: number, afterSpace?: boolean): string;
+
+/** Splits a mime encoded string. Needed for dividing mime words into smaller chunks */
+export function splitMimeEncodedString(str: string, maxlen?: number): string[];
+
+export function encodeURICharComponent(chr: string): string;
+
+export function safeEncodeURIComponent(str: string): string;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/mime-funcs/mime-types.d.ts

@@ -0,0 +1,2 @@
+export function detectMimeType(filename: string | false): string;
+export function detectExtension(mimeType: string | false): string;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/mime-node/index.d.ts

@@ -0,0 +1,224 @@
+/// <reference types="node" />
+
+import { Readable, ReadableOptions, Transform } from "stream";
+
+import Mail = require("../mailer");
+
+declare namespace MimeNode {
+    interface Addresses {
+        from?: string[] | undefined;
+        sender?: string[] | undefined;
+        "reply-to"?: string[] | undefined;
+        to?: string[] | undefined;
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
+    }
+
+    interface Envelope {
+        /** includes an address object or is set to false */
+        from: string | false;
+        /** includes an array of address objects */
+        to: string[];
+    }
+
+    interface Options {
+        /** root node for this tree */
+        rootNode?: MimeNode | undefined;
+
+        /** immediate parent for this node */
+        parentNode?: MimeNode | undefined;
+
+        /** filename for an attachment node */
+        filename?: string | undefined;
+
+        /** Hostname for default message-id values */
+        hostname?: string | undefined;
+
+        /** shared part of the unique multipart boundary */
+        baseBoundary?: string | undefined;
+
+        /** If true, do not exclude Bcc from the generated headers */
+        keepBcc?: boolean | undefined;
+
+        /**
+         * If set to 'win' then uses \r\n,
+         * if 'linux' then \n.
+         * If not set (or `raw` is used) then newlines are kept as is.
+         */
+        newline?: string | undefined;
+
+        /** either 'Q' (the default) or 'B' */
+        textEncoding?: "B" | "Q" | undefined;
+
+        /** method to normalize header keys for custom caseing */
+        normalizeHeaderKey?(key: string): string;
+
+        /** undocumented */
+        boundaryPrefix?: string | undefined;
+
+        /** Undocumented */
+        disableFileAccess?: boolean | undefined;
+
+        /** Undocumented */
+        disableUrlAccess?: boolean | undefined;
+    }
+}
+
+/**
+ * Creates a new mime tree node. Assumes 'multipart/*' as the content type
+ * if it is a branch, anything else counts as leaf. If rootNode is missing from
+ * the options, assumes this is the root.
+ */
+declare class MimeNode {
+    constructor(contentType?: string, options?: MimeNode.Options);
+
+    /** Creates and appends a child node.Arguments provided are passed to MimeNode constructor */
+    createChild(contentType: string, options?: MimeNode.Options): MimeNode;
+
+    /** Appends an existing node to the mime tree. Removes the node from an existing tree if needed */
+    appendChild(childNode: MimeNode): MimeNode;
+
+    /** Replaces current node with another node */
+    replace(node: MimeNode): MimeNode;
+
+    /** Removes current node from the mime tree */
+    remove(): this;
+
+    /**
+     * Sets a header value. If the value for selected key exists, it is overwritten.
+     * You can set multiple values as well by using [{key:'', value:''}] or
+     * {key: 'value'} as the first argument.
+     */
+    setHeader(key: string, value: string | string[]): this;
+    setHeader(headers: { [key: string]: string } | Array<{ key: string; value: string }>): this;
+
+    /**
+     * Adds a header value. If the value for selected key exists, the value is appended
+     * as a new field and old one is not touched.
+     * You can set multiple values as well by using [{key:'', value:''}] or
+     * {key: 'value'} as the first argument.
+     */
+    addHeader(key: string, value: string): this;
+    addHeader(headers: { [key: string]: string } | Array<{ key: string; value: string }>): this;
+
+    /** Retrieves the first mathcing value of a selected key */
+    getHeader(key: string): string;
+
+    /**
+     * Sets body content for current node. If the value is a string, charset is added automatically
+     * to Content-Type (if it is text/*). If the value is a Buffer, you need to specify
+     * the charset yourself
+     */
+    setContent(content: string | Buffer | Readable): this;
+
+    /** Generate the message and return it with a callback or promise */
+    build(callback: (err: Error | null, buf: Buffer) => void): void;
+    build(): Promise<Buffer>;
+
+    getTransferEncoding(): string;
+
+    /** Builds the header block for the mime node. Append \r\n\r\n before writing the content */
+    buildHeaders(): string;
+
+    /**
+     * Streams the rfc2822 message from the current node. If this is a root node,
+     * mandatory header fields are set if missing (Date, Message-Id, MIME-Version)
+     */
+    createReadStream(options?: ReadableOptions): Readable;
+
+    /**
+     * Appends a transform stream object to the transforms list. Final output
+     * is passed through this stream before exposing
+     */
+    transform(transform: Transform): void;
+
+    /**
+     * Appends a post process function. The functon is run after transforms and
+     * uses the following syntax
+     *
+     *   processFunc(input) -> outputStream
+     */
+    processFunc(processFunc: (outputStream: Readable) => Readable): void;
+
+    stream(outputStream: Readable, options: ReadableOptions, done: (err?: Error | null) => void): void;
+
+    /** Sets envelope to be used instead of the generated one */
+    setEnvelope(envelope: Mail.Envelope): this;
+
+    /** Generates and returns an object with parsed address fields */
+    getAddresses(): MimeNode.Addresses;
+
+    /** Generates and returns SMTP envelope with the sender address and a list of recipients addresses */
+    getEnvelope(): MimeNode.Envelope;
+
+    /** Returns Message-Id value. If it does not exist, then creates one */
+    messageId(): string;
+
+    /** Sets pregenerated content that will be used as the output of this node */
+    setRaw(raw: string | Buffer | Readable): this;
+
+    /** shared part of the unique multipart boundary */
+    baseBoundary: string;
+
+    /** a multipart boundary value */
+    boundary?: string | false | undefined;
+
+    /** Undocumented */
+    boundaryPrefix: string;
+
+    /* An array for possible child nodes */
+    childNodes: MimeNode[];
+
+    /** body content for current node */
+    content?: string | Buffer | Readable | undefined;
+
+    /** Undocumented */
+    contentType?: string | undefined;
+
+    /**
+     * If date headers is missing and current node is the root, this value is used instead
+     */
+    date: Date;
+
+    /** Undocumented */
+    disableFileAccess: boolean;
+
+    /** Undocumented */
+    disableUrlAccess: boolean;
+
+    /** filename for an attachment node */
+    filename?: string | undefined;
+
+    /** Hostname for default message-id values */
+    hostname?: string | undefined;
+
+    /** If true, do not exclude Bcc from the generated headers */
+    keepBcc: boolean;
+
+    /** Undocumented */
+    multipart?: boolean | undefined;
+
+    /**
+     * If set to 'win' then uses \r\n,
+     * if 'linux' then \n.
+     * If not set (or `raw` is used) then newlines are kept as is.
+     */
+    newline?: string | undefined;
+
+    /** Undocumented */
+    nodeCounter: number;
+
+    /** method to normalize header keys for custom caseing */
+    normalizeHeaderKey?: ((key: string) => string) | undefined;
+
+    /* Immediate parent for this node (or undefined if not set) */
+    parentNode?: MimeNode | undefined;
+
+    /** root node for this tree */
+    rootNode: MimeNode;
+
+    /** either 'Q' (the default) or 'B' */
+    textEncoding: "B" | "Q" | "";
+}
+
+export = MimeNode;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/mime-node/last-newline.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+
+import { Transform } from "stream";
+
+declare class LastNewline extends Transform {
+    lastByte: boolean;
+}
+
+export = LastNewline;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/qp/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+
+import { Transform, TransformOptions } from "stream";
+
+/** Encodes a Buffer into a Quoted-Printable encoded string */
+export function encode(buffer: Buffer | string): string;
+
+/** Adds soft line breaks to a Quoted-Printable string */
+export function wrap(str: string, lineLength?: number): string;
+
+export interface EncoderOptions extends TransformOptions {
+    lineLength?: number | false | undefined;
+}
+
+/** Creates a transform stream for encoding data to Quoted-Printable encoding */
+export class Encoder extends Transform {
+    options: EncoderOptions;
+
+    inputBytes: number;
+    outputBytes: number;
+
+    constructor(options?: EncoderOptions);
+}