import * as vue from 'vue';
import { Plugin } from 'vue';
import { BaseNode, ParseOptions, MarkdownIt } from 'stream-markdown-parser';
export * from 'stream-markdown-parser';
export { KATEX_COMMANDS, MathOptions, normalizeStandaloneBackslashT, setDefaultMathOptions } from 'stream-markdown-parser';

type AdmonitionKind = 'note' | 'info' | 'tip' | 'warning' | 'danger' | 'caution' | 'error';
interface AdmonitionNode {
    type: 'admonition';
    kind: AdmonitionKind;
    title?: string;
    children: {
        type: string;
        raw: string;
    }[];
    raw: string;
    collapsible?: boolean;
    open?: boolean;
}
type __VLS_Props$l = {
    node: AdmonitionNode;
    indexKey: number | string;
    isDark?: boolean;
    typewriter?: boolean;
};
declare const _default$u: vue.DefineComponent<__VLS_Props$l, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$l> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;

interface NodeChild$9 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
interface BlockquoteNode {
    type: 'blockquote';
    children: NodeChild$9[];
    raw: string;
    cite?: string;
}
type __VLS_Props$k = {
    node: BlockquoteNode;
    indexKey: string | number;
    typewriter?: boolean;
};
declare const _default$t: vue.DefineComponent<__VLS_Props$k, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (text: string) => any;
}, string, vue.PublicProps, Readonly<__VLS_Props$k> & Readonly<{
    onCopy?: (text: string) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLQuoteElement>;

type __VLS_Props$j = {
    node: {
        type: 'checkbox';
        checked: boolean;
        raw: string;
    };
};
declare const _default$s: vue.DefineComponent<__VLS_Props$j, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$j> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;

interface CodeBlockNodeProps {
    node: {
        type: 'code_block';
        language: string;
        code: string;
        raw: string;
        diff?: boolean;
        originalCode?: string;
        updatedCode?: string;
    };
    isDark?: boolean;
    loading?: boolean;
    stream?: boolean;
    darkTheme?: any;
    lightTheme?: any;
    isShowPreview?: boolean;
    monacoOptions?: {
        [k: string]: any;
    };
    enableFontSizeControl?: boolean;
    minWidth?: string | number;
    maxWidth?: string | number;
    themes?: any[];
    showHeader?: boolean;
    showCopyButton?: boolean;
    showExpandButton?: boolean;
    showPreviewButton?: boolean;
    showFontSizeButtons?: boolean;
    customId?: string;
}
interface ImageNodeProps {
    node: {
        type: 'image';
        src: string;
        alt: string;
        title: string | null;
        raw: string;
        loading?: boolean;
    };
    fallbackSrc?: string;
    showCaption?: boolean;
    lazy?: boolean;
    svgMinHeight?: string;
    usePlaceholder?: boolean;
}
interface LinkNodeProps {
    node: {
        type: 'link';
        href: string;
        title: string | null;
        text: string;
        children: {
            type: string;
            raw: string;
        }[];
        raw: string;
        loading?: boolean;
    };
    indexKey: number | string;
    customId?: string;
    showTooltip?: boolean;
    color?: string;
    underlineHeight?: number;
    underlineBottom?: number | string;
    animationDuration?: number;
    animationOpacity?: number;
    animationTiming?: string;
    animationIteration?: string | number;
}
interface PreCodeNodeProps {
    node: any;
}
interface MermaidBlockNodeProps {
    node: any;
    maxHeight?: string | null;
    loading?: boolean;
    isDark?: boolean;
    workerTimeoutMs?: number;
    parseTimeoutMs?: number;
    renderTimeoutMs?: number;
    fullRenderTimeoutMs?: number;
}
interface MathBlockNodeProps {
    node: {
        type: 'math_block';
        content: string;
        raw: string;
        loading?: boolean;
    };
}
interface MathInlineNodeProps {
    node: {
        type: 'math_inline';
        content: string;
        raw: string;
        loading?: boolean;
    };
}

declare function __VLS_template$4(): {
    attrs: Partial<{}>;
    slots: {
        'header-left'?(_: {}): any;
        'header-right'?(_: {}): any;
        loading?(_: {
            loading: boolean;
            stream: boolean;
        }): any;
    };
    refs: {
        container: HTMLDivElement;
        codeEditor: HTMLDivElement;
    };
    rootEl: any;
};
type __VLS_TemplateResult$4 = ReturnType<typeof __VLS_template$4>;
declare const __VLS_component$4: vue.DefineComponent<CodeBlockNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
    previewCode: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<CodeBlockNodeProps> & Readonly<{
    onCopy?: (...args: any[]) => any;
    onPreviewCode?: (...args: any[]) => any;
}>, {
    loading: boolean;
    stream: boolean;
    darkTheme: any;
    lightTheme: any;
    isShowPreview: boolean;
    enableFontSizeControl: boolean;
    minWidth: string | number;
    maxWidth: string | number;
    showHeader: boolean;
    showCopyButton: boolean;
    showExpandButton: boolean;
    showPreviewButton: boolean;
    showFontSizeButtons: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
    container: HTMLDivElement;
    codeEditor: HTMLDivElement;
}, any>;
declare const _default$r: __VLS_WithTemplateSlots$4<typeof __VLS_component$4, __VLS_TemplateResult$4["slots"]>;

type __VLS_WithTemplateSlots$4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

interface DefinitionItemNode {
    type: 'definition_item';
    term: {
        type: string;
        raw: string;
    }[];
    definition: {
        type: string;
        raw: string;
    }[];
    raw: string;
}
interface DefinitionListNode {
    type: 'definition_list';
    items: DefinitionItemNode[];
    raw: string;
}
type __VLS_Props$i = {
    node: DefinitionListNode;
    indexKey: string | number;
    typewriter?: boolean;
};
declare const _default$q: vue.DefineComponent<__VLS_Props$i, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$i> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDListElement>;

type __VLS_Props$h = {
    node: {
        type: 'emoji';
        name: string;
        markup: string;
        raw: string;
    };
};
declare const _default$p: vue.DefineComponent<__VLS_Props$h, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$h> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;

interface FootnoteNode {
    type: 'footnote';
    id: string;
    children: {
        type: string;
        raw: string;
    }[];
    raw: string;
}
type __VLS_Props$g = {
    node: FootnoteNode;
    indexKey: string | number;
    typewriter?: boolean;
};
declare const _default$o: vue.DefineComponent<__VLS_Props$g, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$g> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;

interface FootnoteReferenceNode {
    type: 'footnote_reference';
    id: string;
    raw: string;
}
type __VLS_Props$f = {
    node: FootnoteReferenceNode;
};
declare const _default$n: vue.DefineComponent<__VLS_Props$f, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$f> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;

interface HardBreakNode {
    type: 'hardbreak';
    raw: string;
}
type __VLS_Props$e = {
    node: HardBreakNode;
};
declare const _default$m: vue.DefineComponent<__VLS_Props$e, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$e> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLBRElement>;

declare const _HeadingNode: any;

interface NodeChild$8 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$d = {
    node: {
        type: 'highlight';
        children: NodeChild$8[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
};
declare const _default$l: vue.DefineComponent<__VLS_Props$d, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$d> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;

declare function __VLS_template$3(): {
    attrs: Partial<{}>;
    slots: {
        placeholder?(_: {
            node: {
                type: "image";
                src: string;
                alt: string;
                title: string | null;
                raw: string;
                loading?: boolean;
            };
            displaySrc: string;
            imageLoaded: boolean;
            hasError: boolean;
            fallbackSrc: string;
            lazy: boolean;
            isSvg: boolean;
        }): any;
        error?(_: {
            node: {
                type: "image";
                src: string;
                alt: string;
                title: string | null;
                raw: string;
                loading?: boolean;
            };
            displaySrc: string;
            imageLoaded: boolean;
            hasError: true;
            fallbackSrc: string;
            lazy: boolean;
            isSvg: boolean;
        }): any;
    };
    refs: {
        figureRef: HTMLElement;
    };
    rootEl: HTMLElement;
};
type __VLS_TemplateResult$3 = ReturnType<typeof __VLS_template$3>;
declare const __VLS_component$3: vue.DefineComponent<ImageNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {} & {
    click: (payload: [Event, string]) => any;
    error: (src: string) => any;
    load: (src: string) => any;
}, string, vue.PublicProps, Readonly<ImageNodeProps> & Readonly<{
    onClick?: (payload: [Event, string]) => any;
    onError?: (src: string) => any;
    onLoad?: (src: string) => any;
}>, {
    fallbackSrc: string;
    showCaption: boolean;
    lazy: boolean;
    svgMinHeight: string;
    usePlaceholder: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
    figureRef: HTMLElement;
}, HTMLElement>;
declare const _default$k: __VLS_WithTemplateSlots$3<typeof __VLS_component$3, __VLS_TemplateResult$3["slots"]>;

type __VLS_WithTemplateSlots$3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

type __VLS_Props$c = {
    node: {
        type: 'inline_code';
        code: string;
        raw: string;
    };
};
declare const _default$j: vue.DefineComponent<__VLS_Props$c, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$c> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;

interface NodeChild$7 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$b = {
    node: {
        type: 'insert';
        children: NodeChild$7[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
};
declare const _default$i: vue.DefineComponent<__VLS_Props$b, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$b> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLModElement>;

declare const _default$h: vue.DefineComponent<LinkNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<LinkNodeProps> & Readonly<{}>, {
    showTooltip: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;

interface NodeChild$6 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
interface ListItem$1 {
    type: 'list_item';
    children: NodeChild$6[];
    raw: string;
}
type __VLS_Props$a = {
    item: ListItem$1;
    indexKey?: number | string;
    value?: number;
    /** Forwarded flag to enable/disable non-code node enter transition */
    typewriter?: boolean;
};
declare const _default$g: vue.DefineComponent<__VLS_Props$a, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (text: string) => any;
}, string, vue.PublicProps, Readonly<__VLS_Props$a> & Readonly<{
    onCopy?: (text: string) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLLIElement>;

interface NodeChild$5 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
interface ListItem {
    type: 'list_item';
    children: NodeChild$5[];
    raw: string;
}
type __VLS_Props$9 = {
    node: {
        type: 'list';
        ordered: boolean;
        start?: number;
        items: ListItem[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
    typewriter?: boolean;
};
declare const _default$f: vue.DefineComponent<__VLS_Props$9, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$9> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;

type __VLS_Props$8 = {
    node: {
        type: 'code_block';
        language: string;
        code: string;
        raw: string;
        diff?: boolean;
        originalCode?: string;
        updatedCode?: string;
    };
    loading?: boolean;
    /**
     * If true, update and render code content as it streams in.
     * If false, keep a lightweight loading state and create the editor only when loading becomes false.
     */
    stream?: boolean;
    darkTheme?: string;
    lightTheme?: string;
    isDark?: boolean;
    isShowPreview?: boolean;
    enableFontSizeControl?: boolean;
    /** Minimum width for the code block container (px or CSS unit string) */
    minWidth?: string | number;
    /** Maximum width for the code block container (px or CSS unit string) */
    maxWidth?: string | number;
    themes?: string[];
    /** Header visibility and controls */
    showHeader?: boolean;
    showCopyButton?: boolean;
    showExpandButton?: boolean;
    showPreviewButton?: boolean;
    showFontSizeButtons?: boolean;
};
declare function __VLS_template$2(): {
    attrs: Partial<{}>;
    slots: {
        'header-left'?(_: {}): any;
        'header-right'?(_: {}): any;
        loading?(_: {
            loading: boolean;
            stream: boolean;
        }): any;
    };
    refs: {
        codeBlockContent: HTMLDivElement;
    };
    rootEl: any;
};
type __VLS_TemplateResult$2 = ReturnType<typeof __VLS_template$2>;
declare const __VLS_component$2: vue.DefineComponent<__VLS_Props$8, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
    previewCode: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$8> & Readonly<{
    onCopy?: (...args: any[]) => any;
    onPreviewCode?: (...args: any[]) => any;
}>, {
    loading: boolean;
    stream: boolean;
    darkTheme: string;
    lightTheme: string;
    isShowPreview: boolean;
    enableFontSizeControl: boolean;
    minWidth: string | number;
    maxWidth: string | number;
    showHeader: boolean;
    showCopyButton: boolean;
    showExpandButton: boolean;
    showPreviewButton: boolean;
    showFontSizeButtons: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
    codeBlockContent: HTMLDivElement;
}, any>;
declare const _default$e: __VLS_WithTemplateSlots$2<typeof __VLS_component$2, __VLS_TemplateResult$2["slots"]>;

type __VLS_WithTemplateSlots$2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const _default$d: vue.DefineComponent<MathBlockNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<MathBlockNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
    containerEl: HTMLDivElement;
    mathBlockElement: HTMLDivElement;
}, HTMLDivElement>;

declare function __VLS_template$1(): {
    attrs: Partial<{}>;
    slots: {
        loading?(_: {
            isLoading: true;
        }): any;
    };
    refs: {
        containerEl: HTMLSpanElement;
        mathElement: HTMLSpanElement;
    };
    rootEl: HTMLSpanElement;
};
type __VLS_TemplateResult$1 = ReturnType<typeof __VLS_template$1>;
declare const __VLS_component$1: vue.DefineComponent<MathInlineNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
    containerEl: HTMLSpanElement;
    mathElement: HTMLSpanElement;
}, HTMLSpanElement>;
declare const _default$c: __VLS_WithTemplateSlots$1<typeof __VLS_component$1, __VLS_TemplateResult$1["slots"]>;

type __VLS_WithTemplateSlots$1<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const _default$b: vue.DefineComponent<MermaidBlockNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<MermaidBlockNodeProps> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {
    loading: boolean;
    maxHeight: string | null;
    workerTimeoutMs: number;
    parseTimeoutMs: number;
    renderTimeoutMs: number;
    fullRenderTimeoutMs: number;
}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
    modeContainerRef: HTMLDivElement;
    mermaidContainer: HTMLDivElement;
    mermaidWrapper: HTMLDivElement;
    mermaidContent: HTMLDivElement;
    modalContent: HTMLDivElement;
}, HTMLDivElement>;

interface NodeRendererProps {
    content?: string;
    nodes?: BaseNode[];
    /** Options forwarded to parseMarkdownToStructure when content is provided */
    parseOptions?: ParseOptions;
    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
    /** Enable priority rendering for visible viewport area */
    viewportPriority?: boolean;
    /**
     * Whether code_block renders should stream updates.
     * When false, code blocks stay in a loading state and render once when final content is ready.
     * Default: true
     */
    codeBlockStream?: boolean;
    codeBlockDarkTheme?: any;
    codeBlockLightTheme?: any;
    codeBlockMonacoOptions?: Record<string, any>;
    /** If true, render all `code_block` nodes as plain <pre><code> blocks instead of the full CodeBlockNode */
    renderCodeBlocksAsPre?: boolean;
    /** Minimum width forwarded to CodeBlockNode (px or CSS unit) */
    codeBlockMinWidth?: string | number;
    /** Maximum width forwarded to CodeBlockNode (px or CSS unit) */
    codeBlockMaxWidth?: string | number;
    /** Arbitrary props to forward to every CodeBlockNode */
    codeBlockProps?: Record<string, any>;
    themes?: string[];
    isDark?: boolean;
    customId?: string;
    indexKey?: number | string;
    /** Enable/disable the non-code-node enter transition (typewriter). Default: true */
    typewriter?: boolean;
    /** Enable incremental/batched rendering of nodes to avoid large single flush costs. Default: true */
    batchRendering?: boolean;
    /** How many nodes to render immediately before batching kicks in. Default: 40 */
    initialRenderBatchSize?: number;
    /** How many additional nodes to render per batch tick. Default: 80 */
    renderBatchSize?: number;
    /** Extra delay (ms) before each batch after rAF; helps yield to input. Default: 16 */
    renderBatchDelay?: number;
    /** Target budget (ms) for each batch before we shrink subsequent batch sizes. Default: 6 */
    renderBatchBudgetMs?: number;
    /** Timeout (ms) for requestIdleCallback slices. Default: 120 */
    renderBatchIdleTimeoutMs?: number;
    /** Defer rendering nodes until they are near the viewport */
    deferNodesUntilVisible?: boolean;
    /** Maximum number of fully rendered nodes kept in DOM. Default: 320 */
    maxLiveNodes?: number;
    /** Number of nodes to keep before/after focus. Default: 60 */
    liveNodeBuffer?: number;
}
declare const _default$a: vue.DefineComponent<NodeRendererProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
    handleArtifactClick: (...args: any[]) => void;
    click: (...args: any[]) => void;
    mouseover: (...args: any[]) => void;
    mouseout: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<NodeRendererProps> & Readonly<{
    onCopy?: (...args: any[]) => any;
    onHandleArtifactClick?: (...args: any[]) => any;
    onClick?: (...args: any[]) => any;
    onMouseover?: (...args: any[]) => any;
    onMouseout?: (...args: any[]) => any;
}>, {
    typewriter: boolean;
    codeBlockStream: boolean;
    batchRendering: boolean;
    initialRenderBatchSize: number;
    renderBatchSize: number;
    renderBatchDelay: number;
    renderBatchBudgetMs: number;
    renderBatchIdleTimeoutMs: number;
    deferNodesUntilVisible: boolean;
    maxLiveNodes: number;
    liveNodeBuffer: number;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {
    containerRef: HTMLDivElement;
}, HTMLDivElement>;

interface NodeChild$4 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$7 = {
    node: {
        type: 'paragraph';
        children: NodeChild$4[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
};
declare const _default$9: vue.DefineComponent<__VLS_Props$7, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$7> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLParagraphElement>;

declare const _default$8: vue.DefineComponent<PreCodeNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<PreCodeNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLPreElement>;

type __VLS_Props$6 = {
    node: {
        type: 'reference';
        id: string;
        raw: string;
    };
    messageId?: string;
    threadId?: string;
};
declare const _default$7: vue.DefineComponent<__VLS_Props$6, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    click: (...args: any[]) => void;
    mouseEnter: (...args: any[]) => void;
    mouseLeave: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$6> & Readonly<{
    onClick?: (...args: any[]) => any;
    onMouseEnter?: (...args: any[]) => any;
    onMouseLeave?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;

interface NodeChild$3 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$5 = {
    node: {
        type: 'strikethrough';
        children: NodeChild$3[];
        raw: string;
    };
    customId?: string;
    indexKey?: string | number;
};
declare const _default$6: vue.DefineComponent<__VLS_Props$5, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$5> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLModElement>;

interface NodeChild$2 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$4 = {
    node: {
        type: 'strong';
        children: NodeChild$2[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
};
declare const _default$5: vue.DefineComponent<__VLS_Props$4, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$4> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;

interface NodeChild$1 {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$3 = {
    node: {
        type: 'subscript';
        children: NodeChild$1[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
};
declare const _default$4: vue.DefineComponent<__VLS_Props$3, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$3> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;

interface NodeChild {
    type: string;
    raw: string;
    [key: string]: unknown;
}
type __VLS_Props$2 = {
    node: {
        type: 'superscript';
        children: NodeChild[];
        raw: string;
    };
    customId?: string;
    indexKey?: number | string;
};
declare const _default$3: vue.DefineComponent<__VLS_Props$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$2> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;

interface TableCellNode {
    type: 'table_cell';
    header: boolean;
    children: {
        type: string;
        raw: string;
    }[];
    raw: string;
    align?: 'left' | 'right' | 'center';
}
interface TableRowNode {
    type: 'table_row';
    cells: TableCellNode[];
    raw: string;
}
interface TableNode {
    type: 'table';
    header: TableRowNode;
    rows: TableRowNode[];
    raw: string;
    loading: boolean;
}
type __VLS_Props$1 = {
    node: TableNode;
    indexKey: string | number;
    isDark?: boolean;
    typewriter?: boolean;
};
declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        loading?(_: {
            isLoading: true;
        }): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};
type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
declare const __VLS_component: vue.DefineComponent<__VLS_Props$1, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props$1> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
declare const _default$2: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

type __VLS_Props = {
    node: {
        type: 'text';
        content: string;
        raw: string;
        center?: boolean;
    };
};
declare const _default$1: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    copy: (...args: any[]) => void;
}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
    onCopy?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;

declare const _default: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, HTMLHRElement>;

declare const defaultMap: Record<string, string>;
/**
 * Replace the entire default translation map.
 * Consumers can call this to provide their own fallback translations (e.g. Chinese).
 */
declare function setDefaultI18nMap(map: Record<keyof typeof defaultMap, string>): void;

interface CustomComponents {
    text: any;
    paragraph: any;
    heading: any;
    code_block: any;
    list: any;
    blockquote: any;
    table: any;
    definition_list: any;
    footnote: any;
    footnote_reference: any;
    admonition: any;
    hardbreak: any;
    link: any;
    image: any;
    thematic_break: any;
    math_inline: any;
    math_block: any;
    strong: any;
    emphasis: any;
    strikethrough: any;
    highlight: any;
    insert: any;
    subscript: any;
    superscript: any;
    emoji: any;
    checkbox: any;
    inline_code: any;
    reference: any;
    mermaid: any;
    [key: string]: any;
}

declare function setCustomComponents(id: string, mapping: Partial<CustomComponents>): void;
declare function setCustomComponents(mapping: Partial<CustomComponents>): void;
/**
 * Retrieve custom components for a given scope id.
 * If no id is provided, returns the legacy/global mapping (if any).
 */
declare function getCustomNodeComponents(customId?: string): Partial<CustomComponents>;
/**
 * Remove a scoped custom components mapping.
 * Use this to clean up mappings for dynamic or temporary renderers.
 */
declare function removeCustomComponents(id: string): void;
/**
 * Clear the legacy/global custom components mapping.
 * Use this when you want to remove the single-argument mapping set by
 * `setCustomComponents(mapping)`.
 */
declare function clearGlobalCustomComponents(): void;

declare function getUseMonaco(): Promise<any>;

type LanguageIconResolver = (lang: string) => string | undefined | null;
declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
declare function getLanguageIcon(lang: string): string;
declare const languageMap: Record<string, string>;

/**
 * Allow user to inject a Worker instance, e.g. from Vite ?worker import.
 */
declare function setKaTeXWorker(w: Worker): void;
/**
 * Remove the current worker instance (for cleanup or SSR).
 */
declare function clearKaTeXWorker(): void;
declare function setKaTeXWorkerDebug(enabled: boolean): void;
declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
/**
 * Utilities for clients to inspect/adjust worker load behavior
 */
declare function getKaTeXWorkerLoad(): {
    inFlight: number;
    max: number;
};
declare function setKaTeXWorkerMaxConcurrency(n: number): void;
declare const WORKER_BUSY_CODE = "WORKER_BUSY";
declare function isKaTeXWorkerBusy(): boolean;
declare function waitForKaTeXWorkerSlot(timeout?: number, signal?: AbortSignal): Promise<void>;
interface BackpressureOptions {
    timeout?: number;
    waitTimeout?: number;
    backoffMs?: number;
    maxRetries?: number;
    signal?: AbortSignal;
}
declare const defaultBackpressure: {
    timeout: number;
    waitTimeout: number;
    backoffMs: number;
    maxRetries: number;
};
declare function setKaTeXBackpressureDefaults(opts: Partial<typeof defaultBackpressure>): void;
declare function getKaTeXBackpressureDefaults(): {
    timeout: number;
    waitTimeout: number;
    backoffMs: number;
    maxRetries: number;
};
/**
 * Convenience wrapper: when worker reports busy, wait for a slot and retry.
 * Does not implement fallback-to-main-thread; leave that to the caller.
 */
declare function renderKaTeXWithBackpressure(content: string, displayMode?: boolean, opts?: BackpressureOptions): Promise<string>;

type Theme = 'light' | 'dark';
declare function setMermaidWorkerClientDebug(enabled: boolean): void;
declare function setMermaidWorkerMaxConcurrency(n: number): void;
declare function getMermaidWorkerLoad(): {
    inFlight: number;
    max: number;
};
declare const MERMAID_WORKER_BUSY_CODE = "WORKER_BUSY";
/**
 * Allow user to inject a Worker instance, e.g. from Vite ?worker import.
 */
declare function setMermaidWorker(w: Worker): void;
/**
 * Remove the current worker instance (for cleanup or SSR).
 */
declare function clearMermaidWorker(): void;
declare function canParseOffthread(code: string, theme: Theme, timeout?: number): Promise<boolean>;
declare function findPrefixOffthread(code: string, theme: Theme, timeout?: number): Promise<string>;
declare function terminateWorker(): void;

declare const VueRendererMarkdown: Plugin;

export { _default$u as AdmonitionNode, BackpressureOptions, _default$t as BlockquoteNode, _default$s as CheckboxNode, _default$r as CodeBlockNode, _default$q as DefinitionListNode, _default$p as EmojiNode, _default$o as FootnoteNode, _default$n as FootnoteReferenceNode, _default$m as HardBreakNode, _HeadingNode as HeadingNode, _default$l as HighlightNode, _default$k as ImageNode, _default$j as InlineCodeNode, _default$i as InsertNode, LanguageIconResolver, _default$h as LinkNode, _default$g as ListItemNode, _default$f as ListNode, MERMAID_WORKER_BUSY_CODE, _default$e as MarkdownCodeBlockNode, _default$a as MarkdownRender, _default$d as MathBlockNode, _default$c as MathInlineNode, _default$b as MermaidBlockNode, _default$9 as ParagraphNode, _default$8 as PreCodeNode, _default$7 as ReferenceNode, _default$6 as StrikethroughNode, _default$5 as StrongNode, _default$4 as SubscriptNode, _default$3 as SuperscriptNode, _default$2 as TableNode, _default$1 as TextNode, _default as ThematicBreakNode, VueRendererMarkdown, WORKER_BUSY_CODE, canParseOffthread, clearGlobalCustomComponents, clearKaTeXWorker, clearMermaidWorker, _default$a as default, findPrefixOffthread, getCustomNodeComponents, getKaTeXBackpressureDefaults, getKaTeXWorkerLoad, getLanguageIcon, getMermaidWorkerLoad, getUseMonaco, isKaTeXWorkerBusy, languageMap, removeCustomComponents, renderKaTeXInWorker, renderKaTeXWithBackpressure, setCustomComponents, setDefaultI18nMap, setKaTeXBackpressureDefaults, setKaTeXCache, setKaTeXWorker, setKaTeXWorkerDebug, setKaTeXWorkerMaxConcurrency, setLanguageIconResolver, setMermaidWorker, setMermaidWorkerClientDebug, setMermaidWorkerMaxConcurrency, terminateWorker, waitForKaTeXWorkerSlot };