@bobfrankston/mailx 1.0.465 → 1.0.500

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/nodemailer`
+
+# Summary
+This package contains type definitions for nodemailer (https://github.com/nodemailer/nodemailer).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nodemailer/v6.
+
+### Additional Details
+ * Last updated: Fri, 20 Feb 2026 20:05:00 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+
+# Credits
+These definitions were written by [Rogier Schouten](https://github.com/rogierschouten), [Piotr Roszatycki](https://github.com/dex4er), and [Daniel Chao](https://github.com/bioball).

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

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+
+import JSONTransport = require("./lib/json-transport");
+import Mail = require("./lib/mailer");
+import MailMessage = require("./lib/mailer/mail-message");
+import SendmailTransport = require("./lib/sendmail-transport");
+import SESTransport = require("./lib/ses-transport");
+import SMTPPool = require("./lib/smtp-pool");
+import SMTPTransport = require("./lib/smtp-transport");
+import StreamTransport = require("./lib/stream-transport");
+
+export type SendMailOptions = Mail.Options;
+
+export type Transporter<T = any, D extends TransportOptions = TransportOptions> = Mail<T, D>;
+
+export type SentMessageInfo = any;
+
+export interface Transport<T = any, D extends TransportOptions = TransportOptions> {
+    mailer?: Transporter<T, D> | undefined;
+
+    name: string;
+    version: string;
+
+    send(mail: MailMessage<T>, callback: (err: Error | null, info: T) => void): void;
+
+    verify?(callback: (err: Error | null, success: true) => void): void;
+    verify?(): Promise<true>;
+
+    close?(): void;
+}
+
+export interface TransportOptions {
+    component?: string | undefined;
+}
+
+export interface TestAccount {
+    user: string;
+    pass: string;
+    smtp: { host: string; port: number; secure: boolean };
+    imap: { host: string; port: number; secure: boolean };
+    pop3: { host: string; port: number; secure: boolean };
+    web: string;
+}
+
+export function createTransport(
+    transport: SMTPPool | SMTPPool.Options,
+    defaults?: SMTPPool.Options,
+): Transporter<SMTPPool.SentMessageInfo, SMTPPool.Options>;
+export function createTransport(
+    transport: SendmailTransport | SendmailTransport.Options,
+    defaults?: SendmailTransport.Options,
+): Transporter<SendmailTransport.SentMessageInfo, SendmailTransport.Options>;
+export function createTransport(
+    transport: StreamTransport | StreamTransport.Options,
+    defaults?: StreamTransport.Options,
+): Transporter<StreamTransport.SentMessageInfo, StreamTransport.Options>;
+export function createTransport(
+    transport: JSONTransport | JSONTransport.Options,
+    defaults?: JSONTransport.Options,
+): Transporter<JSONTransport.SentMessageInfo, JSONTransport.Options>;
+export function createTransport(
+    transport: SESTransport | SESTransport.Options,
+    defaults?: SESTransport.Options,
+): Transporter<SESTransport.SentMessageInfo, SESTransport.Options>;
+export function createTransport(
+    transport?: SMTPTransport | SMTPTransport.Options | string,
+    defaults?: SMTPTransport.Options,
+): Transporter<SMTPTransport.SentMessageInfo, SMTPTransport.Options>;
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+export function createTransport<T>(
+    transport: Transport<T> | TransportOptions,
+    defaults?: TransportOptions,
+): Transporter<SMTPTransport.SentMessageInfo, SMTPTransport.Options>;
+
+export function createTestAccount(
+    apiUrl: string,
+    callback: (err: Error | null, testAccount: TestAccount) => void,
+): void;
+export function createTestAccount(callback: (err: Error | null, testAccount: TestAccount) => void): void;
+export function createTestAccount(apiUrl?: string): Promise<TestAccount>;
+
+export function getTestMessageUrl(info: SESTransport.SentMessageInfo | SMTPTransport.SentMessageInfo): string | false;

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

@@ -0,0 +1,31 @@
+declare namespace addressparser {
+    interface Address {
+        name: string;
+        address: string;
+    }
+
+    interface Group {
+        name: string;
+        group: AddressOrGroup[];
+    }
+
+    type AddressOrGroup = Address | Group;
+}
+
+/**
+ * Parses structured e-mail addresses from an address field
+ *
+ * Example:
+ *
+ *    'Name <address@domain>'
+ *
+ * will be converted to
+ *
+ *     [{name: 'Name', address: 'address@domain'}]
+ *
+ * @return An array of address objects
+ */
+declare function addressparser(address: string, options: { flatten: true }): addressparser.Address[];
+declare function addressparser(address: string, options?: { flatten: false }): addressparser.AddressOrGroup[];
+
+export = addressparser;

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

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

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

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+
+import { PassThrough, Readable } from "stream";
+
+declare namespace DKIM {
+    interface OptionalOptions {
+        /** optional location for cached messages. If not set then caching is not used. */
+        cacheDir?: string | false | undefined;
+        /** optional size in bytes, if message is larger than this treshold it gets cached to disk (assuming cacheDir is set and writable). Defaults to 131072 (128 kB). */
+        cacheTreshold?: number | undefined;
+        /** optional algorithm for the body hash, defaults to ‘sha256’ */
+        hashAlgo?: string | undefined;
+        /** an optional colon separated list of header keys to sign (eg. message-id:date:from:to...') */
+        headerFieldNames?: string | undefined;
+        /** optional colon separated list of header keys not to sign. This is useful if you want to sign all the relevant keys but your provider changes some values, ie Message-ID and Date. In this case you should use 'message-id:date' to prevent signing these values. */
+        skipFields?: string | undefined;
+    }
+
+    interface SingleKeyOptions extends OptionalOptions {
+        /** is the domain name to use in the signature */
+        domainName: string;
+        /** is the DKIM key selector */
+        keySelector: string;
+        /** is the private key for the selector in PEM format */
+        privateKey: string | { key: string; passphrase: string };
+    }
+
+    interface MultipleKeysOptions extends OptionalOptions {
+        /** is an optional array of key objects (domainName, keySelector, privateKey) if you want to add more than one signature to the message. If this value is set then the default key values are ignored */
+        keys: SingleKeyOptions[];
+    }
+
+    type Options = SingleKeyOptions | MultipleKeysOptions;
+}
+
+declare class DKIM {
+    options: DKIM.Options;
+    keys: DKIM.SingleKeyOptions[];
+
+    constructor(options?: DKIM.Options);
+
+    sign(input: string | Buffer | Readable, extraOptions?: DKIM.Options): PassThrough;
+}
+
+export = DKIM;

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

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+
+import { Transform } from "stream";
+
+declare namespace MessageParser {
+    interface Header {
+        key: string;
+        line: string;
+    }
+}
+
+/**
+ * MessageParser instance is a transform stream that separates message headers
+ * from the rest of the body. Headers are emitted with the 'headers' event. Message
+ * body is passed on as the resulting stream.
+ */
+declare class MessageParser extends Transform {
+    addListener(event: "headers", listener: (headers: MessageParser.Header[]) => void): this;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "data", listener: (chunk: any) => void): this;
+    addListener(event: "end", listener: () => void): this;
+    addListener(event: "readable", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    emit(event: "headers", headers: MessageParser.Header[]): boolean;
+    emit(event: "close"): boolean;
+    emit(event: "data", chunk: any): boolean;
+    emit(event: "end"): boolean;
+    emit(event: "readable"): boolean;
+    emit(event: "error", err: Error): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+
+    on(event: "headers", listener: (headers: MessageParser.Header[]) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "data", listener: (chunk: any) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "readable", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    once(event: "headers", listener: (headers: MessageParser.Header[]) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "data", listener: (chunk: any) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "readable", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependListener(event: "headers", listener: (headers: MessageParser.Header[]) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "data", listener: (chunk: any) => void): this;
+    prependListener(event: "end", listener: () => void): this;
+    prependListener(event: "readable", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependOnceListener(event: "headers", listener: (headers: MessageParser.Header[]) => void): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "data", listener: (chunk: any) => void): this;
+    prependOnceListener(event: "end", listener: () => void): this;
+    prependOnceListener(event: "readable", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: "headers", listener: (headers: MessageParser.Header[]) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "data", listener: (chunk: any) => void): this;
+    removeListener(event: "end", listener: () => void): this;
+    removeListener(event: "readable", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+export = MessageParser;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/dkim/relaxed-body.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+
+import { Transform, TransformOptions } from "stream";
+
+declare namespace RelaxedBody {
+    interface Options extends TransformOptions {
+        hashAlgo?: string;
+        debug?: boolean;
+    }
+}
+
+/**
+ * Streams through a message body and calculates relaxed body hash
+ */
+declare class RelaxedBody extends Transform {
+    constructor(options?: RelaxedBody.Options);
+
+    addListener(event: "hash", listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "data", listener: (chunk: any) => void): this;
+    addListener(event: "end", listener: () => void): this;
+    addListener(event: "readable", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    emit(event: "hash", digest: Buffer, debugBody: Buffer | false): boolean;
+    emit(event: "close"): boolean;
+    emit(event: "data", chunk: any): boolean;
+    emit(event: "end"): boolean;
+    emit(event: "readable"): boolean;
+    emit(event: "error", err: Error): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+
+    on(event: "hash", listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "data", listener: (chunk: any) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "readable", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    once(event: "hash", listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "data", listener: (chunk: any) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "readable", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependListener(event: "hash", listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "data", listener: (chunk: any) => void): this;
+    prependListener(event: "end", listener: () => void): this;
+    prependListener(event: "readable", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    prependOnceListener(event: "hash", listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "data", listener: (chunk: any) => void): this;
+    prependOnceListener(event: "end", listener: () => void): this;
+    prependOnceListener(event: "readable", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: "hash", listener: (digest: Buffer, debugBody: Buffer | false) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "data", listener: (chunk: any) => void): this;
+    removeListener(event: "end", listener: () => void): this;
+    removeListener(event: "readable", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+export = RelaxedBody;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/dkim/sign.d.ts

@@ -0,0 +1,21 @@
+import DKIM = require(".");
+import MessageParser = require("./message-parser");
+
+/** Returns DKIM signature header line */
+declare function relaxedHeaders(
+    headers: MessageParser.Header[],
+    hashAlgo: string,
+    bodyHash: string,
+    options?: DKIM.SingleKeyOptions,
+): string;
+
+declare namespace relaxedHeaders {
+    function relaxedHeaders(
+        headers: MessageParser.Header[],
+        hashAlgo: string,
+        bodyHash: string,
+        options?: DKIM.SingleKeyOptions,
+    ): string;
+}
+
+export = relaxedHeaders;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/fetch/cookies.d.ts

@@ -0,0 +1,54 @@
+type s = number;
+
+declare namespace Cookies {
+    interface Cookie {
+        name: string;
+        value?: string | undefined;
+        expires?: Date | undefined;
+        path?: string | undefined;
+        domain?: string | undefined;
+        secure?: boolean | undefined;
+        httponly?: boolean | undefined;
+    }
+
+    interface Options {
+        sessionTimeout?: s | undefined;
+    }
+}
+
+/** Creates a biskviit cookie jar for managing cookie values in memory */
+declare class Cookies {
+    options: Cookies.Options;
+    cookies: Cookies.Cookie[];
+
+    constructor(options?: Cookies.Options);
+
+    /** Stores a cookie string to the cookie storage */
+    set(cookieStr: string, url: string): boolean;
+
+    /** Returns cookie string for the 'Cookie:' header. */
+    get(url: string): string;
+
+    /** Lists all valied cookie objects for the specified URL */
+    list(url: string): Cookies.Cookie[];
+
+    /** Parses cookie string from the 'Set-Cookie:' header */
+    parse(cookieStr: string): Cookies.Cookie;
+
+    /** Checks if a cookie object is valid for a specified URL */
+    match(cookie: Cookies.Cookie, url: string): boolean;
+
+    /** Adds (or updates/removes if needed) a cookie object to the cookie storage */
+    add(cookie: Cookies.Cookie): boolean;
+
+    /** Checks if two cookie objects are the same */
+    compare(a: Cookies.Cookie, b: Cookies.Cookie): boolean;
+
+    /** Checks if a cookie is expired */
+    isExpired(cookie: Cookies.Cookie): boolean;
+
+    /** Returns normalized cookie path for an URL path argument */
+    getPath(pathname: string): string;
+}
+
+export = Cookies;

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

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+
+type ms = number;
+
+import _Cookies = require("./cookies");
+
+import * as http from "http";
+import { Writable } from "stream";
+import * as tls from "tls";
+
+declare namespace fetch {
+    type Cookies = _Cookies;
+
+    interface WritableResponse extends Writable {
+        statusCode: number;
+        headers: http.IncomingHttpHeaders;
+    }
+
+    interface Options {
+        fetchRes?: Writable | undefined;
+        cookies?: Cookies | undefined;
+        cookie?: string | undefined;
+        redirects?: number | undefined;
+        maxRedirects?: number | undefined;
+        method?: string | undefined;
+        headers?: { [key: string]: string } | undefined;
+        userAgent?: string | undefined;
+        body?: Buffer | string | { [key: string]: string } | undefined;
+        contentType?: string | false | undefined;
+        tls?: tls.TlsOptions | undefined;
+        timeout?: ms | undefined;
+        allowErrorResponse?: boolean | undefined;
+    }
+}
+
+declare function fetch(url: string, options?: fetch.Options): fetch.WritableResponse;
+
+export = fetch;

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

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+
+import { EventEmitter } from "events";
+
+import { Transport, TransportOptions } from "../..";
+
+import * as shared from "../shared";
+
+import Mail = require("../mailer");
+import MailMessage = require("../mailer/mail-message");
+import MimeNode = require("../mime-node");
+
+declare namespace JSONTransport {
+    type MailOptions = Mail.Options;
+
+    interface Options extends MailOptions, TransportOptions {
+        jsonTransport: true;
+        skipEncoding?: boolean | undefined;
+    }
+
+    interface SentMessageInfo {
+        /** an envelope object {from:‘address’, to:[‘address’]} */
+        envelope: MimeNode.Envelope;
+        /** the Message-ID header value */
+        messageId: string;
+        /** JSON string */
+        message: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+        response: string;
+    }
+}
+
+declare class JSONTransport implements Transport<JSONTransport.SentMessageInfo> {
+    options: JSONTransport.Options;
+
+    logger: shared.Logger;
+    mailer: Mail<JSONTransport.SentMessageInfo>;
+
+    name: string;
+    version: string;
+
+    constructor(options: JSONTransport.Options);
+
+    /** Compiles a mailcomposer message and forwards it to handler that sends it */
+    send(
+        mail: MailMessage<JSONTransport.SentMessageInfo>,
+        callback: (err: Error | null, info: JSONTransport.SentMessageInfo) => void,
+    ): void;
+}
+
+export = JSONTransport;

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

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+
+import { URL } from "url";
+
+import Mail = require("../mailer");
+import MimeNode = require("../mime-node");
+
+/** Creates the object for composing a MimeNode instance out from the mail options */
+declare class MailComposer {
+    mail: Mail.Options;
+    message: MimeNode | false;
+
+    constructor(mail: Mail.Options);
+
+    /** Builds MimeNode instance */
+    compile(): MimeNode;
+
+    /** List all attachments. Resulting attachment objects can be used as input for MimeNode nodes */
+    getAttachments(findRelated: boolean): Mail.Attachment[];
+
+    /** List alternatives. Resulting objects can be used as input for MimeNode nodes */
+    getAlternatives(): Mail.Attachment[];
+}
+
+export = MailComposer;