import React, { ComponentType, PropsWithChildren, CSSProperties } from 'react';
import * as stream_markdown_parser from 'stream-markdown-parser';
import { CodeBlockNode as CodeBlockNode$1, BaseNode, ParseOptions, MarkdownIt, HtmlPolicy, ParsedNode } from 'stream-markdown-parser';
import { SmoothMarkdownStreamOptions } from 'markstream-core';

type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
interface TooltipProps {
    visible: boolean;
    anchorEl: HTMLElement | null;
    content: string;
    placement?: TooltipPlacement;
    offset?: number;
    originX?: number | null;
    originY?: number | null;
    id?: string | null;
    isDark?: boolean | null;
}

interface NodeComponentProps<TNode = unknown> {
    node: TNode;
    ctx?: RenderContext;
    renderNode?: RenderNodeFn;
    indexKey?: React.Key;
    customId?: string;
    isDark?: boolean;
    typewriter?: boolean;
    /** Enable/disable fade animations. Default: true */
    fade?: boolean;
    children?: React.ReactNode;
}

type CustomComponentDisplayMode = 'inline' | 'block';
type MarkstreamCustomComponent<P = never> = ComponentType<P> & {
    markstreamDisplay?: CustomComponentDisplayMode;
};
type CustomComponentMap = Record<string, MarkstreamCustomComponent>;
type StreamingComponent<TNode = any> = ComponentType<NodeComponentProps<TNode>>;
type StreamingComponentMap = Record<string, StreamingComponent<any>>;
type HtmlComponent<P extends object = any> = ComponentType<PropsWithChildren<P>>;
type HtmlComponentMap = Record<string, HtmlComponent<any>>;
type IsAny<T> = 0 extends (1 & T) ? true : false;
type ComponentProps<T> = T extends ComponentType<infer P> ? P : T extends (props: infer P) => any ? P : never;
type StreamingComponentDefinitions<T extends Record<string, any>> = {
    [K in keyof T]: ComponentProps<T[K]> extends infer P ? IsAny<P> extends true ? T[K] : P extends NodeComponentProps<any> ? NodeComponentProps<any> extends P ? T[K] : never : never : never;
};
type ParserComponentOnlyProp = Exclude<keyof NodeComponentProps<any>, 'children' | 'node'>;
type HtmlComponentDefinitions<T extends Record<string, any>> = {
    [K in keyof T]: ComponentProps<T[K]> extends infer P ? IsAny<P> extends true ? T[K] : Extract<keyof P, ParserComponentOnlyProp> extends never ? T[K] : never : never;
};
declare function setCustomComponents(id: string, mapping: CustomComponentMap): void;
declare function setCustomComponents(mapping: CustomComponentMap): void;
declare function getCustomNodeComponents(customId?: string): CustomComponentMap;
declare function removeCustomComponents(id: string): void;
declare function clearGlobalCustomComponents(): void;
declare function defineStreamingComponents<const T extends Record<string, ComponentType<any>>>(components: T & StreamingComponentDefinitions<T>): T & StreamingComponentDefinitions<T>;
declare function defineHtmlComponents<const T extends Record<string, ComponentType<any>>>(components: T & HtmlComponentDefinitions<T>): T & HtmlComponentDefinitions<T>;

interface CodeBlockMonacoThemeObject {
    name: string;
    base?: string;
    inherit?: boolean;
    colors?: Record<string, string>;
    rules?: Array<Record<string, unknown>>;
    [key: string]: unknown;
}
type CodeBlockMonacoTheme = string | CodeBlockMonacoThemeObject;
type CodeBlockMonacoLanguage = string | ((...args: unknown[]) => unknown);
interface CommonCodeBlockProps {
    showHeader?: boolean;
    showCopyButton?: boolean;
    showExpandButton?: boolean;
}
interface ShikiCodeBlockProps extends CommonCodeBlockProps {
    themes?: readonly string[];
    /**
     * Shiki language preload request forwarded to stream-markdown's registerHighlight().
     * This is not a rendering allow-list; already available Shiki languages may still highlight.
     */
    langs?: readonly string[];
}
interface CodeBlockDiffHideUnchangedRegionsOptions {
    enabled?: boolean;
    contextLineCount?: number;
    minimumLineCount?: number;
    revealLineCount?: number;
}
type CodeBlockDiffHideUnchangedRegions = boolean | CodeBlockDiffHideUnchangedRegionsOptions;
type CodeBlockDiffLineStyle = 'background' | 'bar';
type CodeBlockDiffAppearance = 'auto' | 'light' | 'dark';
type CodeBlockDiffUnchangedRegionStyle = 'line-info' | 'line-info-basic' | 'metadata' | 'simple';
type CodeBlockDiffHunkActionKind = 'revert' | 'stage';
type CodeBlockDiffHunkSide = 'upper' | 'lower';
interface CodeBlockDiffHunkActionContext {
    action: CodeBlockDiffHunkActionKind;
    side: CodeBlockDiffHunkSide;
    lineChange: unknown;
    originalModel: unknown;
    modifiedModel: unknown;
}
interface CodeBlockMonacoOptions {
    MAX_HEIGHT?: number | string;
    fontSize?: number;
    lineHeight?: number;
    fontFamily?: string;
    tabSize?: number;
    readOnly?: boolean;
    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded' | string;
    wrappingIndent?: 'none' | 'same' | 'indent' | 'deepIndent' | string;
    theme?: string;
    themes?: CodeBlockMonacoTheme[];
    languages?: CodeBlockMonacoLanguage[];
    renderSideBySide?: boolean;
    useInlineViewWhenSpaceIsLimited?: boolean;
    enableSplitViewResizing?: boolean;
    ignoreTrimWhitespace?: boolean;
    maxComputationTime?: number;
    diffAlgorithm?: string;
    renderIndicators?: boolean;
    originalEditable?: boolean;
    revealDebounceMs?: number;
    revealStrategy?: 'bottom' | 'centerIfOutside' | 'center';
    revealBatchOnIdleMs?: number;
    updateThrottleMs?: number;
    diffUpdateThrottleMs?: number;
    diffAutoScroll?: boolean;
    diffHideUnchangedRegions?: CodeBlockDiffHideUnchangedRegions;
    diffLineStyle?: CodeBlockDiffLineStyle;
    diffAppearance?: CodeBlockDiffAppearance;
    diffUnchangedRegionStyle?: CodeBlockDiffUnchangedRegionStyle;
    diffHunkActionsOnHover?: boolean;
    diffHunkHoverHideDelayMs?: number;
    onDiffHunkAction?: (context: CodeBlockDiffHunkActionContext) => void | boolean | Promise<void | boolean>;
    scrollbar?: Record<string, unknown>;
    [key: string]: unknown;
}
interface CodeBlockNodeProps extends CommonCodeBlockProps {
    node: CodeBlockNode$1;
    isDark?: boolean;
    loading?: boolean;
    stream?: boolean;
    darkTheme?: CodeBlockMonacoTheme;
    lightTheme?: CodeBlockMonacoTheme;
    isShowPreview?: boolean;
    monacoOptions?: CodeBlockMonacoOptions;
    enableFontSizeControl?: boolean;
    minWidth?: string | number;
    maxWidth?: string | number;
    themes?: CodeBlockMonacoTheme[];
    showPreviewButton?: boolean;
    showCollapseButton?: boolean;
    showFontSizeButtons?: boolean;
    showTooltips?: boolean;
    htmlPreviewAllowScripts?: boolean;
    htmlPreviewSandbox?: string;
    customId?: string;
}
interface ImageNodeProps {
    node: {
        type: 'image';
        src: string;
        alt: string;
        title: string | null;
        raw: string;
        loading?: boolean;
    };
    fallbackSrc?: string;
    lazy?: boolean;
    usePlaceholder?: boolean;
}
interface LinkNodeProps {
    node: {
        type: 'link';
        href: string;
        title: string | null;
        text: string;
        attrs?: [string, 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: CodeBlockNode$1;
    className?: string;
    style?: CSSProperties;
    showLineNumbers?: boolean;
    diffInline?: boolean;
}
interface MermaidBlockNodeProps {
    node: CodeBlockNode$1;
    maxHeight?: string | null;
    estimatedPreviewHeightPx?: number;
    loading?: boolean;
    isDark?: boolean;
    workerTimeoutMs?: number;
    parseTimeoutMs?: number;
    renderTimeoutMs?: number;
    fullRenderTimeoutMs?: number;
    renderDebounceMs?: number;
    contentStableDelayMs?: number;
    previewPollDelayMs?: number;
    previewPollMaxDelayMs?: number;
    previewPollMaxAttempts?: number;
    showHeader?: boolean;
    showModeToggle?: boolean;
    showCopyButton?: boolean;
    showExportButton?: boolean;
    showFullscreenButton?: boolean;
    showCollapseButton?: boolean;
    showZoomControls?: boolean;
    enableWheelZoom?: boolean;
    isStrict?: boolean;
    enableMermaidInteractions?: boolean;
    showTooltips?: boolean;
    onRenderError?: (error: unknown, code: string, container: HTMLElement) => boolean | void;
}
interface CodeBlockPreviewPayload {
    node: CodeBlockNode$1;
    artifactType: 'text/html' | 'image/svg+xml';
    artifactTitle: string;
    id: string;
}
interface MermaidBlockEvent<TPayload = unknown> {
    payload?: TPayload;
    defaultPrevented: boolean;
    preventDefault: () => void;
    svgElement?: SVGElement | null;
    svgString?: string | null;
}
interface D2BlockNodeProps {
    node: CodeBlockNode$1;
    maxHeight?: string | null;
    loading?: boolean;
    isDark?: boolean;
    progressiveRender?: boolean;
    progressiveIntervalMs?: number;
    themeId?: number | null;
    darkThemeId?: number | null;
    showHeader?: boolean;
    showModeToggle?: boolean;
    showCopyButton?: boolean;
    showExportButton?: boolean;
    showCollapseButton?: boolean;
}
interface MathBlockNodeProps {
    node: {
        type: 'math_block';
        content: string;
        raw: string;
        loading?: boolean;
    };
}
interface MathInlineNodeProps {
    node: {
        type: 'math_inline';
        content: string;
        raw: string;
        loading?: boolean;
        markup?: string;
    };
}
interface InfographicBlockNodeProps {
    node: CodeBlockNode$1;
    maxHeight?: string | null;
    estimatedPreviewHeightPx?: number;
    loading?: boolean;
    isDark?: boolean;
    showHeader?: boolean;
    showModeToggle?: boolean;
    showCopyButton?: boolean;
    showCollapseButton?: boolean;
    showExportButton?: boolean;
    showFullscreenButton?: boolean;
    showZoomControls?: boolean;
}

type NodeRendererCodeBlockThemes = CodeBlockNodeProps['themes'] | ShikiCodeBlockProps['themes'];
type NodeRendererCodeBlockProps = Partial<Omit<CodeBlockNodeProps, 'node' | 'themes'>> & Partial<Omit<ShikiCodeBlockProps, 'themes'>> & {
    themes?: NodeRendererCodeBlockThemes;
} & Record<string, unknown>;
interface NodeRendererProps<TStreamingComponents extends Record<string, ComponentType<any>> = StreamingComponentMap, THtmlComponents extends Record<string, any> = HtmlComponentMap> {
    content?: string;
    nodes?: readonly BaseNode[] | null;
    /**
     * Whether the input stream is complete (end-of-stream). When true, the parser
     * can stop emitting streaming "loading" nodes for unfinished constructs.
     */
    final?: boolean;
    parseOptions?: ParseOptions;
    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
    streamingComponents?: TStreamingComponents & StreamingComponentDefinitions<TStreamingComponents>;
    htmlComponents?: THtmlComponents & HtmlComponentDefinitions<THtmlComponents>;
    /** Log parse/render timing stats (dev only). */
    debugPerformance?: boolean;
    /**
     * Custom HTML-like tags that should be emitted as custom nodes (e.g. ['thinking']).
     * Forwarded to `getMarkdown()` and merged into parseOptions.
     */
    customHtmlTags?: readonly string[];
    htmlPolicy?: HtmlPolicy;
    viewportPriority?: boolean;
    codeBlockStream?: boolean;
    codeBlockDarkTheme?: CodeBlockMonacoTheme;
    codeBlockLightTheme?: CodeBlockMonacoTheme;
    codeBlockMonacoOptions?: CodeBlockMonacoOptions;
    renderCodeBlocksAsPre?: boolean;
    codeBlockMinWidth?: string | number;
    codeBlockMaxWidth?: string | number;
    codeBlockProps?: NodeRendererCodeBlockProps;
    mermaidProps?: Partial<Omit<MermaidBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
    d2Props?: Partial<Omit<D2BlockNodeProps, 'node' | 'loading' | 'isDark'>>;
    infographicProps?: Partial<Omit<InfographicBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
    showTooltips?: boolean;
    /**
     * Theme names or theme objects preloaded for Monaco-backed code blocks.
     * When Shiki code blocks are used, only string theme names are forwarded to
     * MarkdownCodeBlockNode / stream-markdown; theme objects are ignored.
     */
    themes?: CodeBlockMonacoTheme[];
    /**
     * Shiki language preload list forwarded to MarkdownCodeBlockNode.
     *
     * The default React code block renderer is Monaco-backed. This prop is used
     * when a custom `code_block` or language renderer uses MarkdownCodeBlockNode.
     */
    langs?: readonly string[];
    isDark?: boolean;
    customId?: string;
    indexKey?: number | string;
    /** Show a blinking typewriter cursor while streamed content grows. Default: false */
    typewriter?: boolean;
    /** Enable/disable non-code-node enter and streamed-text fade animations. Default: true */
    fade?: boolean;
    /**
     * Enable built-in smooth pacing for streaming `content` updates.
     * - `true`: force-enable smooth streaming (content mode only)
     * - `false`: force-disable smooth streaming
     * - `'auto'` (default): enable only when typewriter/incremental mode is active
     * Applies when rendering from `content` (not `nodes`).
     */
    smoothStreaming?: boolean | 'auto';
    /** Options forwarded to the built-in smooth streaming controller. Read once when the renderer is created. */
    smoothStreamingOptions?: SmoothMarkdownStreamOptions;
    batchRendering?: boolean;
    initialRenderBatchSize?: number;
    renderBatchSize?: number;
    renderBatchDelay?: number;
    renderBatchBudgetMs?: number;
    renderBatchIdleTimeoutMs?: number;
    deferNodesUntilVisible?: boolean;
    maxLiveNodes?: number;
    liveNodeBuffer?: number;
    onCopy?: (code: string) => void;
    onHandleArtifactClick?: (payload: CodeBlockPreviewPayload) => void;
    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
    onMouseOver?: (event: React.MouseEvent<HTMLElement>) => void;
    onMouseOut?: (event: React.MouseEvent<HTMLElement>) => void;
}
interface RenderContext {
    customId?: string;
    isDark?: boolean;
    final?: boolean;
    indexKey?: string;
    typewriter?: boolean;
    /** Enable/disable fade animations. Default: true */
    fade?: boolean;
    textStreamState?: Map<string, string>;
    streamRenderVersion?: number;
    customComponents?: CustomComponentMap;
    streamingComponents?: StreamingComponentMap;
    htmlComponents?: HtmlComponentMap;
    customHtmlTags?: readonly string[];
    htmlPolicy?: HtmlPolicy;
    codeBlockProps?: NodeRendererCodeBlockProps;
    mermaidProps?: Partial<Omit<MermaidBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
    d2Props?: Partial<Omit<D2BlockNodeProps, 'node' | 'loading' | 'isDark'>>;
    infographicProps?: Partial<Omit<InfographicBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
    showTooltips?: boolean;
    codeBlockStream?: boolean;
    renderCodeBlocksAsPre?: boolean;
    codeBlockThemes?: {
        themes?: CodeBlockMonacoTheme[];
        darkTheme?: CodeBlockMonacoTheme;
        lightTheme?: CodeBlockMonacoTheme;
        monacoOptions?: CodeBlockMonacoOptions;
        minWidth?: string | number;
        maxWidth?: string | number;
        langs?: readonly string[];
    };
    events: {
        onCopy?: (code: string) => void;
        onHandleArtifactClick?: (payload: CodeBlockPreviewPayload) => void;
    };
}
type RenderNodeFn = (node: ParsedNode, key: React.Key, ctx: RenderContext) => React.ReactNode;

interface MarkdownCodeBlockNodeProps extends ShikiCodeBlockProps {
    node: {
        type: 'code_block';
        language: string;
        code: string;
        raw: string;
        diff?: boolean;
        originalCode?: string;
        updatedCode?: string;
    };
    loading?: boolean;
    stream?: boolean;
    darkTheme?: string;
    lightTheme?: string;
    isDark?: boolean;
    isShowPreview?: boolean;
    enableFontSizeControl?: boolean;
    minWidth?: string | number;
    maxWidth?: string | number;
    showPreviewButton?: boolean;
    showCollapseButton?: boolean;
    showFontSizeButtons?: boolean;
    showTooltips?: boolean;
    onCopy?: (code: string) => void;
    onPreviewCode?: (payload: {
        type: string;
        content: string;
        title: string;
    }) => void;
}

interface LinkNodeStyleProps {
    showTooltip?: boolean;
    color?: string;
    underlineHeight?: number;
    underlineBottom?: number | string;
    animationDuration?: number;
    animationOpacity?: number;
    animationTiming?: string;
    animationIteration?: string | number;
}

interface HtmlPreviewFrameProps {
    code: string;
    isDark?: boolean;
    htmlPreviewAllowScripts?: boolean;
    htmlPreviewSandbox?: string;
    onClose?: () => void;
    title?: string;
}

interface D2Instance {
    D2?: D2Constructor;
    compile?: (source: string, options?: Record<string, unknown>) => Promise<unknown> | unknown;
    render?: (input: unknown, options?: Record<string, unknown>) => Promise<unknown> | unknown;
}
interface D2Constructor {
    new (): D2Instance;
    D2?: D2Constructor;
    compile?: D2Instance['compile'];
}
type D2Module = D2Constructor | D2Instance;
type D2Loader = () => Promise<unknown> | unknown;
declare function setD2Loader(loader: D2Loader | null): void;
declare function enableD2(loader?: D2Loader): void;
declare function disableD2(): void;
declare function isD2Enabled(): boolean;
declare function getD2(): Promise<D2Module | null>;

interface ListItemNodeData {
    type: 'list_item';
    children?: ParsedNode[];
    raw?: string;
}
interface ListItemNodeProps extends NodeComponentProps<ListItemNodeData> {
    value?: number;
}

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;
declare function useSafeI18n(): {
    t: (key: string) => string;
};

declare function renderNode(node: ParsedNode, key: React.Key, ctx: RenderContext): any;

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

declare function setKaTeXWorker(w: Worker): void;
declare function clearKaTeXWorker(): void;
declare function setKaTeXWorkerDebug(enabled: boolean): void;
declare const WORKER_BUSY_CODE = "WORKER_BUSY";
declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
declare function clearKaTeXCache(): void;
declare function setKaTeXConcurrencyLimit(limit: number): void;
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;
};
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";
declare function setMermaidWorker(w: Worker): void;
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 AdmonitionNode: {
    (props: NodeComponentProps<{
        type: "admonition";
        kind?: string;
        title?: string;
        children?: stream_markdown_parser.ParsedNode[];
        collapsible?: boolean;
        open?: boolean;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const BlockquoteNode: {
    (props: NodeComponentProps<{
        type: "blockquote";
        children?: stream_markdown_parser.ParsedNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const CheckboxNode: {
    (props: NodeComponentProps<{
        type: "checkbox" | "checkbox_input";
        checked?: boolean;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const CodeBlockNode: {
    (props: CodeBlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ReactCodeBlockNode: {
    (props: CodeBlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const HtmlPreviewFrame: {
    (props: HtmlPreviewFrameProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const D2BlockNode: {
    (props: D2BlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const DefinitionListNode: {
    (props: NodeComponentProps<{
        type: "definition_list";
        items?: stream_markdown_parser.DefinitionItemNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const EmojiNode: {
    (props: NodeComponentProps<{
        type: "emoji";
        name: string;
        markup?: string;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const EmphasisNode: {
    (props: NodeComponentProps<{
        type: "emphasis";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const FootnoteAnchorNode: {
    (props: NodeComponentProps<{
        type: "footnote_anchor";
        id: string;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const FootnoteNode: {
    (props: NodeComponentProps<{
        type: "footnote";
        id: string;
        children?: stream_markdown_parser.ParsedNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const FootnoteReferenceNode: {
    (props: NodeComponentProps<{
        type: "footnote_reference";
        id: string;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const HardBreakNode: {
    (props: NodeComponentProps<{
        type: "hardbreak";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const HeadingNode: {
    (props: NodeComponentProps<{
        type: "heading";
        level?: number;
        children?: stream_markdown_parser.ParsedNode[];
        attrs?: Record<string, string | boolean>;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const HighlightNode: {
    (props: NodeComponentProps<{
        type: "highlight";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const HtmlBlockNode: {
    (props: NodeComponentProps<{
        type: "html_block";
        content?: string;
        tag?: string;
        attrs?: [string, string | null][] | null;
        children?: stream_markdown_parser.ParsedNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const HtmlInlineNode: {
    (props: NodeComponentProps<{
        type: "html_inline";
        content?: string;
        tag?: string;
        attrs?: [string, string | null][] | null;
        children?: stream_markdown_parser.ParsedNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ImageNode: {
    (props: ImageNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const InfographicBlockNode: {
    (props: InfographicBlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const InlineCodeNode: {
    (props: NodeComponentProps<{
        type: "inline_code";
        code: string;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const InsertNode: {
    (props: NodeComponentProps<{
        type: "insert";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const LinkNode: {
    (props: NodeComponentProps<{
        type: "link";
        href: string;
        title: string | null;
        text: string;
        children?: stream_markdown_parser.ParsedNode[];
        loading?: boolean;
    }> & LinkNodeStyleProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ListItemNode: {
    (props: NodeComponentProps<{
        type: "list_item";
        children?: stream_markdown_parser.ParsedNode[];
    }> & {
        value?: number;
    }): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ListNode: {
    (props: NodeComponentProps<{
        type: "list";
        ordered?: boolean;
        start?: number;
        items?: stream_markdown_parser.ListItemNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const MarkdownCodeBlockNode: {
    (props: MarkdownCodeBlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const MathBlockNode: {
    (props: MathBlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const MathInlineNode: {
    (props: MathInlineNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const MermaidBlockNode: {
    (props: MermaidBlockNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const NodeRenderer: {
    (props: NodeRendererProps<StreamingComponentMap, Record<string, any>>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const FallbackComponent: {
    (props: NodeComponentProps<{
        type: string;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ParagraphNode: {
    (props: NodeComponentProps<{
        type: "paragraph";
        children?: stream_markdown_parser.ParsedNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const PreCodeNode: {
    (props: PreCodeNodeProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ReferenceNode: {
    (props: NodeComponentProps<{
        type: "reference";
        id: string;
    }> & {
        messageId?: string;
        threadId?: string;
    }): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const StrikethroughNode: {
    (props: NodeComponentProps<{
        type: "strikethrough";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const StrongNode: {
    (props: NodeComponentProps<{
        type: "strong";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const SubscriptNode: {
    (props: NodeComponentProps<{
        type: "subscript";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const SuperscriptNode: {
    (props: NodeComponentProps<{
        type: "superscript";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const TableNode: {
    (props: NodeComponentProps<{
        type: "table";
        header?: stream_markdown_parser.TableRowNode;
        rows?: stream_markdown_parser.TableRowNode[];
        loading?: boolean;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const TextNode: {
    (props: NodeComponentProps<{
        type: "text";
        content: string;
        center?: boolean;
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const ThematicBreakNode: {
    (props: NodeComponentProps<{
        type: "thematic_break";
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const Tooltip: {
    (props: TooltipProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};
declare const VmrContainerNode: {
    (props: NodeComponentProps<{
        type: "vmr_container";
        name: string;
        attrs?: Record<string, string> | [string, string | null][] | null;
        children?: stream_markdown_parser.ParsedNode[];
    }>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
    displayName: string;
};

export { AdmonitionNode, BackpressureOptions, BlockquoteNode, CheckboxNode, CodeBlockDiffAppearance, CodeBlockDiffHideUnchangedRegions, CodeBlockDiffHideUnchangedRegionsOptions, CodeBlockDiffHunkActionContext, CodeBlockDiffHunkActionKind, CodeBlockDiffHunkSide, CodeBlockDiffLineStyle, CodeBlockDiffUnchangedRegionStyle, CodeBlockMonacoLanguage, CodeBlockMonacoOptions, CodeBlockMonacoTheme, CodeBlockMonacoThemeObject, CodeBlockNode, CodeBlockNodeProps, CodeBlockPreviewPayload, CommonCodeBlockProps, CustomComponentDisplayMode, D2BlockNode, D2BlockNodeProps, D2Constructor, D2Instance, D2Loader, D2Module, DefinitionListNode, EmojiNode, EmphasisNode, FallbackComponent, FootnoteAnchorNode, FootnoteNode, FootnoteReferenceNode, HardBreakNode, HeadingNode, HighlightNode, HtmlBlockNode, HtmlComponent, HtmlComponentMap, HtmlInlineNode, HtmlPreviewFrame, HtmlPreviewFrameProps, ImageNode, ImageNodeProps, InfographicBlockNode, InfographicBlockNodeProps, InlineCodeNode, InsertNode, LanguageIconResolver, LinkNode, LinkNodeProps, LinkNodeStyleProps, ListItemNode, ListItemNodeProps, ListNode, MERMAID_WORKER_BUSY_CODE, MarkdownCodeBlockNode, MarkdownCodeBlockNodeProps, MarkstreamCustomComponent, MathBlockNode, MathBlockNodeProps, MathInlineNode, MathInlineNodeProps, MermaidBlockEvent, MermaidBlockNode, MermaidBlockNodeProps, NodeComponentProps, NodeRenderer, NodeRendererCodeBlockProps, NodeRendererProps, ParagraphNode, PreCodeNode, PreCodeNodeProps, ReactCodeBlockNode, ReferenceNode, ShikiCodeBlockProps, StreamingComponent, StreamingComponentMap, StrikethroughNode, StrongNode, SubscriptNode, SuperscriptNode, TableNode, TextNode, ThematicBreakNode, Tooltip, TooltipPlacement, TooltipProps, VmrContainerNode, WORKER_BUSY_CODE, canParseOffthread, clearGlobalCustomComponents, clearKaTeXCache, clearKaTeXWorker, clearMermaidWorker, NodeRenderer as default, defineHtmlComponents, defineStreamingComponents, disableD2, enableD2, findPrefixOffthread, getCustomNodeComponents, getD2, getKaTeXBackpressureDefaults, getLanguageIcon, getMermaidWorkerLoad, isD2Enabled, languageMap, normalizeLanguageIdentifier, preloadExtendedLanguageIcons, removeCustomComponents, renderKaTeXInWorker, renderKaTeXWithBackpressure, renderNode, resolveMonacoLanguageId, setCustomComponents, setD2Loader, setDefaultI18nMap, setKaTeXBackpressureDefaults, setKaTeXCache, setKaTeXConcurrencyLimit, setKaTeXWorker, setKaTeXWorkerDebug, setLanguageIconResolver, setMermaidWorker, setMermaidWorkerClientDebug, setMermaidWorkerMaxConcurrency, subscribeLanguageIconsRevision, terminateWorker, useSafeI18n, waitForKaTeXWorkerSlot };