@uipath/apollo-wind 2.68.0 → 2.70.0

package/dist/components/ui/loading-dots.d.ts

@@ -0,0 +1,21 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const loadingDotsVariants: (props?: ({
+    size?: "lg" | "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface LoadingDotsStrings {
+    /** Accessible name of the status. */
+    label: string;
+}
+export declare const DEFAULT_LOADING_DOTS_STRINGS: LoadingDotsStrings;
+export interface LoadingDotsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof loadingDotsVariants> {
+    /** Overrides for any subset of the English strings. An explicit `aria-label` wins over `label`. */
+    strings?: Partial<LoadingDotsStrings>;
+}
+/**
+ * Three dots with a staggered bounce, for compact waits inside a conversation such as loading
+ * older messages or a typing hint. The dots take `currentColor`, so set the colour with a text
+ * class. They hold still under `prefers-reduced-motion` (handled by `animate-loading-dot`).
+ */
+declare const LoadingDots: React.ForwardRefExoticComponent<LoadingDotsProps & React.RefAttributes<HTMLDivElement>>;
+export { LoadingDots, loadingDotsVariants };

package/dist/components/ui/loading-dots.js

@@ -0,0 +1,55 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { forwardRef } from "react";
+import { cn } from "../../lib/index.js";
+const loadingDotsVariants = cva('inline-flex shrink-0 items-end text-muted-foreground', {
+    variants: {
+        size: {
+            sm: 'h-2 gap-0.5 [&>[data-slot=loading-dot]]:size-1',
+            md: 'h-3 gap-1 [&>[data-slot=loading-dot]]:size-1.5',
+            lg: 'h-4 gap-1.5 [&>[data-slot=loading-dot]]:size-2'
+        }
+    },
+    defaultVariants: {
+        size: 'md'
+    }
+});
+const DOT_DELAYS = [
+    '[animation-delay:0ms]',
+    '[animation-delay:150ms]',
+    '[animation-delay:300ms]'
+];
+const DEFAULT_LOADING_DOTS_STRINGS = {
+    label: 'Loading'
+};
+const LoadingDots = /*#__PURE__*/ forwardRef(({ className, size = 'md', strings, 'aria-label': ariaLabel, ...props }, ref)=>{
+    const text = {
+        ...DEFAULT_LOADING_DOTS_STRINGS,
+        ...strings
+    };
+    const name = ariaLabel ?? text.label;
+    return /*#__PURE__*/ jsxs("div", {
+        ref: ref,
+        "data-slot": "loading-dots",
+        "data-size": size,
+        role: "status",
+        "aria-label": name,
+        className: cn(loadingDotsVariants({
+            size
+        }), className),
+        ...props,
+        children: [
+            DOT_DELAYS.map((delay)=>/*#__PURE__*/ jsx("span", {
+                    "data-slot": "loading-dot",
+                    "aria-hidden": "true",
+                    className: cn('animate-loading-dot rounded-full bg-current', delay)
+                }, delay)),
+            /*#__PURE__*/ jsx("span", {
+                className: "sr-only",
+                children: name
+            })
+        ]
+    });
+});
+LoadingDots.displayName = 'LoadingDots';
+export { DEFAULT_LOADING_DOTS_STRINGS, LoadingDots, loadingDotsVariants };

package/dist/components/ui/markdown.cjs

@@ -0,0 +1,428 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_MARKDOWN_STRINGS: ()=>DEFAULT_MARKDOWN_STRINGS,
+    Markdown: ()=>Markdown
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_react_markdown_namespaceObject = require("react-markdown");
+var external_react_markdown_default = /*#__PURE__*/ __webpack_require__.n(external_react_markdown_namespaceObject);
+const external_rehype_katex_namespaceObject = require("rehype-katex");
+var external_rehype_katex_default = /*#__PURE__*/ __webpack_require__.n(external_rehype_katex_namespaceObject);
+const external_remark_gfm_namespaceObject = require("remark-gfm");
+var external_remark_gfm_default = /*#__PURE__*/ __webpack_require__.n(external_remark_gfm_namespaceObject);
+const external_remark_math_namespaceObject = require("remark-math");
+var external_remark_math_default = /*#__PURE__*/ __webpack_require__.n(external_remark_math_namespaceObject);
+const external_code_block_cjs_namespaceObject = require("./code-block.cjs");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+function hastText(node) {
+    if ('text' === node.type) return node.value ?? '';
+    return (node.children ?? []).map(hastText).join('');
+}
+function languageOf(node) {
+    const className = node.properties?.className;
+    const classes = Array.isArray(className) ? className.map(String) : [];
+    return classes.find((name)=>name.startsWith('language-'))?.slice('language-'.length);
+}
+const opensInNewTab = (href)=>!!href && !/^(#|mailto:|tel:)/i.test(href);
+const BR_TAG = /^<br\s*\/?>$/i;
+function remarkHtmlBreaks() {
+    const visit = (node)=>{
+        if (!node.children) return;
+        node.children = node.children.map((child)=>'html' === child.type && BR_TAG.test(child.value?.trim() ?? '') ? {
+                type: 'break'
+            } : child);
+        node.children.forEach(visit);
+    };
+    return (tree)=>visit(tree);
+}
+const CURSOR_CONTAINERS = new Set([
+    'ul',
+    'ol',
+    'li',
+    'blockquote',
+    'table',
+    'thead',
+    'tbody',
+    'tr'
+]);
+const CURSOR_TEXT_BLOCKS = new Set([
+    'p',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'td',
+    'th'
+]);
+const CURSOR_CLASS = 'ml-0.5 inline-block h-[1.1em] w-[0.45em] translate-y-[0.2em] rounded-[1px] bg-foreground animate-pulse motion-reduce:animate-none';
+function lastContent(node) {
+    const children = node.children ?? [];
+    for(let i = children.length - 1; i >= 0; i--){
+        const child = children[i];
+        if ('element' === child.type) return child;
+        if ('text' === child.type && child.value?.trim()) return child;
+    }
+}
+function findCursorHost(root) {
+    let node = root;
+    for(;;){
+        const last = lastContent(node);
+        if (last?.type !== 'element' || !last.tagName) return node;
+        if (CURSOR_TEXT_BLOCKS.has(last.tagName)) return last;
+        if (!CURSOR_CONTAINERS.has(last.tagName)) return node;
+        node = last;
+    }
+}
+function rehypeStreamingCursor() {
+    return (tree)=>{
+        const host = findCursorHost(tree);
+        host.children = [
+            ...host.children ?? [],
+            {
+                type: 'element',
+                tagName: 'span',
+                properties: {
+                    dataSlot: 'markdown-cursor',
+                    ariaHidden: 'true',
+                    className: [
+                        CURSOR_CLASS
+                    ]
+                },
+                children: []
+            }
+        ];
+    };
+}
+function rehypeScopeFootnoteLabel(options) {
+    const LABEL = 'footnote-label';
+    const scoped = `${options.prefix}${LABEL}`;
+    const visit = (node)=>{
+        const properties = node.properties;
+        if (properties?.id === LABEL) properties.id = scoped;
+        if (properties && Array.isArray(properties.ariaDescribedBy)) properties.ariaDescribedBy = properties.ariaDescribedBy.map((ref)=>ref === LABEL ? scoped : ref);
+        node.children?.forEach(visit);
+    };
+    return (tree)=>visit(tree);
+}
+const DEFAULT_MARKDOWN_STRINGS = {
+    ...external_code_block_cjs_namespaceObject.DEFAULT_CODE_BLOCK_STRINGS,
+    footnotes: 'Footnotes',
+    footnoteBack: 'Back to content',
+    taskDone: 'Done',
+    taskOpen: 'Not done'
+};
+function isAllowedImageSrc(src, policy) {
+    if ('none' === policy) return false;
+    if ('all' === policy) return true;
+    if ('function' == typeof policy) return policy(src);
+    try {
+        const base = "u" < typeof window ? 'https://relative.invalid' : window.location.href;
+        return new URL(src, base).origin === new URL(base).origin;
+    } catch  {
+        return false;
+    }
+}
+const MarkdownContext = /*#__PURE__*/ external_react_namespaceObject.createContext({
+    strings: DEFAULT_MARKDOWN_STRINGS,
+    images: 'none',
+    codeWrap: false
+});
+const InsideLinkContext = /*#__PURE__*/ external_react_namespaceObject.createContext(false);
+const LINK_CLASS = 'font-medium text-foreground-link underline underline-offset-2 hover:no-underline';
+function MarkdownLink({ node: _node, className, href, children, ...rest }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+        href: href,
+        className: (0, index_cjs_namespaceObject.cn)(LINK_CLASS, className),
+        ...opensInNewTab(href) ? {
+            target: '_blank',
+            rel: 'noreferrer'
+        } : {},
+        ...rest,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(InsideLinkContext.Provider, {
+            value: true,
+            children: children
+        })
+    });
+}
+function MarkdownImage({ node: _node, className, alt, src, ...rest }) {
+    const { images } = external_react_namespaceObject.useContext(MarkdownContext);
+    const insideLink = external_react_namespaceObject.useContext(InsideLinkContext);
+    const source = 'string' == typeof src ? src : '';
+    if (source && isAllowedImageSrc(source, images)) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("img", {
+        alt: alt ?? '',
+        src: source,
+        loading: "lazy",
+        referrerPolicy: "no-referrer",
+        className: (0, index_cjs_namespaceObject.cn)('h-auto max-w-full rounded-md', className),
+        ...rest
+    });
+    const label = alt || source;
+    if (insideLink || !source) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+        "data-slot": "markdown-image-text",
+        children: label
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+        "data-slot": "markdown-image-link",
+        href: source,
+        target: "_blank",
+        rel: "noreferrer",
+        className: LINK_CLASS,
+        children: label
+    });
+}
+function MarkdownInput({ node: _node, className, type, checked, ...rest }) {
+    const { strings } = external_react_namespaceObject.useContext(MarkdownContext);
+    if ('checkbox' !== type) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("input", {
+        type: type,
+        className: className,
+        ...rest
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("input", {
+                type: "checkbox",
+                checked: checked,
+                "aria-hidden": "true",
+                tabIndex: -1,
+                className: (0, index_cjs_namespaceObject.cn)('mr-2 size-3.5 translate-y-0.5 accent-primary', className),
+                ...rest
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("span", {
+                "data-slot": "markdown-task-state",
+                className: "sr-only",
+                children: [
+                    checked ? strings.taskDone : strings.taskOpen,
+                    ' '
+                ]
+            })
+        ]
+    });
+}
+function MarkdownPre({ node, children, ...rest }) {
+    const { strings, codeWrap, renderCodeActions } = external_react_namespaceObject.useContext(MarkdownContext);
+    const codeNode = node?.children?.find((child)=>'element' === child.type && 'code' === child.tagName);
+    if (!codeNode) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("pre", {
+        ...rest,
+        children: children
+    });
+    const block = {
+        code: hastText(codeNode).replace(/\n$/, ''),
+        language: languageOf(codeNode)
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_code_block_cjs_namespaceObject.CodeBlock, {
+        code: block.code,
+        language: block.language,
+        wrap: codeWrap,
+        actions: renderCodeActions?.(block),
+        strings: strings
+    });
+}
+const BUILT_IN_COMPONENTS = {
+    h1: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h1", {
+            className: (0, index_cjs_namespaceObject.cn)('text-xl font-semibold tracking-tight', className),
+            ...rest
+        }),
+    h2: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h2", {
+            className: (0, index_cjs_namespaceObject.cn)('text-lg font-semibold tracking-tight', className),
+            ...rest
+        }),
+    h3: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h3", {
+            className: (0, index_cjs_namespaceObject.cn)('text-base font-semibold', className),
+            ...rest
+        }),
+    h4: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h4", {
+            className: (0, index_cjs_namespaceObject.cn)('text-sm font-semibold', className),
+            ...rest
+        }),
+    h5: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h5", {
+            className: (0, index_cjs_namespaceObject.cn)('text-sm font-semibold', className),
+            ...rest
+        }),
+    h6: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h6", {
+            className: (0, index_cjs_namespaceObject.cn)('text-sm font-semibold text-muted-foreground', className),
+            ...rest
+        }),
+    p: ({ node: _node, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("p", {
+            ...rest
+        }),
+    a: MarkdownLink,
+    ul: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("ul", {
+            className: (0, index_cjs_namespaceObject.cn)('flex flex-col gap-1 pl-6', className?.includes('contains-task-list') ? 'list-none pl-1' : 'list-disc', 'marker:text-muted-foreground', className),
+            ...rest
+        }),
+    ol: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("ol", {
+            className: (0, index_cjs_namespaceObject.cn)('flex list-decimal flex-col gap-1 pl-6 marker:text-muted-foreground', className),
+            ...rest
+        }),
+    li: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("li", {
+            className: (0, index_cjs_namespaceObject.cn)('pl-1 [&>ol]:mt-1 [&>p+p]:mt-2 [&>ul]:mt-1 [&>ul.contains-task-list]:pl-6', className),
+            ...rest
+        }),
+    input: MarkdownInput,
+    blockquote: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("blockquote", {
+            className: (0, index_cjs_namespaceObject.cn)('flex flex-col gap-2 border-l-2 border-border pl-4 text-muted-foreground', className),
+            ...rest
+        }),
+    hr: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("hr", {
+            className: (0, index_cjs_namespaceObject.cn)('border-border-subtle', className),
+            ...rest
+        }),
+    img: MarkdownImage,
+    table: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+            "data-slot": "markdown-table",
+            tabIndex: 0,
+            className: "max-w-full overflow-x-auto rounded-lg border border-border-subtle outline-none focus-visible:ring-2 focus-visible:ring-ring",
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("table", {
+                className: (0, index_cjs_namespaceObject.cn)('w-full border-collapse text-left [&_tr:last-child>td]:border-b-0', className),
+                ...rest
+            })
+        }),
+    th: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("th", {
+            className: (0, index_cjs_namespaceObject.cn)('border-b border-border-subtle bg-surface-overlay px-3 py-2 font-semibold', className),
+            ...rest
+        }),
+    td: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("td", {
+            className: (0, index_cjs_namespaceObject.cn)('border-b border-border-subtle px-3 py-2 align-top', className),
+            ...rest
+        }),
+    code: ({ node: _node, className, ...rest })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("code", {
+            className: (0, index_cjs_namespaceObject.cn)('rounded-md bg-surface-overlay px-1.5 py-0.5 font-mono text-[0.875em]', className),
+            ...rest
+        }),
+    pre: MarkdownPre
+};
+const Markdown = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ children, components, remarkPlugins, rehypePlugins, streaming = false, images = 'none', codeWrap = false, renderCodeActions, strings, className, ...props }, ref)=>{
+    const context = external_react_namespaceObject.useMemo(()=>({
+            strings: {
+                ...DEFAULT_MARKDOWN_STRINGS,
+                ...strings
+            },
+            images,
+            codeWrap,
+            renderCodeActions
+        }), [
+        strings,
+        images,
+        codeWrap,
+        renderCodeActions
+    ]);
+    const { footnotes, footnoteBack } = context.strings;
+    const footnotePrefix = `markdown${external_react_namespaceObject.useId().replace(/[^\w-]/g, '')}-`;
+    const mergedComponents = external_react_namespaceObject.useMemo(()=>components ? {
+            ...BUILT_IN_COMPONENTS,
+            ...components
+        } : BUILT_IN_COMPONENTS, [
+        components
+    ]);
+    const mergedRemarkPlugins = external_react_namespaceObject.useMemo(()=>[
+            external_remark_gfm_default(),
+            [
+                external_remark_math_default(),
+                {
+                    singleDollarTextMath: false
+                }
+            ],
+            remarkHtmlBreaks,
+            ...remarkPlugins ?? []
+        ], [
+        remarkPlugins
+    ]);
+    const mergedRehypePlugins = external_react_namespaceObject.useMemo(()=>[
+            [
+                rehypeScopeFootnoteLabel,
+                {
+                    prefix: footnotePrefix
+                }
+            ],
+            [
+                external_rehype_katex_default(),
+                {
+                    output: 'mathml',
+                    throwOnError: false,
+                    trust: false,
+                    strict: 'ignore'
+                }
+            ],
+            ...rehypePlugins ?? [],
+            ...streaming ? [
+                rehypeStreamingCursor
+            ] : []
+        ], [
+        rehypePlugins,
+        streaming,
+        footnotePrefix
+    ]);
+    const remarkRehypeOptions = external_react_namespaceObject.useMemo(()=>({
+            clobberPrefix: footnotePrefix,
+            footnoteLabel: footnotes,
+            footnoteBackLabel: footnoteBack
+        }), [
+        footnotePrefix,
+        footnotes,
+        footnoteBack
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: ref,
+        "data-slot": "markdown",
+        "data-streaming": streaming || void 0,
+        "aria-busy": streaming || void 0,
+        className: (0, index_cjs_namespaceObject.cn)('flex min-w-0 flex-col gap-3 text-sm leading-relaxed break-words text-foreground [&_math]:text-[1.15em] [&>.katex]:overflow-x-auto [&>.katex]:py-1', className),
+        ...props,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(MarkdownContext.Provider, {
+            value: context,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_markdown_default(), {
+                components: mergedComponents,
+                remarkPlugins: mergedRemarkPlugins,
+                rehypePlugins: mergedRehypePlugins,
+                remarkRehypeOptions: remarkRehypeOptions,
+                children: children
+            })
+        })
+    });
+});
+Markdown.displayName = 'Markdown';
+exports.DEFAULT_MARKDOWN_STRINGS = __webpack_exports__.DEFAULT_MARKDOWN_STRINGS;
+exports.Markdown = __webpack_exports__.Markdown;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_MARKDOWN_STRINGS",
+    "Markdown"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/markdown.d.ts

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import { type Components, type Options } from 'react-markdown';
+import { type CodeBlockStrings } from './code-block';
+export interface MarkdownStrings extends CodeBlockStrings {
+    /** Heading of the generated footnotes section. */
+    footnotes: string;
+    /** Label of the link from a footnote back to its reference. */
+    footnoteBack: string;
+    /** Read by screen readers before a completed task list item. */
+    taskDone: string;
+    /** Read by screen readers before an open task list item. */
+    taskOpen: string;
+}
+export declare const DEFAULT_MARKDOWN_STRINGS: MarkdownStrings;
+export interface MarkdownProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** The markdown source. */
+    children: string;
+    /**
+     * react-markdown renderers merged over the built-in ones. Use it with `remarkPlugins` to render
+     * custom nodes such as citations or resource chips. `code` only styles inline code: fenced blocks
+     * render through `pre`, so override `pre` (or use `renderCodeActions`) to change them.
+     */
+    components?: Components;
+    /** Extra remark plugins, run after GFM and math. */
+    remarkPlugins?: Options['remarkPlugins'];
+    /** Extra rehype plugins, run after KaTeX. */
+    rehypePlugins?: Options['rehypePlugins'];
+    /**
+     * The source is still arriving. Shows a caret after the last text and marks the region busy.
+     * Partial markdown is safe to pass: unclosed fences render as code and broken TeX as source.
+     */
+    streaming?: boolean;
+    /**
+     * Which images load automatically. Markdown in a chat comes from a model: a cross-origin image
+     * URL can carry conversation data to a third party, and a same-origin one can fire an
+     * authenticated GET, both without any click. By default no image loads; each renders as a link
+     * the reader can choose to open. Opt in with `'same-origin'`, `'all'` for trusted content, or a
+     * predicate for an allowlist. (react-markdown already drops `data:` and other unsafe URLs.)
+     */
+    images?: MarkdownImagePolicy;
+    /** Wrap long lines in fenced code instead of scrolling horizontally. */
+    codeWrap?: boolean;
+    /** Extra header actions for each fenced code block (preview, expand), placed before the copy. */
+    renderCodeActions?: (block: MarkdownCodeBlock) => React.ReactNode;
+    strings?: Partial<MarkdownStrings>;
+}
+export interface MarkdownCodeBlock {
+    /** The block's source without the trailing newline. */
+    code: string;
+    /** The fence's info string as written, e.g. `ts` or `html`. */
+    language: string | undefined;
+}
+export type MarkdownImagePolicy = 'none' | 'same-origin' | 'all' | ((src: string) => boolean);
+declare const Markdown: React.ForwardRefExoticComponent<MarkdownProps & React.RefAttributes<HTMLDivElement>>;
+export { Markdown };