import * as vue from 'vue';
import { Plugin, VNode as VNode$1, PropType, CSSProperties, VNodeArrayChildren, VueElement, VNodeProps, AllowedComponentProps, Component } from 'vue';
import { Config } from 'tailwindcss';
import { BundledLanguage, SpecialLanguage, BundledTheme, ThemeRegistrationAny } from 'shiki';

declare const VueEmailPlugin: Plugin;

declare const _default$j: vue.DefineComponent<{}, () => VNode$1<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<{}>>, {}, {}>;

type TailwindConfig = Pick<Config, 'important' | 'prefix' | 'separator' | 'safelist' | 'blocklist' | 'presets' | 'future' | 'experimental' | 'darkMode' | 'theme' | 'corePlugins' | 'plugins'>;

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

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

type DeepRequired<T> = Required<{
    [P in keyof T]: DeepRequired<T[P]>;
}>;

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;
}
type ExtractComponentProps<TComponent> = TComponent extends new () => {
    $props: infer P;
} ? Omit<P, keyof VNodeProps | keyof AllowedComponentProps> : never;
interface VNode {
    type: string;
    props: {
        style?: Record<string, any>;
        children?: string | VNode | VNode[];
        [prop: string]: any;
    };
}
declare function useRender<T extends Component>(component: T, props?: ExtractComponentProps<T>, 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 ExtractComponentProps, type Options, type Patterns, type StylesType, type VNode, VueEmailPlugin, cleanup, deepmerge, htmlToText, useRender };