@vandenberghinc/volt 1.2.6 → 1.2.7

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

@@ -0,0 +1,381 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  Mail: () => Mail
+});
+module.exports = __toCommonJS(stdin_exports);
+var nodemailer = __toESM(require("nodemailer"));
+var vlib = __toESM(require("@vandenberghinc/vlib"));
+var UI = __toESM(require("./ui.js"));
+var import_errors = require("../../errors/index.js");
+var import_status = require("../../status.js");
+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 = void 0, recipients = [], subject = void 0, 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 = {}) {
+    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
+      };
+    }
+    if (Mail.Attachment.RestAPI.is(it)) {
+      const { name, mime_type, charset, compressed } = it;
+      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 import_errors.ExternalError({
+            status: import_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 })
+        };
+      }
+      if (it.url) {
+        if (!opts.allow_untrusted_urls && this.is_http_url(it.url)) {
+          throw new import_errors.ExternalError({
+            status: import_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 import_errors.ExternalError({
+        status: import_status.Status.bad_request,
+        type: "InvalidAttachment",
+        message: "Attachment payload missing { content, encoding } or { url }."
+      });
+    }
+    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 import_errors.ExternalError({
+            status: import_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 })
+        };
+      }
+      if (Mail.Attachment.Native.is(it)) {
+        return { ...it };
+      }
+      throw new import_errors.ExternalError({
+        status: import_status.Status.bad_request,
+        type: "InvalidAttachment",
+        message: "Attachment missing content: provide bytes or { content, encoding }."
+      });
+    }
+    throw new import_errors.ExternalError({
+      status: import_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 import_errors.ExternalError({
+        status: import_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 import_errors.ExternalError({
+            status: import_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 import_errors.ExternalError({
+          status: import_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);
+      }
+      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 : void 0;
+  }
+}
+(function(Mail2) {
+  let Attachment;
+  (function(Attachment2) {
+    Attachment2.encodings = /* @__PURE__ */ new Set(["base64", "hex", "utf8", "utf-8", "binary", "latin1"]);
+    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) || Attachment2.encodings.has(a.encoding)) && (!("compressed" in a) || typeof a.compressed === "boolean");
+    }
+    Attachment2.is = is;
+    let RestAPI;
+    (function(RestAPI2) {
+      function is2(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) || Attachment2.encodings.has(a.encoding)) && (!("url" in a) || typeof a.url === "string");
+      }
+      RestAPI2.is = is2;
+      RestAPI2.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(Attachment2.encodings), required: false },
+        url: { type: "string", required: false }
+      };
+    })(RestAPI = Attachment2.RestAPI || (Attachment2.RestAPI = {}));
+    let Native;
+    (function(Native2) {
+      function is2(a) {
+        return a && typeof a === "object" && ("content" in a || "path" in a || "filename" in a);
+      }
+      Native2.is = is2;
+    })(Native = Attachment2.Native || (Attachment2.Native = {}));
+  })(Attachment = Mail2.Attachment || (Mail2.Attachment = {}));
+})(Mail || (Mail = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Mail
+});

package/backend/dist/cjs/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 {};