@types/nodemailer 6.4.12 → 6.4.13

nodemailer/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for nodemailer (https://github.com/nodema
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nodemailer.
 
 ### Additional Details
- * Last updated: Wed, 18 Oct 2023 05:47:08 GMT
+ * Last updated: Wed, 18 Oct 2023 18:04:03 GMT
  * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
 
 # Credits

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;

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);
+}

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;

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;

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;

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;

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;

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);
+}

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;

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;

nodemailer/lib/well-known/index.d.ts

@@ -0,0 +1,6 @@
+import SMTPConnection = require("../smtp-connection");
+
+/** Resolves SMTP config for given key. Key can be a name (like 'Gmail'), alias (like 'Google Mail') or an email address (like 'test@googlemail.com'). */
+declare function wellKnown(key: string): SMTPConnection.Options | false;
+
+export = wellKnown;

nodemailer/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/nodemailer",
-    "version": "6.4.12",
+    "version": "6.4.13",
     "description": "TypeScript definitions for nodemailer",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nodemailer",
     "license": "MIT",
@@ -32,6 +32,6 @@
     "dependencies": {
         "@types/node": "*"
     },
-    "typesPublisherContentHash": "cb9902e0d20b8e9ee2baf78ad776fd0dd8e3a696db509fd479a5101c3db88d7e",
+    "typesPublisherContentHash": "5f29fc512be89e02dfed5dc1c7aa88ce996bf942f6057978e6c8e4fc71bb29d1",
     "typeScriptVersion": "4.5"
 }