@vandenberghinc/volt 1.2.6 → 1.2.7

package/backend/dist/esm/backend/src/plugins/mail/mail.js

@@ -0,0 +1,396 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+// imports.
+import * as nodemailer from "nodemailer";
+import * as vlib from "@vandenberghinc/vlib";
+// imports.
+import * as UI from "./ui.js";
+import { ExternalError } from "../../errors/index.js";
+import { Status } from "../../status.js";
+/**
+ * The mail class, used to send emails via SMTP.
+ *
+ * @note This class is initialized under server property `mail` when the server is started with the `smtp` option.
+ *
+ * @nav Plugins
+ * @docs
+ */
+export class Mail {
+    /** the smpt mailer. */
+    smtp;
+    /** the smtp sender address. */
+    sender; // is defined when `smtp` is defined.
+    /** the default mail style. */
+    style;
+    /** construct a new server instance. */
+    constructor({ smtp, style = {
+        font: '"Helvetica", sans-serif',
+        title_fg: "#121B23",
+        subtitle_fg: "#121B23",
+        text_fg: "#1F2F3D",
+        button_fg: "#FFFFFF",
+        footer_fg: "#686B80",
+        bg: "#EEEEEE",
+        widget_bg: "#FFFFFF",
+        widget_border: "#E6E6E6",
+        button_bg: "#1F2F3D",
+        divider_bg: "#706780",
+    }, }) {
+        this.style = style;
+        this.sender = smtp.sender;
+        this.smtp = nodemailer.createTransport({
+            ...smtp,
+            ...(smtp.override ?? {}),
+        });
+    }
+    // ---------------------------------------------------------
+    // public methods.
+    /**
+     * send one or multiple mails.
+     *
+     * @note ensure SPF/DKIM are configured when sending attachments.
+     * @returns resolves/rejects when the mail has been sent.
+     *
+     * @param sender optional sender override.
+     * @param recipients recipient addresses.
+     * @param subject subject line.
+     * @param body html string or `UI.MailElement`.
+     * @param attachments supported inputs (paths, backend model, REST model, or nodemailer attachment).
+     * @param max_attachments limit on number of attachments; -1 disables.
+     * @param max_attachment_size max size (bytes) per attachment; -1 disables.
+     * @param max_attachments_size max total size (bytes) across attachments; -1 disables.
+     *
+     * @docs
+     */
+    async send({ sender = undefined, recipients = [], subject = undefined, body = "", attachments = [], max_attachments = -1, max_attachment_size = -1, max_attachments_size = -1, allow_untrusted_urls = false, }) {
+        if (!this.smtp) {
+            throw new Error("smtp is not enabled, define the required server argument on initialization to enable smtp.");
+        }
+        if (body instanceof UI.MailElement) {
+            body = body.html();
+        }
+        if ((sender == null) && (this.sender != null)) {
+            sender = this.sender;
+        }
+        if (!recipients || recipients.length === 0) {
+            throw new Error("the mail has no recipients.");
+        }
+        if (sender == null) {
+            throw new Error('parameter "sender" should be a defined value of type "string" or "array".');
+        }
+        const format_address = (address) => {
+            if (Array.isArray(address))
+                return `${address[0]} <${address[1]}>`;
+            return address;
+        };
+        const to = [];
+        recipients.forEach((address) => to.push(format_address(address)));
+        const { nodemailer_attachments } = this.normalize_and_validate_attachments(attachments, {
+            max_attachments,
+            max_attachment_size,
+            max_attachments_size,
+            allow_untrusted_urls,
+        });
+        try {
+            await this.smtp.sendMail({
+                from: format_address(sender),
+                to,
+                subject,
+                html: body,
+                attachments: nodemailer_attachments,
+            });
+        }
+        catch (error) {
+            throw new Error(error?.message ?? String(error));
+        }
+    }
+    // ---------------------------------------------------------
+    // attachment handling (normalization + validation).
+    // ---------------------------------------------------------
+    /**
+     * convert a single generic attachment input into a nodemailer attachment.
+     */
+    build_attachment(it, opts = {}) {
+        // filesystem path inputs (string | vlib.Path).
+        if (typeof it === "string" || (it instanceof vlib.Path)) {
+            const path = (it instanceof vlib.Path) ? it : new vlib.Path(it);
+            const file_name = path.full_name();
+            const buf = path.load_sync();
+            return {
+                filename: file_name,
+                path: path.str(),
+                content: buf,
+            };
+        }
+        // rest payload: either { content + encoding } or { url }.
+        if (Mail.Attachment.RestAPI.is(it)) {
+            const { name, mime_type, charset, compressed } = it;
+            // a) content + encoding -> to content Buffer/string for nodemailer.
+            if (typeof it.content === "string") {
+                const enc = (it.encoding ?? "base64").toLowerCase();
+                let payload = it.content;
+                if (enc === "base64") {
+                    payload = Buffer.from(this.normalize_base64(it.content), "base64");
+                }
+                else if (enc === "hex" || enc === "latin1" || enc === "binary" || enc === "utf8" || enc === "utf-8") {
+                    const node_enc = enc === "utf-8" ? "utf8" : enc;
+                    payload = Buffer.from(it.content, node_enc);
+                }
+                else {
+                    throw new ExternalError({
+                        status: Status.bad_request,
+                        type: "InvalidAttachment",
+                        message: `Unsupported encoding '${it.encoding}'.`,
+                    });
+                }
+                return {
+                    filename: name ?? "attachment",
+                    content: payload,
+                    contentType: mime_type,
+                    headers: this.build_content_headers({ charset, compressed }),
+                };
+            }
+            // b) url (http/https/data) -> nodemailer streams from path.
+            if (it.url) {
+                if (!opts.allow_untrusted_urls && this.is_http_url(it.url)) {
+                    throw new ExternalError({
+                        status: Status.bad_request,
+                        type: "UntrustedUrlBlocked",
+                        message: "http/https attachment urls are blocked by default. set 'allow_untrusted_urls' to true to allow.",
+                    });
+                }
+                return {
+                    filename: name ?? "attachment",
+                    path: it.url,
+                    contentType: mime_type,
+                    headers: this.build_content_headers({ charset, compressed }),
+                };
+            }
+            throw new ExternalError({
+                status: Status.bad_request,
+                type: "InvalidAttachment",
+                message: "Attachment payload missing { content, encoding } or { url }.",
+            });
+        }
+        // backend model: { bytes } or { content + encoding }.
+        if (Mail.Attachment.is(it)) {
+            const { name, mime_type, charset, compressed } = it;
+            if (it.bytes) {
+                const buf = Buffer.isBuffer(it.bytes) ? it.bytes : Buffer.from(it.bytes);
+                return {
+                    filename: name ?? "attachment",
+                    content: buf,
+                    contentType: mime_type,
+                    headers: this.build_content_headers({ charset, compressed }),
+                };
+            }
+            if (typeof it.content === "string") {
+                const enc = (it.encoding ?? "base64").toLowerCase();
+                let payload;
+                if (enc === "base64") {
+                    payload = Buffer.from(this.normalize_base64(it.content), "base64");
+                }
+                else if (enc === "hex" || enc === "latin1" || enc === "binary" || enc === "utf8" || enc === "utf-8") {
+                    const node_enc = enc === "utf-8" ? "utf8" : enc;
+                    payload = Buffer.from(it.content, node_enc);
+                }
+                else {
+                    throw new ExternalError({
+                        status: Status.bad_request,
+                        type: "InvalidAttachment",
+                        message: `Unsupported encoding '${it.encoding}'.`,
+                    });
+                }
+                return {
+                    filename: name ?? "attachment",
+                    content: payload,
+                    contentType: mime_type,
+                    headers: this.build_content_headers({ charset, compressed }),
+                };
+            }
+            // passthrough for pre-built nodemailer attachments.
+            if (Mail.Attachment.Native.is(it)) {
+                return { ...it };
+            }
+            throw new ExternalError({
+                status: Status.bad_request,
+                type: "InvalidAttachment",
+                message: "Attachment missing content: provide bytes or { content, encoding }.",
+            });
+        }
+        throw new ExternalError({
+            status: Status.bad_request,
+            type: "InvalidAttachment",
+            message: "Unsupported attachment input.",
+        });
+    }
+    /** returns true when url starts with http:// or https:// */
+    is_http_url(u) {
+        const s = typeof u === "string" ? u : String(u);
+        return /^https?:\/\//i.test(s);
+    }
+    /**
+     * normalize and validate a mixed attachment input into nodemailer attachments.
+     * @param input mixed list of attachments.
+     * @param limits size/count validation limits.
+     * @returns normalized nodemailer attachments.
+     * @throws {ExternalError} when limits are exceeded.
+     */
+    normalize_and_validate_attachments(input, limits = {}) {
+        const items = input ?? [];
+        const nm_attachments = [];
+        for (const it of items) {
+            const built = this.build_attachment(it, limits);
+            nm_attachments.push(built);
+        }
+        const { max_attachments, max_attachment_size, max_attachments_size, } = limits;
+        if (typeof max_attachments === "number" && max_attachments !== -1 && nm_attachments.length > max_attachments) {
+            throw new ExternalError({
+                status: Status.bad_request,
+                type: "TooManyAttachments",
+                message: `Too many attachments. max is ${max_attachments}.`,
+            });
+        }
+        if (typeof max_attachment_size === "number" && max_attachment_size !== -1) {
+            for (const a of nm_attachments) {
+                const size = this.measure_attachment_bytes(a);
+                if (size > max_attachment_size) {
+                    throw new ExternalError({
+                        status: Status.bad_request,
+                        type: "AttachmentTooLarge",
+                        message: `Attachment '${a.filename ?? "unnamed"}' exceeds max size of ${max_attachment_size} bytes.`,
+                    });
+                }
+            }
+        }
+        if (typeof max_attachments_size === "number" && max_attachments_size !== -1) {
+            let total = 0;
+            for (const a of nm_attachments)
+                total += this.measure_attachment_bytes(a);
+            if (total > max_attachments_size) {
+                throw new ExternalError({
+                    status: Status.bad_request,
+                    type: "AttachmentsTooLarge",
+                    message: `Total attachments size ${total} bytes exceeds max of ${max_attachments_size} bytes.`,
+                });
+            }
+        }
+        return { nodemailer_attachments: nm_attachments };
+    }
+    /**
+     * measure the on-wire payload size (approx) of a nodemailer attachment content.
+     * note: if `encoding: "base64"` is set, we decode to compute raw byte size.
+     */
+    measure_attachment_bytes(a) {
+        if (a.content) {
+            if (Buffer.isBuffer(a.content))
+                return a.content.length;
+            if (typeof a.content === "string") {
+                if (a.encoding === "base64") {
+                    try {
+                        return Buffer.from(a.content, "base64").length;
+                    }
+                    catch {
+                        return a.content.length;
+                    }
+                }
+                return Buffer.byteLength(a.content);
+            }
+            // stream size unknown beforehand.
+            return 0;
+        }
+        if (a.path) {
+            try {
+                const p = new vlib.Path(String(a.path));
+                return p.size ?? 0;
+            }
+            catch {
+                return 0;
+            }
+        }
+        return 0;
+    }
+    /**
+     * normalize a base64 or url-safe base64 string to standard base64 (no decoding).
+     * trims whitespace and converts url-safe chars.
+     */
+    normalize_base64(b64) {
+        let t = String(b64).trim().replace(/-/g, "+").replace(/_/g, "/");
+        const mod = t.length % 4;
+        if (mod)
+            t += "=".repeat(4 - mod);
+        return t;
+    }
+    /**
+     * optional content headers for charset/compression hints.
+     * email clients usually ignore custom headers; added for traceability.
+     */
+    build_content_headers({ charset, compressed }) {
+        const headers = {};
+        if (charset)
+            headers["X-Attachment-Charset"] = charset;
+        if (typeof compressed === "boolean")
+            headers["X-Attachment-Compressed"] = compressed ? "gzip" : "none";
+        return Object.keys(headers).length ? headers : undefined;
+    }
+}
+/** nested types for the mail module. */
+(function (Mail) {
+    /** Nested attachment types. */
+    let Attachment;
+    (function (Attachment) {
+        Attachment.encodings = new Set(["base64", "hex", "utf8", "utf-8", "binary", "latin1"]);
+        /** Type guard. */
+        function is(a) {
+            return a && typeof a === "object"
+                && ("name" in a)
+                && (!("path" in a) || typeof a.path === "string")
+                && (!("mime_type" in a) || typeof a.mime_type === "string")
+                && (!("charset" in a) || typeof a.charset === "string")
+                && (!("bytes" in a) || (Buffer.isBuffer(a.bytes) || a.bytes instanceof Uint8Array))
+                && (!("content" in a) || typeof a.content === "string")
+                && (!("encoding" in a) || Attachment.encodings.has(a.encoding))
+                && (!("compressed" in a) || typeof a.compressed === "boolean");
+        }
+        Attachment.is = is;
+        let RestAPI;
+        (function (RestAPI) {
+            /** Type guard. */
+            function is(a) {
+                return a && typeof a === "object"
+                    && ("name" in a)
+                    && (!("path" in a) || typeof a.path === "string")
+                    && (!("mime_type" in a) || typeof a.mime_type === "string")
+                    && (!("charset" in a) || typeof a.charset === "string")
+                    && (!("compressed" in a) || typeof a.compressed === "boolean")
+                    && (!("content" in a) || typeof a.content === "string")
+                    && (!("encoding" in a) || Attachment.encodings.has(a.encoding))
+                    && (!("url" in a) || typeof a.url === "string");
+            }
+            RestAPI.is = is;
+            /** Schema validation. */
+            RestAPI.Schema = {
+                name: { type: "string", required: true },
+                path: { type: "string", required: false },
+                mime_type: { type: "string", required: false },
+                charset: { type: "string", required: false },
+                compressed: { type: "boolean", required: false },
+                content: { type: "string", required: false },
+                encoding: { type: "string", enum: Array.from(Attachment.encodings), required: false },
+                url: { type: "string", required: false },
+            };
+        })(RestAPI = Attachment.RestAPI || (Attachment.RestAPI = {}));
+        /** Nested native types. */
+        let Native;
+        (function (Native) {
+            /** Simple type guard. */
+            function is(a) {
+                return a && typeof a === "object"
+                    && ("content" in a || "path" in a || "filename" in a);
+            }
+            Native.is = is;
+        })(Native = Attachment.Native || (Attachment.Native = {}));
+    })(Attachment = Mail.Attachment || (Mail.Attachment = {}));
+})(Mail || (Mail = {}));

package/backend/dist/esm/backend/src/plugins/mail/ui.d.ts

@@ -0,0 +1,297 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh. All rights reserved
+ */
+type none = undefined | null;
+export declare class Element {
+    type: string;
+    element_type: string;
+    tag: string;
+    _style: Record<string, string>;
+    _attrs: Record<string, any>;
+    classes: string[];
+    _inner_html: string | null;
+    children: any[];
+    _lang?: string;
+    _charset?: string;
+    _viewport?: string;
+    _title?: string;
+    _links?: (string | Record<string, string>)[];
+    _disabled?: boolean;
+    constructor({ type, tag, default_style, default_attributes, default_events, }: {
+        type?: string;
+        tag?: string;
+        default_style?: Record<string, string> | null;
+        default_attributes?: Record<string, string> | null;
+        default_events?: Record<string, (event: Event) => any> | null;
+    });
+    pad_numeric(value: string | number, padding?: string): string;
+    html(): string;
+    links(links: (string | Record<string, string>)[]): this;
+    /**
+     * Get or set the background color of the element.
+     * @param value The color value to set.
+     * @returns The current value when getting, or the element instance when setting.
+     * @funcs 3
+     */
+    background_color(): string | undefined;
+    background_color(value: string): this;
+    /**
+     * Get or set the display property.
+     * @funcs 3
+     */
+    display(): string | undefined;
+    display(value: string): this;
+    /**
+     * Get or set the background image.
+     * @funcs 3
+     */
+    background_image(): string | undefined;
+    background_image(value: string): this;
+    background_repeat(): string | undefined;
+    background_repeat(value: string): this;
+    border_top(): string | undefined;
+    border_top(value: string): this;
+    border_bottom(): string | undefined;
+    border_bottom(value: string): this;
+    border_right(): string | undefined;
+    border_right(value: string): this;
+    border_left(): string | undefined;
+    border_left(value: string): this;
+    border_color(): string | undefined;
+    border_color(value: string): this;
+    border_style(): string | undefined;
+    border_style(value: string): this;
+    cursor(): string | undefined;
+    cursor(value: string): this;
+    justify_items(): string | undefined;
+    justify_items(value: string): this;
+    letter_spacing(): string | undefined;
+    letter_spacing(value: string): this;
+    line_height(): string | undefined;
+    line_height(value: string): this;
+    outline(): string | undefined;
+    outline(value: string): this;
+    overflow(): string | undefined;
+    overflow(value: string): this;
+    overflow_x(): string | undefined;
+    overflow_x(value: string): this;
+    overflow_y(): string | undefined;
+    overflow_y(value: string): this;
+    text_align(): string | undefined;
+    text_align(value: string): this;
+    text_align_last(): string | undefined;
+    text_align_last(value: string): this;
+    text_decoration(): string | undefined;
+    text_decoration(value: string): this;
+    text_decoration_color(): string | undefined;
+    text_decoration_color(value: string): this;
+    text_wrap(): string | undefined;
+    text_wrap(value: string): this;
+    white_space(): string | undefined;
+    white_space(value: string): this;
+    overflow_wrap(): string | undefined;
+    overflow_wrap(value: string): this;
+    word_wrap(): string | undefined;
+    word_wrap(value: string): this;
+    box_shadow(): string | undefined;
+    box_shadow(value: string): this;
+    drop_shadow(): string | undefined;
+    drop_shadow(value: string): this;
+    font_size(): string | undefined;
+    font_size(value: string | number): this;
+    font(): string | undefined;
+    font(value: string | number): this;
+    font_family(): string | undefined;
+    font_family(value: string | number): this;
+    font_style(): string | undefined;
+    font_style(value: string | number): this;
+    font_weight(): string | undefined;
+    font_weight(value: string | number): this;
+    width(): string | undefined;
+    width(value: string | number): this;
+    min_width(): string | undefined;
+    min_width(value: string | number): this;
+    max_width(): string | undefined;
+    max_width(value: string | number): this;
+    height(): string | undefined;
+    height(value: string | number): this;
+    min_height(): string | undefined;
+    min_height(value: string | number): this;
+    max_height(): string | undefined;
+    max_height(value: string | number): this;
+    margin_top(): string | undefined;
+    margin_top(value: string | number): this;
+    margin_bottom(): string | undefined;
+    margin_bottom(value: string | number): this;
+    margin_right(): string | undefined;
+    margin_right(value: string | number): this;
+    margin_left(): string | undefined;
+    margin_left(value: string | number): this;
+    padding_top(): string | undefined;
+    padding_top(value: string | number): this;
+    padding_bottom(): string | undefined;
+    padding_bottom(value: string | number): this;
+    padding_right(): string | undefined;
+    padding_right(value: string | number): this;
+    padding_left(): string | undefined;
+    padding_left(value: string | number): this;
+    border_width(): string | undefined;
+    border_width(value: string | number): this;
+    align_items(): string | undefined;
+    align_items(value: string): this;
+    align_content(): string | undefined;
+    align_content(value: string): this;
+    background_size(): string | undefined;
+    background_size(value: string): this;
+    box_sizing(): string | undefined;
+    box_sizing(value: string): this;
+    flex(): string | undefined;
+    flex(value: string): this;
+    flex_grow(): string | undefined;
+    flex_grow(value: string): this;
+    flex_shrink(): string | undefined;
+    flex_shrink(value: string): this;
+    justify_content(): string | undefined;
+    justify_content(value: string): this;
+    mask(): string | undefined;
+    mask(value: string): this;
+    user_select(): string | undefined;
+    user_select(value: string): this;
+    styles(styles: Record<string, string>): this;
+    attrs(attrs: Record<string, string>): this;
+    events(events: Record<string, (event: Event) => void>): this;
+    add_class(name: string): this;
+    remove_class(name: string): this;
+    append(...children: (Element | any[] | Function | none)[]): this;
+    inner_html(): string | null;
+    inner_html(value: string): this;
+    center(): this;
+    padding(): string;
+    padding(value: string | number): this;
+    padding(top_bottom: string | number, left_right: string | number): this;
+    padding(top: string | number, right: string | number, bottom: string | number, left: string | number): this;
+    margin(): string | undefined;
+    margin(value: string | number): this;
+    margin(value: none | string | number, value2: none | string | number): this;
+    margin(value: none | string | number, value2: none | string | number, value3: none | string | number, value4: none | string | number): this;
+    fixed_width(): string | undefined;
+    fixed_width(value: string | number): this;
+    fixed_height(): string | undefined;
+    fixed_height(value: string | number): this;
+    frame(width: string | number | undefined, height: string | number | undefined): this;
+    min_frame(width: string | number | undefined, height: string | number | undefined): this;
+    max_frame(width: string | number | undefined, height: string | number | undefined): this;
+    fixed_frame(width: string | number | undefined, height: string | number | undefined): this;
+    color(): string | undefined;
+    color(value: string): this;
+    border(): string | undefined;
+    border(a: string): this;
+    border(a: string | number, b: string | number): this;
+    border(a: string | number, b: string | number, c: string | number): this;
+    border_radius(): string | undefined;
+    border_radius(value: string | number): this;
+    background(): string | undefined;
+    background(value: string): this;
+    ellipsis_overflow(): boolean | undefined;
+    ellipsis_overflow(to: boolean): this;
+    on_click(): ((e: this, t: Event) => void) | undefined;
+    on_click(callback: (e: this, t: Event) => void): this;
+    lang(): string | undefined;
+    lang(value: string): this;
+    charset(): string | undefined;
+    charset(value: string): this;
+    viewport(): string | undefined;
+    viewport(value: string): this;
+    title(): string | undefined;
+    title(value: string): this;
+}
+export declare class TitleElement extends Element {
+    constructor(text?: string);
+}
+export declare const Title: <Extensions extends object = {}>(text?: string | undefined) => TitleElement & Extensions;
+export declare const NullTitle: <Extensions extends object = {}>() => TitleElement & Extensions;
+export declare class SubtitleElement extends Element {
+    constructor(text?: string);
+}
+export declare const Subtitle: <Extensions extends object = {}>(text?: string | undefined) => SubtitleElement & Extensions;
+export declare const NullSubtitle: <Extensions extends object = {}>() => SubtitleElement & Extensions;
+export declare class TextElement extends Element {
+    constructor(text?: string);
+}
+export declare const Text: <Extensions extends object = {}>(text?: string | undefined) => TextElement & Extensions;
+export declare const NullText: <Extensions extends object = {}>() => TextElement & Extensions;
+export declare class ImageElement extends Element {
+    constructor(src?: string);
+}
+export declare const Image: <Extensions extends object = {}>(src?: string | undefined) => ImageElement & Extensions;
+export declare const NullImageElement: <Extensions extends object = {}>() => ImageElement & Extensions;
+export declare class ImageMaskElement extends Element {
+    mask_child: VStackElement;
+    _src?: string;
+    constructor(src?: string);
+    mask_color(): string | undefined;
+    mask_color(value: string): this;
+    src(): string | undefined;
+    src(value: string): this;
+    mask(): string | undefined;
+    mask(value: string): this;
+}
+export declare const ImageMask: <Extensions extends object = {}>(src?: string | undefined) => ImageMaskElement & Extensions;
+export declare const NullImageMaskElement: <Extensions extends object = {}>() => ImageMaskElement & Extensions;
+export declare class VStackElement extends Element {
+    constructor(...children: any[]);
+}
+export declare const VStack: <Extensions extends object = {}>(...args: any[]) => VStackElement & Extensions;
+export declare const NullVStackElement: <Extensions extends object = {}>() => VStackElement & Extensions;
+export declare class DividerElement extends Element {
+    constructor(text?: string);
+}
+export declare const Divider: <Extensions extends object = {}>(text?: string | undefined) => DividerElement & Extensions;
+export declare const NullDividerElement: <Extensions extends object = {}>() => DividerElement & Extensions;
+export declare class TableDataElement extends Element {
+    constructor(...children: any[]);
+    center(): this;
+    center_vertical(): this;
+    leading_vertical(): this;
+    trailing_vertical(): this;
+}
+export declare const TableData: <Extensions extends object = {}>(...args: any[]) => TableDataElement & Extensions;
+export declare const NullTableDataElement: <Extensions extends object = {}>() => TableDataElement & Extensions;
+export declare class TableRowElement extends Element {
+    private current_cell;
+    private _wrap;
+    constructor(...children: any[]);
+    append(...children: any[]): this;
+    wrap(): boolean;
+    wrap(value: boolean): this;
+    center(): this;
+    center_vertical(): this;
+    leading_vertical(): this;
+    trailing_vertical(): this;
+}
+export declare const TableRow: <Extensions extends object = {}>(...args: any[]) => TableRowElement & Extensions;
+export declare const NullTableRowElement: <Extensions extends object = {}>() => TableRowElement & Extensions;
+export declare class TableElement extends Element {
+    current_cell?: TableDataElement;
+    current_row: TableRowElement;
+    constructor(...children: any[]);
+    row(...children: any[]): this;
+    append(...children: any[]): this;
+}
+export declare const Table: <Extensions extends object = {}>(...args: any[]) => TableElement & Extensions;
+export declare const NullTableElement: <Extensions extends object = {}>() => TableElement & Extensions;
+export declare class CSSElement extends Element {
+    constructor(style?: string);
+}
+export declare const CSS: <Extensions extends object = {}>(style?: string | undefined) => CSSElement & Extensions;
+export declare const NullCSSElement: <Extensions extends object = {}>() => CSSElement & Extensions;
+export declare class MailElement extends Element {
+    private _subject?;
+    constructor(...children: any[]);
+    subject(): string | undefined;
+    subject(subj: string): this;
+}
+export declare const Mail: <Extensions extends object = {}>(...args: any[]) => MailElement & Extensions;
+export declare const NullMailElement: <Extensions extends object = {}>() => MailElement & Extensions;
+export {};