@bobfrankston/mailx 1.0.1

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

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+
+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 SendmailTransport {
+    type MailOptions = Mail.Options;
+
+    interface Options extends MailOptions, TransportOptions {
+        sendmail: true;
+        /** path to the sendmail command (defaults to ‘sendmail’) */
+        path?: string | undefined;
+        /** either ‘windows’ or ‘unix’ (default). Forces all newlines in the output to either use Windows syntax <CR><LF> or Unix syntax <LF> */
+        newline?: string | undefined;
+        /** an optional array of command line options to pass to the sendmail command (ie. ["-f", "foo@blurdybloop.com"]). This overrides all default arguments except for ’-i’ and recipient list so you need to make sure you have all required arguments set (ie. the ‘-f’ flag). */
+        args?: string[] | undefined;
+    }
+
+    interface SentMessageInfo {
+        envelope: MimeNode.Envelope;
+        messageId: string;
+        response: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+    }
+}
+
+declare class SendmailTransport implements Transport<SendmailTransport.SentMessageInfo> {
+    options: SendmailTransport.Options;
+    logger: shared.Logger;
+    mailer: Mail<SendmailTransport.SentMessageInfo>;
+    name: string;
+    version: string;
+    path: string;
+    args: string[] | false;
+    winbreak: boolean;
+
+    constructor(options: SendmailTransport.Options);
+
+    /** Compiles a mailcomposer message and forwards it to handler that sends it */
+    send(
+        mail: MailMessage<SendmailTransport.SentMessageInfo>,
+        callback: (err: Error | null, info: SendmailTransport.SentMessageInfo) => void,
+    ): void;
+}
+
+export = SendmailTransport;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/sendmail-transport/le-unix.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+
+import { Transform } from "stream";
+
+declare class LeUnix extends Transform {}
+
+export = LeUnix;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/sendmail-transport/le-windows.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+
+import { Transform } from "stream";
+
+declare class LeWindows extends Transform {}
+
+export = LeWindows;

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

@@ -0,0 +1,146 @@
+/// <reference types="node" />
+
+import { EventEmitter } from "node: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 SESTransport {
+    /**
+     * Minimal structural shape of SES SendEmail input.
+     * This is intentionally structural so @types/nodemailer does not require
+     * installing @aws-sdk/client-ses.
+     *
+     * If you want the full, exact type, install @aws-sdk/client-ses in your
+     * app and use its types directly in your own code.
+     */
+    interface SendEmailRequestLike {
+        Source?: string;
+        Destination?: {
+            ToAddresses?: string[];
+            CcAddresses?: string[];
+            BccAddresses?: string[];
+        };
+        Message?: unknown;
+        ReplyToAddresses?: string[];
+        ReturnPath?: string;
+        SourceArn?: string;
+        ReturnPathArn?: string;
+        Tags?: Array<{ Name?: string; Value?: string }>;
+        ConfigurationSetName?: string;
+        // Allow extra fields without forcing the SDK type package
+        [key: string]: unknown;
+    }
+
+    /** Structural type matching SES client from @aws-sdk/client-ses */
+    interface SESClientLike {
+        /** Used with v3 low-level client + SendRawEmailCommand */
+        send?(command: unknown): Promise<{ MessageId?: string }>;
+        /** Used with v3 high-level SES class or v2 SDK */
+        sendRawEmail?(params: unknown, options?: unknown): Promise<{ MessageId?: string }>;
+        config?: {
+            region?: string | (() => Promise<string>);
+        };
+    }
+
+    /** Structural type matching the aws module shape */
+    interface AwsModuleLike {
+        SendRawEmailCommand?: unknown;
+        [key: string]: unknown;
+    }
+
+    interface MailOptions extends Mail.Options {
+        /** list of keys that SendRawEmail method can take */
+        ses?: MailSesOptions | undefined;
+    }
+
+    // Keep it as an interface for backward-compatibility
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface MailSesOptions extends Partial<SendEmailRequestLike> {}
+
+    interface Options extends MailOptions, TransportOptions {
+        /** An option that expects an instantiated aws.SES object */
+        SES:
+            | {
+                ses: SESClientLike;
+                aws: AwsModuleLike;
+            }
+            | SESClientLike;
+        /** How many messages per second is allowed to be delivered to SES */
+        maxConnections?: number | undefined;
+        /** How many parallel connections to allow towards SES */
+        sendingRate?: number | undefined;
+    }
+
+    interface SentMessageInfo {
+        /** an envelope object {from:'address', to:['address']} */
+        envelope: MimeNode.Envelope;
+        /** the Message-ID header value. This value is derived from the response of SES API, so it differs from the Message-ID values used in logging. */
+        messageId: string;
+        response: string;
+        accepted: Array<string | Mail.Address>;
+        rejected: Array<string | Mail.Address>;
+        pending: Array<string | Mail.Address>;
+        raw: Buffer;
+    }
+}
+
+declare class SESTransport extends EventEmitter implements Transport<SESTransport.SentMessageInfo> {
+    options: SESTransport.Options;
+
+    logger: shared.Logger;
+    mailer: Mail<SESTransport.SentMessageInfo>;
+
+    name: string;
+    version: string;
+
+    ses: SESTransport.Options["SES"];
+
+    maxConnections: number;
+    connections: number;
+    sendingRate: number;
+    sendingRateTTL: number | null;
+    rateInterval: number;
+    rateMessages: Array<{ ts: number; pending: boolean }>;
+    pending: Array<
+        {
+            mail: Mail<SESTransport.SentMessageInfo>;
+            callback(err: Error | null, info: SESTransport.SentMessageInfo): void;
+        }
+    >;
+    idling: boolean;
+
+    constructor(options: SESTransport.Options);
+
+    /** Schedules a sending of a message */
+    send(
+        mail: MailMessage<SESTransport.SentMessageInfo>,
+        callback: (err: Error | null, info: SESTransport.SentMessageInfo) => void,
+    ): void;
+
+    /** Returns true if there are free slots in the queue */
+    isIdle(): boolean;
+
+    /** Verifies SES configuration */
+    verify(callback: (err: Error | null, success: true) => void): void;
+    verify(): Promise<true>;
+
+    addListener(event: "idle", listener: () => void): this;
+
+    emit(event: "idle"): boolean;
+
+    on(event: "idle", listener: () => void): this;
+
+    once(event: "idle", listener: () => void): this;
+
+    prependListener(event: "idle", listener: () => void): this;
+
+    prependOnceListener(event: "idle", listener: () => void): this;
+
+    listeners(event: "idle"): Array<() => void>;
+}
+
+export = SESTransport;

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

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+
+import SMTPConnection = require("../smtp-connection");
+
+import stream = require("stream");
+
+export type LoggerLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+
+export interface Logger {
+    level(level: LoggerLevel): void;
+    trace(...params: any[]): void;
+    debug(...params: any[]): void;
+    info(...params: any[]): void;
+    warn(...params: any[]): void;
+    error(...params: any[]): void;
+    fatal(...params: any[]): void;
+}
+
+export interface ResolveHostnameOptions {
+    host?: string | undefined;
+    servername?: string | false | undefined;
+}
+
+export interface ResolveHostnameValue {
+    host: string;
+    servername: string | false;
+    _cached?: true | undefined;
+}
+
+export function resolveHostname(
+    options: ResolveHostnameOptions | null | undefined,
+    callback: (err: Error | null, value: ResolveHostnameValue) => void,
+): void;
+
+/** Parses connection url to a structured configuration object */
+export function parseConnectionUrl(url: string): SMTPConnection.Options;
+/** Returns a bunyan-compatible logger interface. Uses either provided logger or creates a default console logger */
+export function getLogger(options?: { [key: string]: any }, defaults?: { [key: string]: any }): Logger;
+/** Wrapper for creating a callback than either resolves or rejects a promise based on input */
+export function callbackPromise(resolve: (...args: any[]) => void, reject: (err: Error) => void): () => void;
+/**
+ * Resolves a String or a Buffer value for content value. Useful if the value
+ * is a Stream or a file or an URL. If the value is a Stream, overwrites
+ * the stream object with the resolved value (you can't stream a value twice).
+ *
+ * This is useful when you want to create a plugin that needs a content value,
+ * for example the `html` or `text` value as a String or a Buffer but not as
+ * a file path or an URL.
+ */
+export function resolveContent(
+    data: object | any[],
+    key: string | number,
+    callback: (err: Error | null, value: Buffer | string) => void,
+): void;
+export function resolveContent(data: object | any[], key: string | number): Promise<Buffer | string>;
+/** Copies properties from source objects to target objects */
+export function assign(target: object, ...sources: object[]): object;
+export function encodeXText(str: string): string;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/smtp-connection/data-stream.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+
+import { Transform } from "stream";
+
+/**
+ * Escapes dots in the beginning of lines. Ends the stream with <CR><LF>.<CR><LF>
+ * Also makes sure that only <CR><LF> sequences are used for linebreaks
+ */
+declare class DataStream extends Transform {}
+
+export = DataStream;

package/packages/mailx-send/mailsend/node_modules/@types/nodemailer/lib/smtp-connection/http-proxy-client.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+
+import { Socket } from "net";
+import { TLSSocket } from "tls";
+
+/**
+ * Establishes proxied connection to destinationPort
+ */
+declare function httpProxyClient(
+    proxyUrl: string,
+    destinationPort: number,
+    destinationHost: string,
+    callback: (err: Error | null, socket: TLSSocket | Socket) => void,
+): void;
+
+export = httpProxyClient;

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

@@ -0,0 +1,270 @@
+/// <reference types="node" />
+
+import { EventEmitter } from "events";
+import * as net from "net";
+import { Readable } from "stream";
+import * as tls from "tls";
+
+import * as shared from "../shared";
+
+import MimeNode = require("../mime-node");
+import XOAuth2 = require("../xoauth2");
+
+type ms = number;
+
+declare namespace SMTPConnection {
+    interface Credentials {
+        /** the username */
+        user: string;
+        /** then password */
+        pass: string;
+    }
+
+    type OAuth2 = XOAuth2.Options;
+
+    interface AuthenticationTypeCustom extends Credentials {
+        /** indicates the authetication type, defaults to ‘login’, other option is ‘oauth2’ or ‘custom’ */
+        type: "custom" | "Custom" | "CUSTOM";
+        method: string;
+    }
+
+    interface AuthenticationTypeLogin extends Credentials {
+        /** indicates the authetication type, defaults to ‘login’, other option is ‘oauth2’ or ‘custom’ */
+        type?: "login" | "Login" | "LOGIN" | undefined;
+    }
+
+    interface AuthenticationTypeOAuth2 extends OAuth2 {
+        /** indicates the authetication type, defaults to ‘login’, other option is ‘oauth2’ or ‘custom’ */
+        type?: "oauth2" | "OAuth2" | "OAUTH2" | undefined;
+    }
+
+    type AuthenticationType = AuthenticationTypeCustom | AuthenticationTypeLogin | AuthenticationTypeOAuth2;
+
+    interface AuthenticationCredentials {
+        /** normal authentication object */
+        credentials: Credentials;
+    }
+
+    interface AuthenticationOAuth2 {
+        /**  if set then forces smtp-connection to use XOAuth2 for authentication */
+        oauth2: OAuth2;
+    }
+
+    interface CustomAuthenticationResponse {
+        command: string;
+        response: string;
+        status: number;
+        text: string;
+        code?: number | undefined;
+    }
+
+    interface CustomAuthenticationContext {
+        auth: AuthenticationCredentials;
+        authMethod: string;
+        extensions: string[];
+        authMethods: string[];
+        maxAllowedSize: number | false;
+        sendCommand(cmd: string): Promise<CustomAuthenticationResponse>;
+        sendCommand(cmd: string, done: (err: Error | null, data: CustomAuthenticationResponse) => void): void;
+        resolve(): unknown;
+        reject(err: Error | string): unknown;
+    }
+
+    interface CustomAuthenticationHandlers {
+        [method: string]: (ctx: CustomAuthenticationContext) => Promise<boolean> | unknown;
+    }
+
+    type DSNOption = "NEVER" | "SUCCESS" | "FAILURE" | "DELAY";
+
+    interface DSNOptions {
+        /** return either the full message ‘FULL’ or only headers ‘HDRS’ */
+        ret?: "Full" | "HDRS" | undefined;
+        /** sender’s ‘envelope identifier’ for tracking */
+        envid?: string | undefined;
+        /** when to send a DSN. Multiple options are OK - array or comma delimited. NEVER must appear by itself. */
+        notify?: DSNOption | DSNOption[] | undefined;
+        /** original recipient */
+        orcpt?: string | undefined;
+    }
+
+    interface Envelope {
+        /** includes an address object or is set to false */
+        from: string | false;
+        /** the recipient address or an array of addresses */
+        to: string | string[];
+        /** an optional value of the predicted size of the message in bytes. This value is used if the server supports the SIZE extension (RFC1870) */
+        size?: number | undefined;
+        /** if true then inform the server that this message might contain bytes outside 7bit ascii range */
+        use8BitMime?: boolean | undefined;
+        /** the dsn options */
+        dsn?: DSNOptions | undefined;
+    }
+
+    interface SMTPError extends NodeJS.ErrnoException {
+        /** string code identifying the error, for example ‘EAUTH’ is returned when authentication */
+        code?: string | undefined;
+        /** the last response received from the server (if the error is caused by an error response from the server) */
+        response?: string | undefined;
+        /** the numeric response code of the response string (if available) */
+        responseCode?: number | undefined;
+        /** command which provoked an error */
+        command?: string | undefined;
+    }
+
+    interface SentMessageInfo {
+        /** an array of accepted recipient addresses. Normally this array should contain at least one address except when in LMTP mode. In this case the message itself might have succeeded but all recipients were rejected after sending the message. */
+        accepted: string[];
+        /** an array of rejected recipient addresses. This array includes both the addresses that were rejected before sending the message and addresses rejected after sending it if using LMTP */
+        rejected: string[];
+        /** if some recipients were rejected then this property holds an array of error objects for the rejected recipients */
+        rejectedErrors?: SMTPError[] | undefined;
+        /** the last response received from the server */
+        response: string;
+        /** how long was envelope prepared */
+        envelopeTime: number;
+        /** how long was send stream prepared */
+        messageTime: number;
+        /** how many bytes were streamed */
+        messageSize: number;
+    }
+
+    interface Options {
+        /** the hostname or IP address to connect to (defaults to ‘localhost’) */
+        host?: string | undefined;
+        /** the port to connect to (defaults to 25 or 465) */
+        port?: number | undefined;
+        /** defines authentication data */
+        auth?: AuthenticationType | undefined;
+        /** defines if the connection should use SSL (if true) or not (if false) */
+        secure?: boolean | undefined;
+        /** indicates that the provided socket has already been upgraded to TLS (if true) */
+        secured?: boolean | undefined;
+        /** turns off STARTTLS support if true */
+        ignoreTLS?: boolean | undefined;
+        /** forces the client to use STARTTLS. Returns an error if upgrading the connection is not possible or fails. */
+        requireTLS?: boolean | undefined;
+        /** tries to use STARTTLS and continues normally if it fails */
+        opportunisticTLS?: boolean | undefined;
+        /** optional hostname of the client, used for identifying to the server */
+        name?: string | undefined;
+        /** the local interface to bind to for network connections */
+        localAddress?: string | undefined;
+        /** how many milliseconds to wait for the connection to establish */
+        connectionTimeout?: ms | undefined;
+        /** how many milliseconds to wait for the greeting after connection is established */
+        greetingTimeout?: ms | undefined;
+        /** how many milliseconds of inactivity to allow */
+        socketTimeout?: ms | undefined;
+        /** how many milliseconds to wait for the DNS requests to be resolved */
+        dnsTimeout?: ms | undefined;
+        /** optional bunyan compatible logger instance. If set to true then logs to console. If value is not set or is false then nothing is logged */
+        logger?: shared.Logger | boolean | undefined;
+        /** if set to true, then logs SMTP traffic without message content */
+        transactionLog?: boolean | undefined;
+        /** if set to true, then logs SMTP traffic and message content, otherwise logs only transaction events */
+        debug?: boolean | undefined;
+        /** defines preferred authentication method, e.g. ‘PLAIN’ */
+        authMethod?: string | undefined;
+        /** defines additional options to be passed to the socket constructor, e.g. {rejectUnauthorized: true} */
+        tls?: tls.ConnectionOptions | undefined;
+        /** initialized socket to use instead of creating a new one */
+        socket?: net.Socket | undefined;
+        /** connected socket to use instead of creating and connecting a new one. If secure option is true, then socket is upgraded from plaintext to ciphertext */
+        connection?: net.Socket | undefined;
+        customAuth?: CustomAuthenticationHandlers | undefined;
+        /** if true, uses LMTP instead of SMTP protocol */
+        lmtp?: boolean | undefined;
+    }
+}
+
+declare class SMTPConnection extends EventEmitter {
+    options: SMTPConnection.Options;
+
+    logger: shared.Logger;
+
+    id: string;
+    stage: "init" | "connected";
+
+    secureConnection: boolean;
+    alreadySecured: boolean;
+
+    port: number;
+    host: string;
+
+    name: string;
+    /** Expose version nr, just for the reference */
+    version: string;
+
+    /** If true, then the user is authenticated */
+    authenticated: boolean;
+    /** If set to true, this instance is no longer active */
+    destroyed: boolean;
+    /** Defines if the current connection is secure or not. If not, STARTTLS can be used if available */
+    secure: boolean;
+
+    lastServerResponse: string | false;
+
+    /** The socket connecting to the server */
+    _socket: net.Socket;
+
+    constructor(options?: SMTPConnection.Options);
+
+    /** Creates a connection to a SMTP server and sets up connection listener */
+    connect(callback: (err?: SMTPConnection.SMTPError) => void): void;
+    /** Sends QUIT */
+    quit(): void;
+    /** Closes the connection to the server */
+    close(): void;
+    /** Authenticate user */
+    login(
+        auth:
+            | SMTPConnection.AuthenticationCredentials
+            | SMTPConnection.AuthenticationOAuth2
+            | SMTPConnection.Credentials,
+        callback: (err?: SMTPConnection.SMTPError) => void,
+    ): void;
+    /** Sends a message */
+    send(
+        envelope: SMTPConnection.Envelope,
+        message: string | Buffer | Readable,
+        callback: (err: SMTPConnection.SMTPError | null, info: SMTPConnection.SentMessageInfo) => void,
+    ): void;
+    /** Resets connection state */
+    reset(callback: (err?: SMTPConnection.SMTPError) => void): void;
+
+    addListener(event: "connect" | "end", listener: () => void): this;
+    addListener(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+
+    emit(event: "connect" | "end"): boolean;
+    emit(event: "error", error: Error): boolean;
+
+    listenerCount(event: "connect" | "end" | "error"): number;
+
+    listeners(event: "connect" | "end"): Array<() => void>;
+    listeners(event: "error"): Array<(err: SMTPConnection.SMTPError) => void>;
+
+    off(event: "connect" | "end", listener: () => void): this;
+    off(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+
+    on(event: "connect" | "end", listener: () => void): this;
+    on(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+
+    once(event: "connect" | "end", listener: () => void): this;
+    once(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+
+    prependListener(event: "connect" | "end", listener: () => void): this;
+    prependListener(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+
+    prependOnceListener(event: "connect" | "end", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+
+    rawListeners(event: "connect" | "end"): Array<() => void>;
+    rawListeners(event: "error"): Array<(err: SMTPConnection.SMTPError) => void>;
+
+    removeAllListener(event: "connect" | "end" | "error"): this;
+
+    removeListener(event: "connect" | "end", listener: () => void): this;
+    removeListener(event: "error", listener: (err: SMTPConnection.SMTPError) => void): this;
+}
+
+export = SMTPConnection;

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

@@ -0,0 +1,93 @@
+/// <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");
+import SMTPConnection = require("../smtp-connection");
+
+declare namespace SMTPPool {
+    interface MailOptions extends Mail.Options {
+        auth?: SMTPConnection.AuthenticationType | undefined;
+        dsn?: SMTPConnection.DSNOptions | undefined;
+    }
+
+    interface Options extends MailOptions, TransportOptions, SMTPConnection.Options {
+        /** set to true to use pooled connections (defaults to false) instead of creating a new connection for every email */
+        pool: true;
+        service?: string | undefined;
+        getSocket?(options: Options, callback: (err: Error | null, socketOptions: any) => void): void; // TODO http.ClientRequest?
+        url?: string | undefined;
+        /** the count of maximum simultaneous connections to make against the SMTP server (defaults to 5) */
+        maxConnections?: number | undefined;
+        /** limits the message count to be sent using a single connection (defaults to 100). After maxMessages is reached the connection is dropped and a new one is created for the following messages */
+        maxMessages?: number | undefined;
+        /** defines the time measuring period in milliseconds (defaults to 1000, ie. to 1 second) for rate limiting */
+        rateDelta?: number | undefined;
+        /** limits the message count to be sent in rateDelta time. Once rateLimit is reached, sending is paused until the end of the measuring period. This limit is shared between connections, so if one connection uses up the limit, then other connections are paused as well. If rateLimit is not set then sending rate is not limited */
+        rateLimit?: number | undefined;
+    }
+
+    interface SentMessageInfo extends SMTPConnection.SentMessageInfo {
+        /** includes the envelope object for the message */
+        envelope: MimeNode.Envelope;
+        /** most transports should return the final Message-Id value used with this property */
+        messageId: string;
+    }
+}
+
+/**
+ * Creates a SMTP pool transport object for Nodemailer
+ */
+declare class SMTPPool extends EventEmitter implements Transport<SMTPPool.SentMessageInfo> {
+    options: SMTPPool.Options;
+
+    mailer: Mail<SMTPPool.SentMessageInfo>;
+    logger: shared.Logger;
+
+    name: string;
+    version: string;
+
+    idling: boolean;
+
+    constructor(options?: SMTPPool.Options | string);
+
+    /** Placeholder function for creating proxy sockets. This method immediatelly returns without a socket */
+    getSocket(options: SMTPPool.Options, callback: (err: Error | null, socketOptions: any) => void): void;
+
+    /** Sends an e-mail using the selected settings */
+    send(
+        mail: MailMessage<SMTPPool.SentMessageInfo>,
+        callback: (err: Error | null, info: SMTPPool.SentMessageInfo) => void,
+    ): void;
+
+    /** 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>;
+
+    addListener(event: "idle", listener: () => void): this;
+
+    emit(event: "idle"): boolean;
+
+    on(event: "idle", listener: () => void): this;
+
+    once(event: "idle", listener: () => void): this;
+
+    prependListener(event: "idle", listener: () => void): this;
+
+    prependOnceListener(event: "idle", listener: () => void): this;
+
+    listeners(event: "idle"): Array<() => void>;
+}
+
+export = SMTPPool;