vue-email/dist/index.d.mts

💌 Write email templates with Vue

import * as vue from 'vue';
import { Plugin, VNode, PropType, CSSProperties, Component } from 'vue';
import { TailwindConfig } from '@vue-email/tailwind';
import { BundledLanguage, SpecialLanguage, BundledTheme, ThemeRegistrationAny } from 'shiki';

declare const VueEmailPlugin: Plugin;

declare const _default$j: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$i: vue.DefineComponent<{
    px: {
        type: PropType<string | number>;
    };
    py: {
        type: PropType<string | number>;
        default: number;
    };
    target: {
        type: StringConstructor;
        default: string;
    };
    href: StringConstructor;
    style: ObjectConstructor;
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    px: {
        type: PropType<string | number>;
    };
    py: {
        type: PropType<string | number>;
        default: number;
    };
    target: {
        type: StringConstructor;
        default: string;
    };
    href: StringConstructor;
    style: ObjectConstructor;
}>>, {
    target: string;
    py: string | number;
}, {}>;

declare const _default$h: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$g: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

type FallbackFont = 'Arial' | 'Helvetica' | 'Verdana' | 'Georgia' | 'Times New Roman' | 'serif' | 'sans-serif' | 'monospace' | 'cursive' | 'fantasy';
type FontFormat = 'woff' | 'woff2' | 'truetype' | 'opentype' | 'embedded-opentype' | 'svg';
type FontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number;
type FontStyle = 'normal' | 'italic' | 'oblique';
declare const _default$f: vue.DefineComponent<{
    fontFamily: {
        type: StringConstructor;
        required: true;
    };
    fallbackFontFamily: {
        type: PropType<FallbackFont | FallbackFont[]>;
        default: string;
    };
    webFont: {
        type: PropType<{
            url: string;
            format: FontFormat;
        }>;
        default: undefined;
    };
    fontStyle: {
        type: PropType<FontStyle>;
        default: string;
    };
    fontWeight: {
        type: PropType<FontWeight>;
        default: number;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    fontFamily: {
        type: StringConstructor;
        required: true;
    };
    fallbackFontFamily: {
        type: PropType<FallbackFont | FallbackFont[]>;
        default: string;
    };
    webFont: {
        type: PropType<{
            url: string;
            format: FontFormat;
        }>;
        default: undefined;
    };
    fontStyle: {
        type: PropType<FontStyle>;
        default: string;
    };
    fontWeight: {
        type: PropType<FontWeight>;
        default: number;
    };
}>>, {
    fontWeight: FontWeight;
    fontStyle: FontStyle;
    fallbackFontFamily: FallbackFont | FallbackFont[];
    webFont: {
        url: string;
        format: FontFormat;
    };
}, {}>;

declare const _default$e: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$d: vue.DefineComponent<{
    as: {
        type: PropType<"h1" | "h2" | "h3" | "h4" | "h5" | "h6">;
        default: string;
    };
    m: {
        type: PropType<string | number>;
        default: undefined;
    };
    mx: {
        type: PropType<string | number>;
        default: undefined;
    };
    my: {
        type: PropType<string | number>;
        default: undefined;
    };
    mt: {
        type: PropType<string | number>;
        default: undefined;
    };
    mr: {
        type: PropType<string | number>;
        default: undefined;
    };
    mb: {
        type: PropType<string | number>;
        default: undefined;
    };
    ml: {
        type: PropType<string | number>;
        default: undefined;
    };
    style: {
        type: PropType<string | CSSProperties>;
        default: undefined;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    as: {
        type: PropType<"h1" | "h2" | "h3" | "h4" | "h5" | "h6">;
        default: string;
    };
    m: {
        type: PropType<string | number>;
        default: undefined;
    };
    mx: {
        type: PropType<string | number>;
        default: undefined;
    };
    my: {
        type: PropType<string | number>;
        default: undefined;
    };
    mt: {
        type: PropType<string | number>;
        default: undefined;
    };
    mr: {
        type: PropType<string | number>;
        default: undefined;
    };
    mb: {
        type: PropType<string | number>;
        default: undefined;
    };
    ml: {
        type: PropType<string | number>;
        default: undefined;
    };
    style: {
        type: PropType<string | CSSProperties>;
        default: undefined;
    };
}>>, {
    style: string | CSSProperties;
    as: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
    m: string | number;
    mx: string | number;
    my: string | number;
    mt: string | number;
    mr: string | number;
    mb: string | number;
    ml: string | number;
}, {}>;

declare const _default$c: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$b: vue.DefineComponent<{
    lang: {
        type: StringConstructor;
        default: string;
    };
    dir: {
        type: PropType<"auto" | "ltr" | "rtl">;
        default: string;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    lang: {
        type: StringConstructor;
        default: string;
    };
    dir: {
        type: PropType<"auto" | "ltr" | "rtl">;
        default: string;
    };
}>>, {
    lang: string;
    dir: "auto" | "ltr" | "rtl";
}, {}>;

declare const _default$a: vue.DefineComponent<{
    src: {
        type: StringConstructor;
        required: true;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    src: {
        type: StringConstructor;
        required: true;
    };
}>>, {}, {}>;

declare const _default$9: vue.DefineComponent<{
    href: {
        type: StringConstructor;
        required: true;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    href: {
        type: StringConstructor;
        required: true;
    };
}>>, {}, {}>;

declare const _default$8: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$7: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$6: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$5: vue.DefineComponent<{
    config: {
        type: PropType<TailwindConfig>;
        required: false;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    config: {
        type: PropType<TailwindConfig>;
        required: false;
    };
}>>, {}, {}>;

declare const _default$4: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

interface StylesType {
    h1?: CSSProperties;
    h2?: CSSProperties;
    h3?: CSSProperties;
    h4?: CSSProperties;
    h5?: CSSProperties;
    h6?: CSSProperties;
    blockQuote?: CSSProperties;
    bold?: CSSProperties;
    italic?: CSSProperties;
    link?: CSSProperties;
    codeBlock?: CSSProperties;
    codeInline?: CSSProperties;
    p?: CSSProperties;
    li?: CSSProperties;
    ul?: CSSProperties;
    ol?: CSSProperties;
    image?: CSSProperties;
    br?: CSSProperties;
    hr?: CSSProperties;
    table?: CSSProperties;
    thead?: CSSProperties;
    tbody?: CSSProperties;
    tr?: CSSProperties;
    th?: CSSProperties;
    td?: CSSProperties;
    strikethrough?: CSSProperties;
}
interface Patterns {
    h1?: RegExp;
    h2?: RegExp;
    h3?: RegExp;
    h4?: RegExp;
    h5?: RegExp;
    h6?: RegExp;
    blockQuote?: RegExp;
    bold?: RegExp;
    italic?: RegExp;
    link?: RegExp;
    codeBlock?: RegExp;
    codeInline?: RegExp;
    p?: RegExp;
    li?: RegExp;
    ul?: RegExp;
    image?: RegExp;
    br?: RegExp;
    hr?: RegExp;
    table?: RegExp;
    strikethrough?: RegExp;
}

interface VueEmailPluginOptions {
    /**
     * The base URL of your website.
     * @default null
     * @example
     * ```ts
     * baseUrl: 'https://example.com'
     * ```
     * @see https://vue-email.net/getting-started/installation#options
     */
    baseUrl?: string | null;
    /**
     * Provide translations for your templates.
     * @see
     */
    i18n?: I18n;
    tailwind?: TailwindConfig;
    [key: string]: any;
}
interface I18n {
    locale?: string;
    defaultLocale: string;
    translations?: Record<string, Record<string, string>>;
}
type DeepRequired<T> = Required<{
    [P in keyof T]: DeepRequired<T[P]>;
}>;
declare module 'vue' {
    interface ComponentCustomProperties {
        $vueEmail: VueEmailPluginOptions;
    }
}

declare const _default$3: vue.DefineComponent<{
    source: {
        type: StringConstructor;
        required: true;
    };
    customStyles: {
        type: () => StylesType;
        default: undefined;
    };
    containerStyles: {
        type: () => CSSProperties;
        default: undefined;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    source: {
        type: StringConstructor;
        required: true;
    };
    customStyles: {
        type: () => StylesType;
        default: undefined;
    };
    containerStyles: {
        type: () => CSSProperties;
        default: undefined;
    };
}>>, {
    customStyles: StylesType;
    containerStyles: CSSProperties;
}, {}>;

declare const _default$2: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;

declare const _default$1: vue.DefineComponent<{
    code: {
        type: StringConstructor;
        required: true;
    };
    lang: {
        type: PropType<BundledLanguage | SpecialLanguage>;
        required: true;
    };
    theme: {
        type: PropType<BundledTheme | ThemeRegistrationAny>;
        required: true;
    };
    class: {
        type: StringConstructor;
        default: string;
    };
    showLineNumbers: {
        type: BooleanConstructor;
        default: boolean;
    };
    lineNumberColor: {
        type: StringConstructor;
        default: string;
    };
    lineHighlightingColor: {
        type: StringConstructor;
        default: string;
    };
    highlightedLines: {
        type: PropType<number[]>;
        default: () => never[];
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    code: {
        type: StringConstructor;
        required: true;
    };
    lang: {
        type: PropType<BundledLanguage | SpecialLanguage>;
        required: true;
    };
    theme: {
        type: PropType<BundledTheme | ThemeRegistrationAny>;
        required: true;
    };
    class: {
        type: StringConstructor;
        default: string;
    };
    showLineNumbers: {
        type: BooleanConstructor;
        default: boolean;
    };
    lineNumberColor: {
        type: StringConstructor;
        default: string;
    };
    lineHighlightingColor: {
        type: StringConstructor;
        default: string;
    };
    highlightedLines: {
        type: PropType<number[]>;
        default: () => never[];
    };
}>>, {
    class: string;
    showLineNumbers: boolean;
    lineNumberColor: string;
    lineHighlightingColor: string;
    highlightedLines: number[];
}, {}>;

declare const _default: vue.DefineComponent<{
    class: {
        type: StringConstructor;
        default: string;
    };
    style: {
        type: PropType<CSSProperties>;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[], unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    class: {
        type: StringConstructor;
        default: string;
    };
    style: {
        type: PropType<CSSProperties>;
    };
}>>, {
    class: string;
}, {}>;

interface Options {
    pretty?: boolean;
}
interface RenderParams {
    props?: any;
    i18n?: I18n;
    components?: Record<string, Component>;
}
/**
 * Convert Vue file into HTML email template
 * @param {Component} component The main component to render
 * @param {RenderParams} [params] The parameters for rendering the component
 * @param {Options} [options] The options to convert the template
 * @returns {Promise<string>} The HTML email template
 * @throws {Error} If vue-i18n package is not installed for i18n usage
 *
 * @example
 * await useRender('component.vue', {
 *   props: {
 *     name: 'John',
 *   },
 *   i18n: {
 *     locale: 'en',
 *     translations: {},
 *   },
 * });
 */
declare function useRender(component: Component, params?: RenderParams | null, options?: Options): Promise<{
    html: string;
    text: string;
}>;

/**
 * Deep merges two objects.
 *
 * @param target
 * @param sources
 */
declare function deepmerge<T extends Record<string, any>>(target: T, ...sources: T[]): T;

declare function cleanup(str: string): string;

declare function htmlToText(html: string): string;

export { type DeepRequired, _default$j as EBody, _default$i as EButton, _default$1 as ECodeBlock, _default as ECodeInline, _default$h as EColumn, _default$g as EContainer, _default$f as EFont, _default$e as EHead, _default$d as EHeading, _default$c as EHr, _default$b as EHtml, _default$a as EImg, _default$9 as ELink, _default$3 as EMarkdown, _default$8 as EPreview, _default$7 as ERow, _default$6 as ESection, _default$2 as EStyle, _default$5 as ETailwind, _default$4 as EText, type I18n, type Options, type Patterns, type RenderParams, type StylesType, VueEmailPlugin, type VueEmailPluginOptions, cleanup, deepmerge, htmlToText, useRender };