@elabs-ai/components-ai 4.0.0

package/dist/index.d.ts

@@ -0,0 +1,4079 @@
+import * as react from 'react';
+import { ComponentProps, ReactNode, HTMLAttributes, RefObject, FormEvent, PropsWithChildren, ImgHTMLAttributes, FC, ElementType, JSX } from 'react';
+import * as _elabs_ai_components_ui from '@elabs-ai/components-ui';
+import { AccordionItem, Accordion, TimelineItemProps, Status, TimelineRootProps, Button, FileSource, HoverCard, HoverCardContent, HoverCardTrigger, CollapsibleContent, CollapsibleTrigger, Badge, HeadingLevel, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Collapsible, Avatar, InputGroupButton, DropdownMenuItem, DropdownMenu, DropdownMenuContent, TooltipContent, Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, InputGroupAddon, InputGroupTextarea, Alert, AlertDescription, AlertTitle, Switch, Carousel, ProseHeadingLevel, ButtonGroup, Popover, PopoverContent, Dialog, DialogContent, CommandDialog, CommandShortcut, DialogTrigger, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, ScrollArea, TabsContent, Tabs, TabsList, TabsTrigger, InputGroup, InputGroupInput, InputGroupText, Input } from '@elabs-ai/components-ui';
+import { Tool as Tool$1, FileUIPart, SourceDocumentUIPart, Experimental_SpeechResult, ChatStatus, ToolUIPart, LanguageModelUsage, UIMessage, Experimental_GeneratedImage, DynamicToolUIPart, Experimental_TranscriptionResult } from 'ai';
+import { LucideIcon, LucideProps, FileIcon } from 'lucide-react';
+import { MediaController, MediaControlBar, MediaDurationDisplay, MediaMuteButton, MediaPlayButton, MediaSeekBackwardButton, MediaSeekForwardButton, MediaTimeDisplay, MediaTimeRange, MediaVolumeRange } from 'media-chrome/react';
+import { ReactFlowProps, ConnectionLineComponent, Controls as Controls$1, EdgeProps, Panel as Panel$1, NodeToolbar as NodeToolbar$1 } from '@xyflow/react';
+import { BundledLanguage, ThemedToken } from 'shiki';
+import { StickToBottom } from 'use-stick-to-bottom';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ITheme } from '@xterm/xterm';
+import { TProps } from 'react-jsx-parser';
+import { MermaidConfig, DiagramPlugin } from '@streamdown/mermaid';
+import { Streamdown } from 'streamdown';
+import { z } from 'zod';
+import { Transition } from 'motion/react';
+import { RiveParameters } from '@rive-app/react-webgl2';
+
+type AgentProps = ComponentProps<"div">;
+declare const Agent: react.MemoExoticComponent<({ className, ...props }: AgentProps) => react.JSX.Element>;
+type AgentHeaderProps = ComponentProps<"div"> & {
+    name: string;
+    model?: string;
+};
+declare const AgentHeader: react.MemoExoticComponent<({ className, name, model, ...props }: AgentHeaderProps) => react.JSX.Element>;
+type AgentContentProps = ComponentProps<"div">;
+declare const AgentContent: react.MemoExoticComponent<({ className, ...props }: AgentContentProps) => react.JSX.Element>;
+type AgentInstructionsProps = ComponentProps<"div"> & {
+    children: string;
+};
+declare const AgentInstructions: react.MemoExoticComponent<({ className, children, ...props }: AgentInstructionsProps) => react.JSX.Element>;
+type AgentToolsProps = ComponentProps<typeof Accordion>;
+declare const AgentTools: react.MemoExoticComponent<({ className, ...props }: AgentToolsProps) => react.JSX.Element>;
+type AgentToolProps = ComponentProps<typeof AccordionItem> & {
+    tool: Tool$1;
+};
+declare const AgentTool: react.MemoExoticComponent<({ className, tool, value, ...props }: AgentToolProps) => react.JSX.Element>;
+type AgentOutputProps = ComponentProps<"div"> & {
+    schema: string;
+};
+declare const AgentOutput: react.MemoExoticComponent<({ className, schema, ...props }: AgentOutputProps) => react.JSX.Element>;
+
+type AgentTimelineProps = TimelineRootProps;
+/** The `<ol>` rail an agent run's steps sit on (canonical @elabs-ai/components-ui spine). */
+declare const AgentTimeline: react.ForwardRefExoticComponent<TimelineRootProps & react.RefAttributes<HTMLOListElement>>;
+interface AgentStepProps extends Omit<TimelineItemProps, "children" | "description"> {
+    /** Optional leading concept glyph on the title row (Lucide). */
+    icon?: LucideIcon;
+    /** What the agent did — the step's title (`text-body`). */
+    name: ReactNode;
+    /** The business summary line under the name (`text-meta`), not JSON. */
+    summary?: ReactNode;
+    /**
+     * The canonical execution status (closed 7-state enum). Drives the rail
+     * node AND the `StatusBadge`. `skipped` is the agent-step-only state with
+     * no SDK source (research 10 §B.1).
+     */
+    status?: Status;
+    /**
+     * Drop the inline `StatusBadge` (the rail node still carries the status
+     * color). For quiet prose rails — e.g. the `ChainOfThought` alias — where a
+     * badge per step would shout.
+     */
+    hideBadge?: boolean;
+    /** Rich detail under the node (e.g. a `ToolDetails` disclosure, results). */
+    children?: ReactNode;
+}
+/**
+ * One executed/executing step: icon + name + `StatusBadge` + business
+ * summary, with composed children for detail. Memoized for long transcripts
+ * (research 10 §G.6).
+ */
+declare const AgentStep: react.NamedExoticComponent<AgentStepProps & react.RefAttributes<HTMLLIElement>>;
+
+type ArtifactProps = HTMLAttributes<HTMLDivElement> & {
+    /**
+     * The artifact body has not arrived yet (loading-states.md loading signal).
+     * ArtifactContent renders a layout-shaped skeleton instead of its
+     * children; ArtifactHeader/ArtifactTitle keep rendering as passed.
+     * @default false
+     */
+    loading?: boolean;
+};
+declare const Artifact: ({ className, loading, children, ...props }: ArtifactProps) => react.JSX.Element;
+type ArtifactHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const ArtifactHeader: ({ className, ...props }: ArtifactHeaderProps) => react.JSX.Element;
+type ArtifactCloseProps = ComponentProps<typeof Button>;
+declare const ArtifactClose: ({ className, children, size, variant, ...props }: ArtifactCloseProps) => react.JSX.Element;
+type ArtifactTitleProps = HTMLAttributes<HTMLParagraphElement>;
+declare const ArtifactTitle: ({ className, ...props }: ArtifactTitleProps) => react.JSX.Element;
+type ArtifactDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+declare const ArtifactDescription: ({ className, ...props }: ArtifactDescriptionProps) => react.JSX.Element;
+type ArtifactActionsProps = HTMLAttributes<HTMLDivElement>;
+declare const ArtifactActions: ({ className, ...props }: ArtifactActionsProps) => react.JSX.Element;
+type ArtifactActionProps = ComponentProps<typeof Button> & {
+    tooltip?: string;
+    label?: string;
+    icon?: LucideIcon;
+};
+declare const ArtifactAction: ({ tooltip, label, icon: Icon, children, className, size, variant, ...props }: ArtifactActionProps) => react.JSX.Element;
+type ArtifactContentProps = HTMLAttributes<HTMLDivElement>;
+declare const ArtifactContent: ({ className, children, ...props }: ArtifactContentProps) => react.JSX.Element;
+
+/** Closed asset-type enum shared by the tree (`ProducedAssetTree`) and the preview (`AssetPreview`). */
+type ContextAssetType = "markdown" | "code" | "sql" | "csv" | "image";
+/** One produced asset — the unit the drill-in focuses (research 09 §B.1). */
+interface ContextAsset {
+    id: string;
+    name: string;
+    path?: string;
+    type: ContextAssetType;
+    /** Inline content: source text — or, for `image`, the image src URL. */
+    content?: string;
+    /** Optional Shiki language for `code` assets (defaults to "typescript"). */
+    language?: string;
+    /**
+     * The file itself, when the asset IS one — a `File`, a `Blob`, a URL, a
+     * buffer. Carried so a `renderPreview` injection (below) can hand it to
+     * something that opens files, such as `@elabs-ai/components-viewer`'s
+     * `FileViewer`, without the asset first being turned into a string.
+     *
+     * `ContextAssetType` is deliberately NOT widened to cover PDFs, Office files
+     * or video: this union describes what THIS package can draw, and every format
+     * beyond it arrives through the injection seam rather than by growing a case
+     * per format here (ADR 0024 §6).
+     */
+    source?: FileSource;
+    /** MIME type, when known — helps a renderer that detects by media type. */
+    mediaType?: string;
+}
+/**
+ * Draw the body of an asset preview.
+ *
+ * Return `null` to decline and let `AssetPreview` fall through to its own
+ * type-keyed rendering, which is what makes this additive: an injection that
+ * handles PDFs only leaves markdown, code and CSV exactly as they were.
+ */
+type AssetPreviewRenderer = (asset: ContextAsset) => ReactNode | null;
+type ContextPanelView = "root" | "detail";
+interface ContextPanelContextValue {
+    /** Lifted state (doc-13 `state` / `actions` / `meta` interface). */
+    state: {
+        open: boolean;
+        view: ContextPanelView;
+        selectedAsset: ContextAsset | null;
+    };
+    actions: {
+        /** Toggle the panel (the inline collapse on desktop, the Sheet on mobile). */
+        toggle: () => void;
+        setOpen: (open: boolean | ((open: boolean) => boolean)) => void;
+        /** Drill into one asset (root → detail). Focus moves to the BACK control. */
+        openDetail: (asset: ContextAsset) => void;
+        /** Return to the root view; focus is restored to the originating row. */
+        back: () => void;
+    };
+    meta: {
+        isMobile: boolean;
+        openMobile: boolean;
+        setOpenMobile: (open: boolean) => void;
+        /**
+         * The injected preview renderer, if the provider was given one.
+         * `AssetPreview` reads it from here so a page can teach the whole rail a
+         * new format in one place instead of at every call site.
+         */
+        renderPreview?: AssetPreviewRenderer;
+    };
+}
+declare function useContextPanel(): ContextPanelContextValue;
+/**
+ * The renderer injected into the surrounding `ContextPanelProvider`, if any.
+ *
+ * Unlike `useContextPanel()` this does NOT throw outside a provider:
+ * `AssetPreview` is usable on its own (a preview pane in a page, a story), and
+ * "no provider" simply means nobody injected anything.
+ */
+declare function useAssetPreviewRenderer(): AssetPreviewRenderer | undefined;
+interface ContextPanelProviderProps {
+    children: ReactNode;
+    /** Uncontrolled initial open state. Default `true`. */
+    defaultOpen?: boolean;
+    /** Controlled open state (`isControlled = open !== undefined`, never flips). */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled view (root ↔ detail). */
+    view?: ContextPanelView;
+    onViewChange?: (view: ContextPanelView) => void;
+    /** Uncontrolled initial view. Default `"root"`. */
+    defaultView?: ContextPanelView;
+    /** Controlled selected asset. */
+    selectedAsset?: ContextAsset | null;
+    onSelectedAssetChange?: (asset: ContextAsset | null) => void;
+    /** Uncontrolled initial selected asset. Default `null`. */
+    defaultSelectedAsset?: ContextAsset | null;
+    /**
+     * Draw an asset's preview body yourself.
+     *
+     * The seam that lets this package show formats it cannot parse — a PDF, a
+     * spreadsheet, a video — without importing a domain sibling
+     * (`@elabs-ai/components-ai` and
+     * `@elabs-ai/components-viewer` are peers in the layer graph and
+     * may never import each other). The consuming app owns the edge:
+     *
+     * ```tsx
+     * <ContextPanelProvider
+     *   renderPreview={(asset) =>
+     *     asset.source ? <FileViewer source={asset.source} /> : null
+     *   }
+     * >
+     * ```
+     *
+     * Return `null` to decline, and the built-in type-keyed rendering runs
+     * exactly as before — so an injection is additive, never a replacement.
+     */
+    renderPreview?: AssetPreviewRenderer;
+}
+/**
+ * Lifts the panel state above the workspace so siblings outside the panel's
+ * frame (the app-header trigger) can read/drive it — no prop-drilling, no
+ * page-level `useState`, no conditional mount (research 09 §B.1/§C.2).
+ */
+declare function ContextPanelProvider({ children, defaultOpen, open: openProp, onOpenChange, view: viewProp, onViewChange, defaultView, selectedAsset: selectedAssetProp, onSelectedAssetChange, defaultSelectedAsset, renderPreview, }: ContextPanelProviderProps): react.JSX.Element;
+interface ContextPanelProps extends ComponentProps<"div"> {
+    /** Expanded panel width (any CSS length). Default `"20rem"`. */
+    width?: string;
+}
+/**
+ * The always-mounted shell. On desktop it animates its OWN width via the
+ * canonical `useCollapsiblePanel` two-element tween — bounded to the SHELL
+ * (a relative group + absolute container), not the viewport (09 §B.2). Below
+ * the mobile breakpoint it renders a `Sheet side="right"` with the same
+ * children, driven by the same provider (09 §B.4).
+ */
+declare const ContextPanel: react.ForwardRefExoticComponent<Omit<ContextPanelProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type ContextPanelTriggerProps = ComponentProps<typeof Button>;
+/** Toggle button — placeable ANYWHERE inside the provider (e.g. the app header). */
+declare const ContextPanelTrigger: react.ForwardRefExoticComponent<Omit<_elabs_ai_components_ui.ButtonProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+interface ContextPanelHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Root-view title. Default `"Context"`. */
+    title?: ReactNode;
+}
+/**
+ * Title row. In the detail view it hosts the BACK control (a real button —
+ * "tab-panel swap", not a breadcrumb) and shows the focused asset's name.
+ */
+declare const ContextPanelHeader: react.ForwardRefExoticComponent<ContextPanelHeaderProps & react.RefAttributes<HTMLDivElement>>;
+interface ContextPanelBodyProps extends HTMLAttributes<HTMLDivElement> {
+    /** Root view — the labelled sections (status / grounding / produced assets). */
+    root: ReactNode;
+    /** Detail view — typically `<ContextPanelDetail><AssetPreview …/></ContextPanelDetail>`. */
+    detail: ReactNode;
+    /** Accessible name of the region. Default `"Context"`. */
+    label?: string;
+}
+/**
+ * The two-view container that owns the drill-in. v1: a CSS-gated two-pane
+ * translateX track (both panes mounted, transform-only, `duration-base` +
+ * explicit `motion-reduce:` neutralizer). The off-screen pane is `aria-hidden`
+ * AND `inert` so Tab can't land in it mid-slide (09 §B.3/§B.5). The panes'
+ * `data-vt-pane` identities are the v2 `useViewTransition` seam.
+ */
+declare const ContextPanelBody: react.ForwardRefExoticComponent<ContextPanelBodyProps & react.RefAttributes<HTMLDivElement>>;
+interface ContextPanelSectionProps extends HTMLAttributes<HTMLElement> {
+    /** Section label — a quiet `text-meta` heading, not a box (research 08). */
+    label?: ReactNode;
+}
+/** A labelled root-view section (status / grounding / produced assets). */
+declare const ContextPanelSection: react.ForwardRefExoticComponent<ContextPanelSectionProps & react.RefAttributes<HTMLElement>>;
+type ContextPanelDetailProps = HTMLAttributes<HTMLDivElement>;
+/** The focused single-asset view — hosts `<AssetPreview>` (research 04 §5). */
+declare const ContextPanelDetail: react.ForwardRefExoticComponent<ContextPanelDetailProps & react.RefAttributes<HTMLDivElement>>;
+
+type AssetPreviewMode = "preview" | "raw";
+interface AssetPreviewProps extends HTMLAttributes<HTMLDivElement> {
+    asset: ContextAsset;
+    /** Initial mode. Default `"preview"`. */
+    defaultMode?: AssetPreviewMode;
+    /**
+     * Draw this asset's preview body yourself; return `null` to decline and get
+     * the built-in rendering. Wins over a renderer injected on
+     * `ContextPanelProvider`, so one rail-wide default can still be overridden
+     * for a single preview.
+     */
+    renderPreview?: AssetPreviewRenderer;
+}
+declare const AssetPreview: ({ asset, defaultMode, renderPreview, className, ...props }: AssetPreviewProps) => react.JSX.Element;
+
+type AttachmentData = (FileUIPart & {
+    id: string;
+}) | (SourceDocumentUIPart & {
+    id: string;
+});
+type AttachmentMediaCategory = "image" | "video" | "audio" | "document" | "source" | "unknown";
+type AttachmentVariant = "grid" | "inline" | "list";
+declare const getMediaCategory: (data: AttachmentData) => AttachmentMediaCategory;
+declare const getAttachmentLabel: (data: AttachmentData) => string;
+interface AttachmentsContextValue {
+    variant: AttachmentVariant;
+}
+interface AttachmentContextValue {
+    data: AttachmentData;
+    mediaCategory: AttachmentMediaCategory;
+    onRemove?: () => void;
+    variant: AttachmentVariant;
+}
+declare const useAttachmentsContext: () => AttachmentsContextValue;
+declare const useAttachmentContext: () => AttachmentContextValue;
+type AttachmentsProps = HTMLAttributes<HTMLDivElement> & {
+    variant?: AttachmentVariant;
+};
+declare const Attachments: ({ variant, className, children, ...props }: AttachmentsProps) => react.JSX.Element;
+type AttachmentProps = HTMLAttributes<HTMLDivElement> & {
+    data: AttachmentData;
+    onRemove?: () => void;
+};
+declare const Attachment: ({ data, onRemove, className, children, ...props }: AttachmentProps) => react.JSX.Element;
+type AttachmentPreviewProps = HTMLAttributes<HTMLDivElement> & {
+    fallbackIcon?: ReactNode;
+};
+declare const AttachmentPreview: ({ fallbackIcon, className, ...props }: AttachmentPreviewProps) => react.JSX.Element;
+type AttachmentInfoProps = HTMLAttributes<HTMLDivElement> & {
+    showMediaType?: boolean;
+};
+declare const AttachmentInfo: ({ showMediaType, className, ...props }: AttachmentInfoProps) => react.JSX.Element | null;
+type AttachmentRemoveProps = ComponentProps<typeof Button> & {
+    label?: string;
+};
+declare const AttachmentRemove: ({ label, className, children, ...props }: AttachmentRemoveProps) => react.JSX.Element | null;
+type AttachmentHoverCardProps = ComponentProps<typeof HoverCard>;
+declare const AttachmentHoverCard: ({ openDelay, closeDelay, ...props }: AttachmentHoverCardProps) => react.JSX.Element;
+type AttachmentHoverCardTriggerProps = ComponentProps<typeof HoverCardTrigger>;
+declare const AttachmentHoverCardTrigger: (props: AttachmentHoverCardTriggerProps) => react.JSX.Element;
+type AttachmentHoverCardContentProps = ComponentProps<typeof HoverCardContent>;
+declare const AttachmentHoverCardContent: ({ align, className, ...props }: AttachmentHoverCardContentProps) => react.JSX.Element;
+type AttachmentEmptyProps = HTMLAttributes<HTMLDivElement>;
+declare const AttachmentEmpty: ({ className, children, ...props }: AttachmentEmptyProps) => react.JSX.Element;
+
+type AudioPlayerProps = Omit<ComponentProps<typeof MediaController>, "audio">;
+declare const AudioPlayer: ({ className, ...props }: AudioPlayerProps) => react.JSX.Element;
+type AudioPlayerElementProps = Omit<ComponentProps<"audio">, "src"> & ({
+    data: Experimental_SpeechResult["audio"];
+} | {
+    src: string;
+});
+declare const AudioPlayerElement: ({ ...props }: AudioPlayerElementProps) => react.JSX.Element;
+type AudioPlayerControlBarProps = ComponentProps<typeof MediaControlBar>;
+declare const AudioPlayerControlBar: (props: AudioPlayerControlBarProps) => react.JSX.Element;
+type AudioPlayerPlayButtonProps = ComponentProps<typeof MediaPlayButton>;
+declare const AudioPlayerPlayButton: (props: AudioPlayerPlayButtonProps) => react.JSX.Element;
+type AudioPlayerSeekBackwardButtonProps = ComponentProps<typeof MediaSeekBackwardButton>;
+declare const AudioPlayerSeekBackwardButton: (props: AudioPlayerSeekBackwardButtonProps) => react.JSX.Element;
+type AudioPlayerSeekForwardButtonProps = ComponentProps<typeof MediaSeekForwardButton>;
+declare const AudioPlayerSeekForwardButton: (props: AudioPlayerSeekForwardButtonProps) => react.JSX.Element;
+type AudioPlayerTimeDisplayProps = ComponentProps<typeof MediaTimeDisplay>;
+declare const AudioPlayerTimeDisplay: (props: AudioPlayerTimeDisplayProps) => react.JSX.Element;
+type AudioPlayerTimeRangeProps = ComponentProps<typeof MediaTimeRange>;
+declare const AudioPlayerTimeRange: (props: AudioPlayerTimeRangeProps) => react.JSX.Element;
+type AudioPlayerDurationDisplayProps = ComponentProps<typeof MediaDurationDisplay>;
+declare const AudioPlayerDurationDisplay: (props: AudioPlayerDurationDisplayProps) => react.JSX.Element;
+type AudioPlayerMuteButtonProps = ComponentProps<typeof MediaMuteButton>;
+declare const AudioPlayerMuteButton: (props: AudioPlayerMuteButtonProps) => react.JSX.Element;
+type AudioPlayerVolumeRangeProps = ComponentProps<typeof MediaVolumeRange>;
+declare const AudioPlayerVolumeRange: (props: AudioPlayerVolumeRangeProps) => react.JSX.Element;
+
+type CanvasProps = ReactFlowProps & {
+    children?: ReactNode;
+};
+declare const Canvas: ({ className, ...props }: CanvasProps) => react.JSX.Element;
+
+type ChainOfThoughtProps = ComponentProps<"div"> & {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare const ChainOfThought: react.MemoExoticComponent<({ className, open, defaultOpen, onOpenChange, children, ...props }: ChainOfThoughtProps) => react.JSX.Element>;
+type ChainOfThoughtHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+declare const ChainOfThoughtHeader: react.MemoExoticComponent<({ className, children, ...props }: ChainOfThoughtHeaderProps) => react.JSX.Element>;
+type ChainOfThoughtStepProps = Omit<AgentStepProps, "name" | "summary" | "status" | "hideBadge"> & {
+    label: ReactNode;
+    description?: ReactNode;
+    status?: "complete" | "active" | "pending";
+};
+/**
+ * @deprecated Compose `AgentStep` (agent-timeline.tsx) directly. Since #192
+ * this is a thin alias mapping the legacy `label`/`description`/3-state
+ * `status` props onto the canonical rail (`AgentTimeline` + `AgentStep`); the
+ * pre-#192 hand-rolled connector + text-opacity status idiom is gone
+ * (research 10 §B.3). The badge stays hidden here — the rail node carries the
+ * status — keeping the quiet prose-rail look.
+ */
+declare const ChainOfThoughtStep: react.MemoExoticComponent<({ label, description, status, ...props }: ChainOfThoughtStepProps) => react.JSX.Element>;
+type ChainOfThoughtSearchResultsProps = ComponentProps<"div">;
+declare const ChainOfThoughtSearchResults: react.MemoExoticComponent<({ className, ...props }: ChainOfThoughtSearchResultsProps) => react.JSX.Element>;
+type ChainOfThoughtSearchResultProps = ComponentProps<typeof Badge>;
+declare const ChainOfThoughtSearchResult: react.MemoExoticComponent<({ className, children, ...props }: ChainOfThoughtSearchResultProps) => react.JSX.Element>;
+type ChainOfThoughtContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const ChainOfThoughtContent: react.MemoExoticComponent<({ className, children, ...props }: ChainOfThoughtContentProps) => react.JSX.Element>;
+type ChainOfThoughtImageProps = ComponentProps<"div"> & {
+    caption?: string;
+};
+declare const ChainOfThoughtImage: react.MemoExoticComponent<({ className, children, caption, ...props }: ChainOfThoughtImageProps) => react.JSX.Element>;
+
+interface ChatGreetingProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Primary line, e.g. "Good morning, Avery". */
+    title: ReactNode;
+    /**
+     * Second line, rendered under `title` inside the same heading. Independent
+     * of `accent` — either may be passed alone.
+     */
+    subtitle?: ReactNode;
+    /**
+     * Phrase rendered in `text-primary-text` with a bold underline, appended
+     * after `subtitle` (or alone). The underline + weight is a NON-hue channel
+     * deliberately layered on top of the color — a monochrome theme's `--primary`
+     * can be a near-white "pen" by design, in which case the accent colour alone
+     * is indistinguishable from the surrounding `--foreground` headline text. The
+     * underline/weight keep the phrase legible as an accent in EVERY theme,
+     * not only the two where hue alone would carry it.
+     */
+    accent?: ReactNode;
+    /** Soft primary glow behind the headline. Default `true`; `false` for dense/embedded use. */
+    orb?: boolean;
+    /**
+     * Semantic heading level for `title`. Default `1` (a chat empty state is
+     * typically the only heading on the page). Override to `2`+ when ChatGreeting
+     * sits inside a page or route that already renders its own `<h1>` —
+     * `Heading` decouples `level` from `size`, so the visual display-scale rung
+     * stays put regardless of the level chosen.
+     */
+    level?: HeadingLevel;
+}
+/**
+ * ChatGreeting — the centered first-run greeting for an empty chat/composer scene.
+ *
+ * A display-scale headline (`title`, then `subtitle` with an `accent` phrase
+ * in `text-primary-text` + a bold underline, so the accent reads in every theme,
+ * including a monochrome one whose `--primary` is otherwise the same
+ * near-white as the headline) over an optional soft primary glow. Pair it
+ * with `<Composer />` for the standard empty/first-run chat state.
+ *
+ * Distinct from `ConversationEmptyState` (a generic centered "No messages yet"
+ * message panel) — this is the display-scale greeting anatomy, not a status
+ * message.
+ */
+declare const ChatGreeting: react.ForwardRefExoticComponent<ChatGreetingProps & react.RefAttributes<HTMLDivElement>>;
+
+type CheckpointProps = HTMLAttributes<HTMLDivElement>;
+declare const Checkpoint: ({ className, children, ...props }: CheckpointProps) => react.JSX.Element;
+type CheckpointIconProps = LucideProps;
+declare const CheckpointIcon: ({ className, children, ...props }: CheckpointIconProps) => string | number | bigint | boolean | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react.JSX.Element;
+type CheckpointTriggerProps = ComponentProps<typeof Button> & {
+    tooltip?: string;
+};
+declare const CheckpointTrigger: ({ children, variant, size, tooltip, ...props }: CheckpointTriggerProps) => react.JSX.Element;
+
+type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
+    code: string;
+    language: BundledLanguage;
+    showLineNumbers?: boolean;
+    /**
+     * Soft-wrap long lines instead of scrolling horizontally. Use in narrow embeds
+     * (e.g. a side rail) so content is not silently clipped. Default: false.
+     */
+    wrap?: boolean;
+    /**
+     * code is arriving incrementally (loading-states.md isStreaming) — code
+     * keeps rendering progressively (build-up), NOT a skeleton, since a
+     * streaming code block is not fetch-then-show. Shows a Shimmer generating
+     * cue below the content as the in-progress affordance.
+     * @default false
+     */
+    isStreaming?: boolean;
+};
+interface TokenizedCode {
+    tokens: ThemedToken[][];
+    fg: string;
+    bg: string;
+}
+declare const highlightCode: (code: string, language: BundledLanguage, callback?: (result: TokenizedCode) => void, el?: Element | null) => TokenizedCode | null;
+declare const CodeBlockContainer: ({ className, language, style, ...props }: HTMLAttributes<HTMLDivElement> & {
+    language: string;
+}) => react.JSX.Element;
+declare const CodeBlockHeader: ({ children, className, ...props }: HTMLAttributes<HTMLDivElement>) => react.JSX.Element;
+declare const CodeBlockTitle: ({ children, className, ...props }: HTMLAttributes<HTMLDivElement>) => react.JSX.Element;
+declare const CodeBlockFilename: ({ children, className, ...props }: HTMLAttributes<HTMLSpanElement>) => react.JSX.Element;
+declare const CodeBlockActions: ({ children, className, ...props }: HTMLAttributes<HTMLDivElement>) => react.JSX.Element;
+declare const CodeBlockContent: ({ code, language, showLineNumbers, wrap, }: {
+    code: string;
+    language: BundledLanguage;
+    showLineNumbers?: boolean;
+    wrap?: boolean;
+}) => react.JSX.Element;
+declare const CodeBlock: ({ code, language, showLineNumbers, wrap, isStreaming, className, children, ...props }: CodeBlockProps) => react.JSX.Element;
+type CodeBlockCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+declare const CodeBlockCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: CodeBlockCopyButtonProps) => react.JSX.Element;
+type CodeBlockLanguageSelectorProps = ComponentProps<typeof Select>;
+declare const CodeBlockLanguageSelector: (props: CodeBlockLanguageSelectorProps) => react.JSX.Element;
+type CodeBlockLanguageSelectorTriggerProps = ComponentProps<typeof SelectTrigger>;
+declare const CodeBlockLanguageSelectorTrigger: ({ className, ...props }: CodeBlockLanguageSelectorTriggerProps) => react.JSX.Element;
+type CodeBlockLanguageSelectorValueProps = ComponentProps<typeof SelectValue>;
+declare const CodeBlockLanguageSelectorValue: (props: CodeBlockLanguageSelectorValueProps) => react.JSX.Element;
+type CodeBlockLanguageSelectorContentProps = ComponentProps<typeof SelectContent>;
+declare const CodeBlockLanguageSelectorContent: ({ align, ...props }: CodeBlockLanguageSelectorContentProps) => react.JSX.Element;
+type CodeBlockLanguageSelectorItemProps = ComponentProps<typeof SelectItem>;
+declare const CodeBlockLanguageSelectorItem: (props: CodeBlockLanguageSelectorItemProps) => react.JSX.Element;
+
+type CommitProps = ComponentProps<typeof Collapsible>;
+declare const Commit: ({ className, children, ...props }: CommitProps) => react.JSX.Element;
+type CommitHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+declare const CommitHeader: ({ className, children, ...props }: CommitHeaderProps) => react.JSX.Element;
+type CommitHashProps = HTMLAttributes<HTMLSpanElement>;
+declare const CommitHash: ({ className, children, ...props }: CommitHashProps) => react.JSX.Element;
+type CommitMessageProps = HTMLAttributes<HTMLSpanElement>;
+declare const CommitMessage: ({ className, children, ...props }: CommitMessageProps) => react.JSX.Element;
+type CommitMetadataProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitMetadata: ({ className, children, ...props }: CommitMetadataProps) => react.JSX.Element;
+type CommitSeparatorProps = HTMLAttributes<HTMLSpanElement>;
+declare const CommitSeparator: ({ className, children, ...props }: CommitSeparatorProps) => react.JSX.Element;
+type CommitInfoProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitInfo: ({ className, children, ...props }: CommitInfoProps) => react.JSX.Element;
+type CommitAuthorProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitAuthor: ({ className, children, ...props }: CommitAuthorProps) => react.JSX.Element;
+type CommitAuthorAvatarProps = ComponentProps<typeof Avatar> & {
+    initials: string;
+};
+declare const CommitAuthorAvatar: ({ initials, className, ...props }: CommitAuthorAvatarProps) => react.JSX.Element;
+type CommitTimestampProps = HTMLAttributes<HTMLTimeElement> & {
+    date: Date;
+};
+declare const CommitTimestamp: ({ date, className, children, ...props }: CommitTimestampProps) => react.JSX.Element;
+type CommitActionsProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitActions: ({ className, children, ...props }: CommitActionsProps) => react.JSX.Element;
+type CommitCopyButtonProps = ComponentProps<typeof Button> & {
+    hash: string;
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+declare const CommitCopyButton: ({ hash, onCopy, onError, timeout, children, className, ...props }: CommitCopyButtonProps) => react.JSX.Element;
+type CommitContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const CommitContent: ({ className, children, ...props }: CommitContentProps) => react.JSX.Element;
+type CommitFilesProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitFiles: ({ className, children, ...props }: CommitFilesProps) => react.JSX.Element;
+type CommitFileProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitFile: ({ className, children, ...props }: CommitFileProps) => react.JSX.Element;
+type CommitFileInfoProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitFileInfo: ({ className, children, ...props }: CommitFileInfoProps) => react.JSX.Element;
+type CommitFileStatusProps = HTMLAttributes<HTMLSpanElement> & {
+    status: "added" | "modified" | "deleted" | "renamed";
+};
+declare const CommitFileStatus: ({ status, className, children, ...props }: CommitFileStatusProps) => react.JSX.Element;
+type CommitFileIconProps = ComponentProps<typeof FileIcon>;
+declare const CommitFileIcon: ({ className, ...props }: CommitFileIconProps) => react.JSX.Element;
+type CommitFilePathProps = HTMLAttributes<HTMLSpanElement>;
+declare const CommitFilePath: ({ className, children, ...props }: CommitFilePathProps) => react.JSX.Element;
+type CommitFileChangesProps = HTMLAttributes<HTMLDivElement>;
+declare const CommitFileChanges: ({ className, children, ...props }: CommitFileChangesProps) => react.JSX.Element;
+type CommitFileAdditionsProps = HTMLAttributes<HTMLSpanElement> & {
+    count: number;
+};
+declare const CommitFileAdditions: ({ count, className, children, ...props }: CommitFileAdditionsProps) => react.JSX.Element | null;
+type CommitFileDeletionsProps = HTMLAttributes<HTMLSpanElement> & {
+    count: number;
+};
+declare const CommitFileDeletions: ({ count, className, children, ...props }: CommitFileDeletionsProps) => react.JSX.Element | null;
+
+interface AttachmentsContext {
+    files: (FileUIPart & {
+        id: string;
+    })[];
+    add: (files: File[] | FileList) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    openFileDialog: () => void;
+    fileInputRef: RefObject<HTMLInputElement | null>;
+}
+interface TextInputContext {
+    value: string;
+    setInput: (v: string) => void;
+    clear: () => void;
+}
+interface PromptInputControllerProps {
+    textInput: TextInputContext;
+    attachments: AttachmentsContext;
+    /** INTERNAL: Allows PromptInput to register its file textInput + "open" callback */
+    __registerFileInput: (ref: RefObject<HTMLInputElement | null>, open: () => void) => void;
+}
+declare const usePromptInputController: () => PromptInputControllerProps;
+declare const useProviderAttachments: () => AttachmentsContext;
+type PromptInputProviderProps = PropsWithChildren<{
+    initialInput?: string;
+}>;
+/**
+ * Optional global provider that lifts PromptInput state outside of PromptInput.
+ * If you don't use it, PromptInput stays fully self-managed.
+ */
+declare const PromptInputProvider: ({ initialInput: initialTextInput, children, }: PromptInputProviderProps) => react.JSX.Element;
+declare const usePromptInputAttachments: () => AttachmentsContext;
+interface ReferencedSourcesContext {
+    sources: (SourceDocumentUIPart & {
+        id: string;
+    })[];
+    add: (sources: SourceDocumentUIPart[] | SourceDocumentUIPart) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+}
+declare const LocalReferencedSourcesContext: react.Context<ReferencedSourcesContext | null>;
+declare const usePromptInputReferencedSources: () => ReferencedSourcesContext;
+type PromptInputActionAddAttachmentsProps = ComponentProps<typeof DropdownMenuItem> & {
+    label?: string;
+};
+declare const PromptInputActionAddAttachments: ({ label, ...props }: PromptInputActionAddAttachmentsProps) => react.JSX.Element;
+type PromptInputActionAddScreenshotProps = ComponentProps<typeof DropdownMenuItem> & {
+    label?: string;
+};
+declare const PromptInputActionAddScreenshot: ({ label, onSelect, ...props }: PromptInputActionAddScreenshotProps) => react.JSX.Element;
+interface PromptInputMessage {
+    text: string;
+    files: FileUIPart[];
+}
+type PromptInputProps = Omit<HTMLAttributes<HTMLFormElement>, "onSubmit" | "onError"> & {
+    accept?: string;
+    multiple?: boolean;
+    globalDrop?: boolean;
+    syncHiddenInput?: boolean;
+    maxFiles?: number;
+    maxFileSize?: number;
+    /**
+     * The fill of the inner well (the `InputGroup` `variant`). `"surface"`
+     * (default) is the standard muted composer look; `"card"` renders a
+     * `bg-card` well for nesting inside an already-tinted outer frame — the
+     * "double card" look (#254). e.g.
+     * `<div className="rounded-xl bg-surface-muted p-1.5"><PromptInput tone="card">…</PromptInput></div>`.
+     * The well fill is NOT universally "white": `--card` reads lighter
+     * (raised) than `--surface-muted` on light themes, but darker (recessed) on
+     * dark — the same theme-dependent trade-off documented
+     * for `bg-surface-muted`-as-a-well in `styling-and-tokens.md`. The well
+     * stays a legible, distinct tone against the outer frame in every theme;
+     * only the "raised" framing is light-themes-specific.
+     */
+    tone?: "surface" | "card";
+    onError?: (err: {
+        code: "max_files" | "max_file_size" | "accept";
+        message: string;
+    }) => void;
+    onSubmit: (message: PromptInputMessage, event: FormEvent<HTMLFormElement>) => void | Promise<void>;
+    /**
+     * Classes for the inner surface (the visible `InputGroup` well), e.g. to shape
+     * its corners. `className` styles the outer `<form>`; this styles the well —
+     * the only way to reach it from outside (used by `Composer`).
+     */
+    surfaceClassName?: string;
+};
+declare const PromptInput: ({ className, surfaceClassName, tone, accept, multiple, globalDrop, syncHiddenInput, maxFiles, maxFileSize, onError, onSubmit, children, ...props }: PromptInputProps) => react.JSX.Element;
+type PromptInputBodyProps = HTMLAttributes<HTMLDivElement>;
+declare const PromptInputBody: ({ className, ...props }: PromptInputBodyProps) => react.JSX.Element;
+type PromptInputTextareaProps = ComponentProps<typeof InputGroupTextarea>;
+declare const PromptInputTextarea: ({ onChange, onKeyDown, className, placeholder, ...props }: PromptInputTextareaProps) => react.JSX.Element;
+type PromptInputHeaderProps = Omit<ComponentProps<typeof InputGroupAddon>, "align">;
+declare const PromptInputHeader: ({ className, ...props }: PromptInputHeaderProps) => react.JSX.Element;
+type PromptInputFooterProps = Omit<ComponentProps<typeof InputGroupAddon>, "align">;
+declare const PromptInputFooter: ({ className, ...props }: PromptInputFooterProps) => react.JSX.Element;
+type PromptInputToolsProps = HTMLAttributes<HTMLDivElement>;
+declare const PromptInputTools: ({ className, ...props }: PromptInputToolsProps) => react.JSX.Element;
+type PromptInputButtonTooltip = string | {
+    content: ReactNode;
+    shortcut?: string;
+    side?: ComponentProps<typeof TooltipContent>["side"];
+};
+type PromptInputButtonProps = ComponentProps<typeof InputGroupButton> & {
+    tooltip?: PromptInputButtonTooltip;
+};
+declare const PromptInputButton: ({ variant, className, size, tooltip, "aria-label": ariaLabelProp, ...props }: PromptInputButtonProps) => react.JSX.Element;
+type PromptInputActionMenuProps = ComponentProps<typeof DropdownMenu>;
+declare const PromptInputActionMenu: (props: PromptInputActionMenuProps) => react.JSX.Element;
+type PromptInputActionMenuTriggerProps = PromptInputButtonProps;
+declare const PromptInputActionMenuTrigger: ({ className, children, ...props }: PromptInputActionMenuTriggerProps) => react.JSX.Element;
+type PromptInputActionMenuContentProps = ComponentProps<typeof DropdownMenuContent>;
+declare const PromptInputActionMenuContent: ({ className, ...props }: PromptInputActionMenuContentProps) => react.JSX.Element;
+type PromptInputActionMenuItemProps = ComponentProps<typeof DropdownMenuItem>;
+declare const PromptInputActionMenuItem: ({ className, ...props }: PromptInputActionMenuItemProps) => react.JSX.Element;
+/**
+ * Which action the merged primary control currently performs (#351). The
+ * component owns the AFFORDANCE only — it always invokes `onSubmit` (via the
+ * normal form submit) once the action is "send", never `onStop`. What a
+ * mid-turn submit MEANS (queued, interleaved, dropped) is entirely up to the
+ * app's own `onSubmit`/runtime — brand-ui asserts nothing about that (D5).
+ */
+type PromptInputSubmitAction = "send" | "stop";
+type PromptInputSubmitProps = ComponentProps<typeof InputGroupButton> & {
+    status?: ChatStatus;
+    onStop?: () => void;
+    /**
+     * Glyph for the SEND action only — survives the send↔stop flip, so a
+     * consumer's resting glyph (e.g. `Composer`'s circular arrow) is no longer
+     * lost while generating with a non-empty composer. Prefer this over
+     * `children`.
+     */
+    sendIcon?: ReactNode;
+    /**
+     * @deprecated Replaces the glyph for **every** status — ready, submitted,
+     * streaming AND error — which is why generating/error affordances can
+     * disappear even though the control is still live. Prefer `sendIcon`,
+     * which only ever replaces the resting Send glyph.
+     */
+    children?: ReactNode;
+};
+/**
+ * Merged primary-action contract (#351):
+ *   1. `ready`/`undefined`/`error` → **Send** (unchanged).
+ *   2. `submitted`/`streaming` + composer EMPTY → **Stop** (unchanged).
+ *   3. `submitted`/`streaming` + composer NON-EMPTY → **Send** (the fix — a
+ *      follow-up can always be composed and submitted mid-turn).
+ *   4. A `PromptInputStop` mounted alongside → this control is ALWAYS Send;
+ *      the dedicated control owns stopping (the composed "separate" shape).
+ */
+declare const PromptInputSubmit: ({ className, variant, size, status, onStop, onClick, children, sendIcon, disabled, ...props }: PromptInputSubmitProps) => react.JSX.Element;
+type PromptInputStopProps = ComponentProps<typeof InputGroupButton> & {
+    status?: ChatStatus;
+    onStop: () => void;
+    /** Glyph override; defaults to a square Stop icon. */
+    children?: ReactNode;
+};
+/**
+ * A dedicated Stop control — the composed answer to "two buttons" (#351;
+ * never a `mode` prop, per `component-api.md`'s ban on behavioural-mode
+ * props). Renders `null` unless the turn is running (`status` is `submitted`
+ * or `streaming`). While at least one `PromptInputStop` is mounted inside the
+ * same `PromptInput`, `PromptInputSubmit` stays the Send action in every
+ * state — the dedicated control owns stopping instead.
+ */
+declare const PromptInputStop: ({ className, variant, size, status, onStop, onClick, children, ...props }: PromptInputStopProps) => react.JSX.Element | null;
+type PromptInputSelectProps = ComponentProps<typeof Select>;
+declare const PromptInputSelect: (props: PromptInputSelectProps) => react.JSX.Element;
+type PromptInputSelectTriggerProps = ComponentProps<typeof SelectTrigger>;
+declare const PromptInputSelectTrigger: ({ className, ...props }: PromptInputSelectTriggerProps) => react.JSX.Element;
+type PromptInputSelectContentProps = ComponentProps<typeof SelectContent>;
+declare const PromptInputSelectContent: ({ className, ...props }: PromptInputSelectContentProps) => react.JSX.Element;
+type PromptInputSelectItemProps = ComponentProps<typeof SelectItem>;
+declare const PromptInputSelectItem: ({ className, ...props }: PromptInputSelectItemProps) => react.JSX.Element;
+type PromptInputSelectValueProps = ComponentProps<typeof SelectValue>;
+declare const PromptInputSelectValue: ({ className, ...props }: PromptInputSelectValueProps) => react.JSX.Element;
+type PromptInputHoverCardProps = ComponentProps<typeof HoverCard>;
+declare const PromptInputHoverCard: ({ openDelay, closeDelay, ...props }: PromptInputHoverCardProps) => react.JSX.Element;
+type PromptInputHoverCardTriggerProps = ComponentProps<typeof HoverCardTrigger>;
+declare const PromptInputHoverCardTrigger: (props: PromptInputHoverCardTriggerProps) => react.JSX.Element;
+type PromptInputHoverCardContentProps = ComponentProps<typeof HoverCardContent>;
+declare const PromptInputHoverCardContent: ({ align, ...props }: PromptInputHoverCardContentProps) => react.JSX.Element;
+type PromptInputTabsListProps = HTMLAttributes<HTMLDivElement>;
+declare const PromptInputTabsList: ({ className, ...props }: PromptInputTabsListProps) => react.JSX.Element;
+type PromptInputTabProps = HTMLAttributes<HTMLDivElement>;
+declare const PromptInputTab: ({ className, ...props }: PromptInputTabProps) => react.JSX.Element;
+type PromptInputTabLabelProps = HTMLAttributes<HTMLHeadingElement>;
+declare const PromptInputTabLabel: ({ className, ...props }: PromptInputTabLabelProps) => react.JSX.Element;
+type PromptInputTabBodyProps = HTMLAttributes<HTMLDivElement>;
+declare const PromptInputTabBody: ({ className, ...props }: PromptInputTabBodyProps) => react.JSX.Element;
+type PromptInputTabItemProps = HTMLAttributes<HTMLDivElement>;
+declare const PromptInputTabItem: ({ className, ...props }: PromptInputTabItemProps) => react.JSX.Element;
+type PromptInputCommandProps = ComponentProps<typeof Command>;
+declare const PromptInputCommand: ({ className, ...props }: PromptInputCommandProps) => react.JSX.Element;
+type PromptInputCommandInputProps = ComponentProps<typeof CommandInput>;
+declare const PromptInputCommandInput: ({ className, ...props }: PromptInputCommandInputProps) => react.JSX.Element;
+type PromptInputCommandListProps = ComponentProps<typeof CommandList>;
+declare const PromptInputCommandList: ({ className, ...props }: PromptInputCommandListProps) => react.JSX.Element;
+type PromptInputCommandEmptyProps = ComponentProps<typeof CommandEmpty>;
+declare const PromptInputCommandEmpty: ({ className, ...props }: PromptInputCommandEmptyProps) => react.JSX.Element;
+type PromptInputCommandGroupProps = ComponentProps<typeof CommandGroup>;
+declare const PromptInputCommandGroup: ({ className, ...props }: PromptInputCommandGroupProps) => react.JSX.Element;
+type PromptInputCommandItemProps = ComponentProps<typeof CommandItem>;
+/**
+ * A selectable row inside `PromptInputCommand` (e.g. an `@`-mention popup).
+ *
+ * `id`/`role`/`aria-selected` are assigned internally by the `cmdk` dependency
+ * itself — one layer below this wrapper and below `@elabs-ai/components-ui`'s
+ * own `CommandItem` — and applied AFTER any props you pass, so a
+ * consumer-supplied `id`/`role`/`aria-selected` is silently overridden
+ * (`CommandItem` warns about this in development; #365).
+ *
+ * To wire `aria-activedescendant` from an input rendered OUTSIDE this
+ * `PromptInputCommand` tree (the composer textarea driving the popup), use
+ * `PromptInputCommand`'s `onActiveItemIdChange` callback (inherited from
+ * `@elabs-ai/components-ui`'s `Command`, since `PromptInputCommandProps =
+ * ComponentProps<typeof Command>`) instead of reading the id back
+ * positionally from the DOM:
+ *
+ * ```tsx
+ * const [activeId, setActiveId] = useState<string>();
+ * <textarea role="combobox" aria-expanded={open} aria-controls={listId}
+ *           aria-activedescendant={activeId} />
+ * <PromptInputCommand onActiveItemIdChange={setActiveId}>…</PromptInputCommand>
+ * ```
+ */
+declare const PromptInputCommandItem: ({ className, ...props }: PromptInputCommandItemProps) => react.JSX.Element;
+type PromptInputCommandSeparatorProps = ComponentProps<typeof CommandSeparator>;
+declare const PromptInputCommandSeparator: ({ className, ...props }: PromptInputCommandSeparatorProps) => react.JSX.Element;
+
+interface ComposerProps {
+    /** Submit handler — receives the assembled message (text + attachments). */
+    onSubmit?: PromptInputProps["onSubmit"];
+    /** Textarea placeholder. Default `"Ask me anything…"`. */
+    placeholder?: string;
+    /**
+     * Muted status line shown above the input well. Default `"Awaiting your
+     * input"`. Drive it from chat state ("Thinking…", "Generating…") or pass
+     * `null` to hide the strip entirely.
+     */
+    status?: ReactNode;
+    /** Model-selector pill label. Default `"Claude Opus 4"`; pass `null` to hide it. */
+    model?: ReactNode;
+    /**
+     * Override the left-hand tool cluster (attach + model pill) — e.g. to add a
+     * web-search or connect-data control. Render `PromptInputButton`s /
+     * `PromptInputActionMenu` here; when set, `showAttach`/`model` are ignored.
+     */
+    tools?: ReactNode;
+    /** Send-button state, forwarded to `PromptInputSubmit` (ready/submitted/streaming/error). */
+    sendStatus?: ComponentProps<typeof PromptInputSubmit>["status"];
+    /** Stop handler used while the send button shows the generating state. */
+    onStop?: ComponentProps<typeof PromptInputSubmit>["onStop"];
+    /**
+     * Extra props spread onto the send button — `disabled`, `aria-label`,
+     * `variant`, `id`, `className`. `status` and `onStop` are excluded because
+     * `Composer` owns them via `sendStatus` / `onStop` above. (A `data-*` key is
+     * not assignable through this object: TypeScript only permits arbitrary
+     * `data-*` on a JSX element directly, not on a typed props object. Reach for
+     * `id` or `aria-label` as the test hook.)
+     *
+     * **`disabled` is the one that matters for correctness.** `PromptInput`'s
+     * submit handler calls `form.reset()` as soon as it ACCEPTS a submit, so a
+     * consumer that refuses the send inside `onSubmit` — an app doing async setup
+     * on the first message, say — has already had the textarea cleared and the
+     * user's text destroyed, with nothing to restore from. Disabling the control
+     * is what actually prevents it: `PromptInputTextarea`'s Enter handler checks
+     * `submitControl?.disabled` and bails before `requestSubmit()`, so the Enter
+     * path is closed too, not just the click.
+     *
+     * Leave it UNSET rather than passing `false` when you have no opinion —
+     * `PromptInputSubmit` resolves `disabled ?? autoDisabled`, so a literal
+     * `false` opts out of the library's own empty-composer guard.
+     */
+    submitProps?: Omit<ComponentProps<typeof PromptInputSubmit>, "status" | "onStop">;
+    /**
+     * The two-tone arrangement, forwarded to the `tone` prop of `PromptInput`.
+     * `"surface"` (default, unchanged) is the original Composer look — an outer
+     * `bg-card` frame around the standard muted `PromptInput` well — so every
+     * existing usage is unaffected. `"card"` swaps to the tinted-outer/
+     * distinct-inner "double card" (#254): an outer `bg-surface-muted` frame
+     * around a `tone="card"` well. The well fill relative to the frame is
+     * theme-driven, not universally "white" — raised on light themes, recessed
+     * on dark; see the `tone` prop doc on `PromptInput`.
+     */
+    tone?: PromptInputProps["tone"];
+    /** Optional suggestion chips rendered beneath the composer. */
+    suggestions?: string[];
+    /** Click handler for a suggestion chip. */
+    onSuggestionClick?: (suggestion: string) => void;
+    /** Show the voice button. Default `true`. */
+    showVoice?: boolean;
+    /** Show the attach button. Default `true`. */
+    showAttach?: boolean;
+    /** Extra classes for the outer card frame. */
+    className?: string;
+}
+/**
+ * Composer — the standard brand-ui AI chat input.
+ *
+ * A rounded two-tone "double card": a status strip wrapping a recessed
+ * `PromptInput` well (sharp top, theme-rounded bottom), a model pill, voice,
+ * and a circular send. Built on the real `PromptInput`, so it drops into a
+ * `ChatShell` footer or stands alone as an empty-state composer. `tone`
+ * (default `"surface"`, unchanged) picks the arrangement: `"surface"` keeps
+ * the original outer `bg-card` frame around the standard muted well;
+ * `"card"` (#254) swaps to an outer `bg-surface-muted` frame around a
+ * `tone="card"` well — the well fill is theme-driven (raised on light
+ * themes, recessed on dark), not universally white; see the
+ * `tone` prop doc on `PromptInput`. Semantic tokens only; theme-aware radii
+ * (`rounded-xl` frame / `rounded-b-lg` well); reads in every theme.
+ *
+ * This is the canonical chat input — reach for it instead of hand-rolling a
+ * `PromptInput` footer.
+ */
+declare function Composer({ onSubmit, placeholder, status, model, tools, sendStatus, onStop, submitProps, suggestions, onSuggestionClick, showVoice, showAttach, tone, className, }: ComposerProps): react.JSX.Element;
+
+type ToolUIPartApproval = {
+    id: string;
+    approved?: never;
+    reason?: never;
+} | {
+    id: string;
+    approved: boolean;
+    reason?: string;
+} | {
+    id: string;
+    approved: true;
+    reason?: string;
+} | {
+    id: string;
+    approved: false;
+    reason?: string;
+} | undefined;
+type ConfirmationProps = ComponentProps<typeof Alert> & {
+    approval?: ToolUIPartApproval;
+    state: ToolUIPart["state"];
+};
+declare const Confirmation: ({ className, approval, state, variant, role, children, ...props }: ConfirmationProps) => react.JSX.Element | null;
+type ConfirmationTitleProps = ComponentProps<typeof AlertTitle>;
+/**
+ * The question zone (research 11 §B.3 APPROVE-3) — out-ranks the surrounding
+ * `text-body` and names the pending region via the card's `aria-labelledby`.
+ */
+declare const ConfirmationTitle: ({ className, id, ...props }: ConfirmationTitleProps) => react.JSX.Element;
+type ConfirmationDescriptionProps = ComponentProps<typeof AlertDescription>;
+/** The consequence zone — what approving will actually do (research 11 §B.3). */
+declare const ConfirmationDescription: ({ className, ...props }: ConfirmationDescriptionProps) => react.JSX.Element;
+interface ConfirmationRequestProps {
+    children?: ReactNode;
+}
+declare const ConfirmationRequest: ({ children }: ConfirmationRequestProps) => ReactNode;
+interface ConfirmationAcceptedProps {
+    children?: ReactNode;
+}
+declare const ConfirmationAccepted: ({ children }: ConfirmationAcceptedProps) => ReactNode;
+interface ConfirmationRejectedProps {
+    children?: ReactNode;
+}
+declare const ConfirmationRejected: ({ children }: ConfirmationRejectedProps) => ReactNode;
+type ConfirmationActionsProps = ComponentProps<"div">;
+declare const ConfirmationActions: ({ className, ...props }: ConfirmationActionsProps) => react.JSX.Element | null;
+type ConfirmationActionProps = ComponentProps<typeof Button>;
+declare const ConfirmationAction: ({ className, ...props }: ConfirmationActionProps) => react.JSX.Element;
+type ConfirmationApproveProps = ConfirmationActionProps;
+/**
+ * The proceed action — presets the filled primary variant (research 11 §B.3
+ * APPROVE-2). Role-named so the primary path cannot drift to `outline`.
+ */
+declare const ConfirmationApprove: (props: ConfirmationApproveProps) => react.JSX.Element;
+type ConfirmationDenyProps = ConfirmationActionProps;
+/** The decline action — presets the quiet `ghost` variant, never `outline`. */
+declare const ConfirmationDeny: (props: ConfirmationDenyProps) => react.JSX.Element;
+declare const ApprovalCard: ({ className, approval, state, variant, role, children, ...props }: ConfirmationProps) => react.JSX.Element | null;
+type ApprovalCardProps = ConfirmationProps;
+declare const ApprovalCardTitle: ({ className, id, ...props }: ConfirmationTitleProps) => react.JSX.Element;
+type ApprovalCardTitleProps = ConfirmationTitleProps;
+declare const ApprovalCardDescription: ({ className, ...props }: ConfirmationDescriptionProps) => react.JSX.Element;
+type ApprovalCardDescriptionProps = ConfirmationDescriptionProps;
+declare const ApprovalCardRequest: ({ children }: ConfirmationRequestProps) => ReactNode;
+type ApprovalCardRequestProps = ConfirmationRequestProps;
+declare const ApprovalCardAccepted: ({ children }: ConfirmationAcceptedProps) => ReactNode;
+type ApprovalCardAcceptedProps = ConfirmationAcceptedProps;
+declare const ApprovalCardRejected: ({ children }: ConfirmationRejectedProps) => ReactNode;
+type ApprovalCardRejectedProps = ConfirmationRejectedProps;
+declare const ApprovalCardActions: ({ className, ...props }: ConfirmationActionsProps) => react.JSX.Element | null;
+type ApprovalCardActionsProps = ConfirmationActionsProps;
+declare const ApprovalCardAction: ({ className, ...props }: ConfirmationActionProps) => react.JSX.Element;
+type ApprovalCardActionProps = ConfirmationActionProps;
+declare const ApprovalCardApprove: (props: ConfirmationApproveProps) => react.JSX.Element;
+type ApprovalCardApproveProps = ConfirmationApproveProps;
+declare const ApprovalCardDeny: (props: ConfirmationDenyProps) => react.JSX.Element;
+type ApprovalCardDenyProps = ConfirmationDenyProps;
+
+declare const Connection: ConnectionLineComponent;
+
+type ModelId = string;
+interface ContextSchema {
+    usedTokens: number;
+    maxTokens: number;
+    usage?: LanguageModelUsage;
+    modelId?: ModelId;
+}
+type ContextProps = ComponentProps<typeof HoverCard> & ContextSchema;
+declare const Context: ({ usedTokens, maxTokens, usage, modelId, ...props }: ContextProps) => react.JSX.Element;
+type ContextTriggerProps = ComponentProps<typeof Button>;
+declare const ContextTrigger: ({ children, ...props }: ContextTriggerProps) => react.JSX.Element;
+type ContextContentProps = ComponentProps<typeof HoverCardContent>;
+declare const ContextContent: ({ className, ...props }: ContextContentProps) => react.JSX.Element;
+type ContextContentHeaderProps = ComponentProps<"div">;
+declare const ContextContentHeader: ({ children, className, ...props }: ContextContentHeaderProps) => react.JSX.Element;
+type ContextContentBodyProps = ComponentProps<"div">;
+declare const ContextContentBody: ({ children, className, ...props }: ContextContentBodyProps) => react.JSX.Element;
+type ContextContentFooterProps = ComponentProps<"div">;
+declare const ContextContentFooter: ({ children, className, ...props }: ContextContentFooterProps) => react.JSX.Element;
+type ContextInputUsageProps = ComponentProps<"div">;
+declare const ContextInputUsage: ({ className, children, ...props }: ContextInputUsageProps) => string | number | bigint | true | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react.JSX.Element | null;
+type ContextOutputUsageProps = ComponentProps<"div">;
+declare const ContextOutputUsage: ({ className, children, ...props }: ContextOutputUsageProps) => string | number | bigint | true | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react.JSX.Element | null;
+type ContextReasoningUsageProps = ComponentProps<"div">;
+declare const ContextReasoningUsage: ({ className, children, ...props }: ContextReasoningUsageProps) => string | number | bigint | true | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react.JSX.Element | null;
+type ContextCacheUsageProps = ComponentProps<"div">;
+declare const ContextCacheUsage: ({ className, children, ...props }: ContextCacheUsageProps) => string | number | bigint | true | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react.JSX.Element | null;
+
+type ControlsProps = ComponentProps<typeof Controls$1>;
+declare const Controls: (props: ControlsProps) => react.JSX.Element;
+
+type ConversationProps = ComponentProps<typeof StickToBottom>;
+declare const Conversation: ({ className, ...props }: ConversationProps) => react.JSX.Element;
+type ConversationContentProps = ComponentProps<typeof StickToBottom.Content>;
+declare const ConversationContent: ({ className, ...props }: ConversationContentProps) => react.JSX.Element;
+type ConversationEmptyStateProps = ComponentProps<"div"> & {
+    title?: string;
+    description?: string;
+    icon?: React.ReactNode;
+};
+declare const ConversationEmptyState: ({ className, title, description, icon, children, ...props }: ConversationEmptyStateProps) => react.JSX.Element;
+type ConversationScrollButtonProps = ComponentProps<typeof Button>;
+declare const ConversationScrollButton: ({ className, ...props }: ConversationScrollButtonProps) => false | react.JSX.Element;
+type ConversationDownloadProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+    messages: UIMessage[];
+    filename?: string;
+    formatMessage?: (message: UIMessage, index: number) => string;
+};
+declare const messagesToMarkdown: (messages: UIMessage[], formatMessage?: (message: UIMessage, index: number) => string) => string;
+declare const ConversationDownload: ({ messages, filename, formatMessage, className, children, ...props }: ConversationDownloadProps) => react.JSX.Element;
+
+declare const Edge: {
+    Animated: (props: EdgeProps) => react.JSX.Element;
+    Temporary: (props: EdgeProps) => react.JSX.Element;
+};
+
+type EnvironmentVariablesProps = HTMLAttributes<HTMLDivElement> & {
+    showValues?: boolean;
+    defaultShowValues?: boolean;
+    onShowValuesChange?: (show: boolean) => void;
+};
+declare const EnvironmentVariables: ({ showValues: controlledShowValues, defaultShowValues, onShowValuesChange, className, children, ...props }: EnvironmentVariablesProps) => react.JSX.Element;
+type EnvironmentVariablesHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const EnvironmentVariablesHeader: ({ className, children, ...props }: EnvironmentVariablesHeaderProps) => react.JSX.Element;
+type EnvironmentVariablesTitleProps = HTMLAttributes<HTMLHeadingElement>;
+declare const EnvironmentVariablesTitle: ({ className, children, ...props }: EnvironmentVariablesTitleProps) => react.JSX.Element;
+type EnvironmentVariablesToggleProps = ComponentProps<typeof Switch>;
+declare const EnvironmentVariablesToggle: ({ className, ...props }: EnvironmentVariablesToggleProps) => react.JSX.Element;
+type EnvironmentVariablesContentProps = HTMLAttributes<HTMLDivElement>;
+declare const EnvironmentVariablesContent: ({ className, children, ...props }: EnvironmentVariablesContentProps) => react.JSX.Element;
+type EnvironmentVariableGroupProps = HTMLAttributes<HTMLDivElement>;
+declare const EnvironmentVariableGroup: ({ className, children, ...props }: EnvironmentVariableGroupProps) => react.JSX.Element;
+type EnvironmentVariableNameProps = HTMLAttributes<HTMLSpanElement>;
+declare const EnvironmentVariableName: ({ className, children, ...props }: EnvironmentVariableNameProps) => react.JSX.Element;
+type EnvironmentVariableValueProps = HTMLAttributes<HTMLSpanElement>;
+declare const EnvironmentVariableValue: ({ className, children, ...props }: EnvironmentVariableValueProps) => react.JSX.Element;
+type EnvironmentVariableProps = HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    value: string;
+};
+declare const EnvironmentVariable: ({ name, value, className, children, ...props }: EnvironmentVariableProps) => react.JSX.Element;
+type EnvironmentVariableCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+    copyFormat?: "name" | "value" | "export";
+};
+declare const EnvironmentVariableCopyButton: ({ onCopy, onError, timeout, copyFormat, children, className, ...props }: EnvironmentVariableCopyButtonProps) => react.JSX.Element;
+type EnvironmentVariableRequiredProps = ComponentProps<typeof Badge>;
+declare const EnvironmentVariableRequired: ({ className, children, ...props }: EnvironmentVariableRequiredProps) => react.JSX.Element;
+
+/**
+ * Visual axis (#193, research 04 §4 ASSET-1): `code` (default, unchanged) is
+ * the IDE source tree — mono + hard box; `document` is the produced-asset
+ * look — sans body role, no box (section label + spacing separate it,
+ * research 08), for trees of documents rather than source files.
+ */
+declare const fileTreeVariants: (props?: ({
+    variant?: "code" | "document" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type FileTreeVariant = NonNullable<VariantProps<typeof fileTreeVariants>["variant"]>;
+type FileTreeProps = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & VariantProps<typeof fileTreeVariants> & {
+    expanded?: Set<string>;
+    defaultExpanded?: Set<string>;
+    selectedPath?: string;
+    onSelect?: (path: string) => void;
+    onExpandedChange?: (expanded: Set<string>) => void;
+};
+declare const FileTree: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & VariantProps<(props?: ({
+    variant?: "code" | "document" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    expanded?: Set<string>;
+    defaultExpanded?: Set<string>;
+    selectedPath?: string;
+    onSelect?: (path: string) => void;
+    onExpandedChange?: (expanded: Set<string>) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+type FileTreeIconProps = HTMLAttributes<HTMLSpanElement>;
+declare const FileTreeIcon: ({ className, children, ...props }: FileTreeIconProps) => react.JSX.Element;
+type FileTreeNameProps = HTMLAttributes<HTMLSpanElement>;
+declare const FileTreeName: ({ className, children, ...props }: FileTreeNameProps) => react.JSX.Element;
+type FileTreeFolderProps = HTMLAttributes<HTMLDivElement> & {
+    path: string;
+    name: string;
+};
+declare const FileTreeFolder: ({ path, name, className, children, ...props }: FileTreeFolderProps) => react.JSX.Element;
+type FileTreeFileProps = HTMLAttributes<HTMLDivElement> & {
+    path: string;
+    name: string;
+    icon?: ReactNode;
+};
+declare const FileTreeFile: ({ path, name, icon, className, children, ...props }: FileTreeFileProps) => react.JSX.Element;
+type FileTreeActionsProps = HTMLAttributes<HTMLDivElement>;
+declare const FileTreeActions: ({ className, children, ...props }: FileTreeActionsProps) => react.JSX.Element;
+/** Asset-type glyphs (lucide, research 04 §4) — doc / code / sql / csv / image. */
+declare const PRODUCED_ASSET_ICONS: Record<ContextAssetType, LucideIcon>;
+type ProducedAssetTreeProps = Omit<FileTreeProps, "variant" | "onSelect" | "selectedPath"> & {
+    /** The produced assets, in display order. */
+    assets: ContextAsset[];
+    /** Selected asset id (mirror `useContextPanel().state.selectedAsset?.id`). */
+    selectedId?: string;
+    /** Called with the chosen asset — wire to `useContextPanel().actions.openDetail`. */
+    onSelect?: (asset: ContextAsset) => void;
+};
+/**
+ * ProducedAssetTree — the document-variant preset (#193, research 04 §4):
+ * produced assets are documents, not source code, so the tree reads sans,
+ * box-free, with first-class asset-type icons. Pair with `ContextPanelSection`
+ * for the label; selection drives the ContextPanel drill-in.
+ */
+declare const ProducedAssetTree: react.ForwardRefExoticComponent<Omit<FileTreeProps, "onSelect" | "variant" | "selectedPath"> & {
+    /** The produced assets, in display order. */
+    assets: ContextAsset[];
+    /** Selected asset id (mirror `useContextPanel().state.selectedAsset?.id`). */
+    selectedId?: string;
+    /** Called with the chosen asset — wire to `useContextPanel().actions.openDetail`. */
+    onSelect?: (asset: ContextAsset) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+/** One labelled metadata row rendered in the detail panel `<dl>`. */
+interface GalleryMetaItem {
+    /** Field label (rendered muted, in the `<dt>`). */
+    label: string;
+    /** Field value — a string in the common case; `ReactNode` allows a link/badge. */
+    value: ReactNode;
+}
+/** A single gallery image plus its optional metadata. */
+interface GalleryImage {
+    /** Full-resolution source shown in the lightbox and standalone tile. */
+    src: string;
+    /** Required alt text (a11y). Pass `""` to mark the image decorative. */
+    alt: string;
+    /** Cheaper thumbnail for the grid; falls back to `src`. */
+    thumbnailSrc?: string;
+    /** Headline shown in the panel; also feeds the dialog's accessible name. */
+    title?: string;
+    /** Long-form copy shown under the title in the detail panel. */
+    description?: string;
+    /** Structured key/value rows rendered as a `<dl>` in the detail panel. */
+    meta?: GalleryMetaItem[];
+    /** Overrides `src` for the download (e.g. a signed full-res URL). */
+    downloadUrl?: string;
+    /** Suggested download filename. */
+    downloadName?: string;
+}
+interface GalleryProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Images to display. `0` → empty state, `1` → standalone, `≥2` → grid. */
+    images: GalleryImage[];
+    /** Thumbnails to show before collapsing the rest into a "+N more" tile. @default 5 */
+    maxVisible?: number;
+    /** Aspect ratio for grid tiles and the standalone image. @default 1 (square) */
+    aspectRatio?: number;
+    /** Hide every download affordance (e.g. rights-restricted assets). @default false */
+    hideDownload?: boolean;
+    /**
+     * The set is still arriving (loading-states.md `loading` signal). Renders
+     * skeleton tiles in the grid footprint instead of the empty state, and fills
+     * the gap up to `expectedCount` (or `maxVisible`) while images stream in.
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Total images expected once the set finishes arriving. When
+     * `images.length < expectedCount`, the arrived tiles render alongside
+     * skeleton tiles for the missing ones, so the grid fills in place (no reflow).
+     */
+    expectedCount?: number;
+    /**
+     * Replace the default metadata body in the detail panel. Receives the
+     * currently-active image, so it stays in sync with the carousel. The panel
+     * chrome + title heading remain.
+     */
+    renderMeta?: (image: GalleryImage, index: number) => ReactNode;
+}
+declare const Gallery: react.ForwardRefExoticComponent<GalleryProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * part-groups.ts — Pure, framework-free part-grouping engine.
+ *
+ * Derives collapsible reasoning/tool traces from an ordered list of message
+ * parts. This is a CLIENT-SIDE VIEW TRANSFORM — never a model output format.
+ * Adapted from assistant-ui's grouping design onto this library's idiom.
+ *
+ * `groupBy(part, context)` maps each part to a group-key path (`group-…`);
+ * ADJACENT parts sharing a key path coalesce into synthetic group nodes
+ * (`{ type: "group-…", status, indices }`); multi-element paths nest. The
+ * `group-` namespace is reserved so a group key can never collide with a real
+ * part `type`.
+ */
+/** A reserved group-key. The `group-` prefix can't collide with real part types. */
+type GroupKey = `group-${string}`;
+/** Rolled-up status of a group (any member running → the group is running). */
+type GroupStatus = "pending" | "running" | "complete" | "error";
+/** The minimum a groupable part must expose. */
+interface GroupablePart {
+    type: string;
+    [key: string]: unknown;
+}
+/** Context passed to `groupBy` for each part. */
+interface GroupByContext<T extends GroupablePart> {
+    index: number;
+    parts: readonly T[];
+}
+/** Maps a part to its group-key path (`[]` = not grouped, a top-level leaf). */
+type GroupBy<T extends GroupablePart> = (part: T, context: GroupByContext<T>) => readonly GroupKey[];
+/** Extract a part's status; return `undefined` to fall back to the default. */
+type GetPartStatus<T extends GroupablePart> = (part: T) => GroupStatus | undefined;
+/** The synthetic node produced for a coalesced group. */
+interface PartGroupNode {
+    type: GroupKey;
+    status: GroupStatus;
+    /** Original indices of every leaf part under this group (recursive). */
+    indices: number[];
+}
+/** One node in the grouped tree — a leaf part or a synthetic group. */
+type GroupedNode<T extends GroupablePart> = {
+    kind: "leaf";
+    key: string;
+    index: number;
+    part: T;
+} | {
+    kind: "group";
+    key: string;
+    group: PartGroupNode;
+    children: GroupedNode<T>[];
+};
+/**
+ * Best-effort status from common AI-SDK part shapes (tool `state`, reasoning
+ * `state`, `isStreaming`). Overridable via `getStatus`.
+ */
+declare function defaultPartStatus(part: GroupablePart): GroupStatus;
+/** Roll several member statuses up into one group status. */
+declare function rollupStatus(statuses: readonly GroupStatus[]): GroupStatus;
+/**
+ * Build the grouped tree from an ordered part list. Pure + deterministic —
+ * never throws. Adjacent parts with a shared group-key path coalesce; multi-key
+ * paths nest; ungrouped parts (path `[]`) stay as top-level leaves.
+ */
+declare function buildPartGroups<T extends GroupablePart>(parts: readonly T[], groupBy: GroupBy<T>, getStatus?: GetPartStatus<T>): GroupedNode<T>[];
+/**
+ * A cheap fingerprint of the parts' identity + type + status. Feed it to a
+ * `useMemo` so the grouped tree only rebuilds when something structural
+ * changed — streaming token updates that don't change status won't churn it.
+ */
+declare function partsFingerprint<T extends GroupablePart>(parts: readonly T[], getStatus?: GetPartStatus<T>): string;
+/** Whether a part folds into a trace (`inline`) or always stands alone. */
+type PartDisplay = "inline" | "standalone";
+interface GroupPartByTypeOptions<T extends GroupablePart> {
+    /** Group key for the collapsible trace. @default "group-work" */
+    groupKey?: GroupKey;
+    /** Part types folded into the trace. @default reasoning + tool-* + dynamic-tool + step-start */
+    inline?: (string | RegExp)[];
+    /** Part types forced standalone (never folded). @default approval / human / confirmation */
+    standalone?: (string | RegExp)[];
+    /** Explicit per-part classification; overrides the type lists. */
+    classify?: (part: T) => PartDisplay | undefined;
+}
+/**
+ * Build a `groupBy` that folds reasoning/tool parts into ONE collapsible trace
+ * while forcing human/approval-style parts to stand alone — an interaction card
+ * must never fold into a thinking accordion. The classification maps to the
+ * `display: "inline" | "standalone"` hint.
+ */
+declare function groupPartByType<T extends GroupablePart>(options?: GroupPartByTypeOptions<T>): GroupBy<T>;
+/** Type guard: is this render subject a synthetic group node? */
+declare function isGroupNode(part: {
+    type: string;
+}): part is PartGroupNode;
+
+interface GroupedPartRenderArgs<T extends GroupablePart> {
+    /** The real part (leaf) or the synthetic group node. */
+    part: T | PartGroupNode;
+    /** True when `part` is a synthetic group node. */
+    isGroup: boolean;
+    /** The rendered subtree — group nodes only. */
+    children?: ReactNode;
+    /** Rolled-up status (groups) or the part's status (leaves). */
+    status: GroupStatus;
+    /** Original part indices under this group (groups only). */
+    indices?: number[];
+    /** Original part index (leaves only). */
+    index?: number;
+}
+type GroupedPartRenderer<T extends GroupablePart> = (args: GroupedPartRenderArgs<T>) => ReactNode;
+interface GroupedPartsProps<T extends GroupablePart> extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The ordered message parts to render. */
+    parts: readonly T[];
+    /** How to group parts. @default `groupPartByType()` */
+    groupBy?: GroupBy<T>;
+    /** Extract a part's status (drives group rollup + streaming affordances). */
+    getStatus?: GetPartStatus<T>;
+    /** Render-prop switching on `part.type`. Omit to use the default renderers. */
+    children?: GroupedPartRenderer<T>;
+}
+/**
+ * Renders `parts`, coalescing adjacent grouped parts into collapsible traces.
+ * The tree only rebuilds when the parts' identity/type/status fingerprint
+ * changes, so streaming token updates don't remount rows.
+ */
+declare function GroupedParts<T extends GroupablePart>({ parts, groupBy, getStatus, children, className, ...props }: GroupedPartsProps<T>): react.JSX.Element;
+
+type ImageProps = Experimental_GeneratedImage & Omit<ImgHTMLAttributes<HTMLImageElement>, "src"> & {
+    /**
+     * Show a Skeleton placeholder (loading-states.md) until the img element
+     * finishes decoding, so the base64 payload does not pop in. Requires
+     * explicit `width`+`height` so the reserved box matches the final size
+     * (interaction-guidelines.md Images section — prevents CLS); without
+     * both there is no box to reserve, so the default is `false` in that
+     * case rather than mounting a skeleton that collapses to nothing.
+     * @default Boolean(width && height)
+     */
+    showSkeleton?: boolean;
+};
+/** `<img>` wrapper for an AI-SDK generated image, with a decode-aware skeleton. */
+declare const Image: react.ForwardRefExoticComponent<Experimental_GeneratedImage & Omit<ImgHTMLAttributes<HTMLImageElement>, "src"> & {
+    /**
+     * Show a Skeleton placeholder (loading-states.md) until the img element
+     * finishes decoding, so the base64 payload does not pop in. Requires
+     * explicit `width`+`height` so the reserved box matches the final size
+     * (interaction-guidelines.md Images section — prevents CLS); without
+     * both there is no box to reserve, so the default is `false` in that
+     * case rather than mounting a skeleton that collapses to nothing.
+     * @default Boolean(width && height)
+     */
+    showSkeleton?: boolean;
+} & react.RefAttributes<HTMLImageElement>>;
+
+type InlineCitationProps = ComponentProps<"span">;
+declare const InlineCitation: ({ className, ...props }: InlineCitationProps) => react.JSX.Element;
+type InlineCitationTextProps = ComponentProps<"span">;
+declare const InlineCitationText: ({ className, ...props }: InlineCitationTextProps) => react.JSX.Element;
+type InlineCitationCardProps = ComponentProps<typeof HoverCard>;
+declare const InlineCitationCard: (props: InlineCitationCardProps) => react.JSX.Element;
+/**
+ * A cited source: a bare string — a URL, or any opaque id / human label — or a
+ * labelled object.
+ *
+ * Non-URL sources are first-class. An agent citing a warehouse table, a document
+ * id, an uploaded file or a wiki page has no hostname to show, and must not have
+ * to synthesize a fake URL to satisfy the chip.
+ */
+type InlineCitationSourceRef = string | {
+    /** Opaque identifier, shown when there is no `label` and no `url`. */
+    id?: string;
+    /** Human-readable label — wins over any hostname derived from `url`. */
+    label?: string;
+    /** Optional link; its hostname is the fallback label. */
+    url?: string;
+};
+/**
+ * The chip label for a source ref. Exported so consumers can render the same
+ * label elsewhere (a footnote list, a tooltip) without re-deriving the rules.
+ */
+declare const inlineCitationSourceLabel: (source: InlineCitationSourceRef) => string;
+type InlineCitationCardTriggerProps = ComponentProps<typeof Badge> & {
+    sources: InlineCitationSourceRef[];
+};
+declare const InlineCitationCardTrigger: ({ sources, className, ...props }: InlineCitationCardTriggerProps) => react.JSX.Element;
+type EvidenceChipProps = InlineCitationCardTriggerProps;
+/**
+ * EvidenceChip — the named front door for the inline evidence interaction
+ * (research 11 §B.4): the re-skinned `InlineCitationCardTrigger` (green
+ * "grounded" wash). Use inside an `InlineCitationCard` (HoverCard) — it reuses
+ * the citation carousel wholesale; it is not a new primitive.
+ */
+declare const EvidenceChip: ({ sources, className, ...props }: InlineCitationCardTriggerProps) => react.JSX.Element;
+type InlineCitationCardBodyProps = ComponentProps<"div">;
+declare const InlineCitationCardBody: ({ className, ...props }: InlineCitationCardBodyProps) => react.JSX.Element;
+type InlineCitationCarouselProps = ComponentProps<typeof Carousel>;
+declare const InlineCitationCarousel: ({ className, children, ...props }: InlineCitationCarouselProps) => react.JSX.Element;
+type InlineCitationCarouselContentProps = ComponentProps<"div">;
+declare const InlineCitationCarouselContent: (props: InlineCitationCarouselContentProps) => react.JSX.Element;
+type InlineCitationCarouselItemProps = ComponentProps<"div">;
+declare const InlineCitationCarouselItem: ({ className, ...props }: InlineCitationCarouselItemProps) => react.JSX.Element;
+type InlineCitationCarouselHeaderProps = ComponentProps<"div">;
+declare const InlineCitationCarouselHeader: ({ className, ...props }: InlineCitationCarouselHeaderProps) => react.JSX.Element;
+type InlineCitationCarouselIndexProps = ComponentProps<"div">;
+declare const InlineCitationCarouselIndex: ({ children, className, ...props }: InlineCitationCarouselIndexProps) => react.JSX.Element;
+type InlineCitationCarouselPrevProps = ComponentProps<"button">;
+declare const InlineCitationCarouselPrev: ({ className, ...props }: InlineCitationCarouselPrevProps) => react.JSX.Element;
+type InlineCitationCarouselNextProps = ComponentProps<"button">;
+declare const InlineCitationCarouselNext: ({ className, ...props }: InlineCitationCarouselNextProps) => react.JSX.Element;
+type InlineCitationSourceProps = ComponentProps<"div"> & {
+    title?: string;
+    url?: string;
+    description?: string;
+};
+declare const InlineCitationSource: ({ title, url, description, className, children, ...props }: InlineCitationSourceProps) => react.JSX.Element;
+type InlineCitationQuoteProps = ComponentProps<"blockquote">;
+declare const InlineCitationQuote: ({ children, className, ...props }: InlineCitationQuoteProps) => react.JSX.Element;
+
+interface InteractiveTerminalHandle {
+    /** Process → screen. ANSI passthrough (colors, cursor movement, clears, …). */
+    write(data: string): void;
+    /** Clears the viewport + scrollback. */
+    clear(): void;
+    /** Re-fits cols/rows to the current container size. */
+    fit(): void;
+    /** Focuses the terminal's input surface. */
+    focus(): void;
+}
+interface InteractiveTerminalProps extends Omit<HTMLAttributes<HTMLDivElement>, "onResize"> {
+    /** Keystrokes + paste → process. The PTY/process stays consumer-owned. */
+    onData?: (data: string) => void;
+    /** Fires whenever the container resizes and cols/rows are refit. */
+    onResize?: (size: {
+        cols: number;
+        rows: number;
+    }) => void;
+    /** Degrades to a read-only log: writes still render, stdin is disabled. */
+    readOnly?: boolean;
+    /** Terminal font size in px. Defaults to `13` (matches `CodeEditor`). */
+    fontSize?: number;
+    /** Accessible name for the terminal's real focusable surface. Required. */
+    "aria-label": string;
+}
+/**
+ * Builds xterm's `ITheme` from the active theme's semantic tokens, resolved
+ * off `rootEl` (defaults to `<html>`, where `data-theme` lives).
+ *
+ * ANSI mapping (documented so the intent is auditable, not guessed at):
+ *  - background/foreground → `--card`/`--foreground` (the terminal reads as a
+ *    raised panel, matching the existing `Terminal` log's bordered-box look).
+ *  - cursor → `--primary`; cursorAccent → the background, so glyphs stay
+ *    legible under a solid block cursor.
+ *  - selectionBackground → a low-alpha `--primary` wash.
+ *  - red/green/yellow/blue → the AA-tuned `-text` variants (`--destructive-text`,
+ *    `--success-text`, `--warning-text`, `--info-text`) — these are the ones
+ *    tuned to read as TEXT on a surface, which is exactly what ANSI color codes
+ *    paint. `bright*` variants use the more saturated fill tokens
+ *    (`--destructive`, `--success`, `--warning`, `--info`).
+ *  - magenta/cyan → `--chart-4`/`--chart-2` (no dedicated fill/text pair, so the
+ *    `bright*` siblings are the same hue pushed AWAY from the background).
+ *  - black/white are `background`/`foreground` RUNGS, not the tokens
+ *    themselves: `black` = the terminal's own background (the common "ANSI
+ *    black" convention — invisible ink), `brightBlack` = `--border-strong`
+ *    (a dim ink for comments/hashes), `white` = `--muted-foreground` (a dimmer
+ *    ink), `brightWhite` = `--foreground` (full ink).
+ *
+ * EVERY slot above except `black` then passes through `readableInk()` — the AA
+ * floor (#386). The mapping picks the token that carries the right MEANING; the
+ * floor guarantees the resulting ink is legible on this terminal's actual
+ * background. Several of these tokens are mark/fill rungs (≥3:1 only), so
+ * without the floor EVERY palette this repo ships had sub-AA ANSI slots —
+ * measured from `themes.css`: `:root` 7 (worst 2.39:1), `light` 4 (worst
+ * 2.91:1), `dark` 1 (3.16:1). Re-derived on every
+ * run by `interactive-terminal.test.tsx`, which parses those palettes out of
+ * `themes.css` rather than hard-coding them. Keep new slots inside `ink(...)`;
+ * a raw token assigned straight to an ANSI slot is the bug.
+ */
+declare function buildInteractiveTerminalTheme(rootEl?: Element | null): ITheme;
+/**
+ * A token-themed, PTY-ready terminal emulator wrapped as a brand-ui component.
+ * Wraps xterm.js + `FitAddon`; the process itself is consumer-owned — this
+ * component only renders ANSI output and emits `onData`/`onResize`.
+ *
+ * Keyboard: the terminal's real focusable surface is xterm's own input
+ * textarea (reachable by Tab like any control). Tab/Shift-Tab and Escape are
+ * explicitly let through (`attachCustomKeyEventHandler`) so focus can always
+ * leave the terminal — there is no keyboard trap.
+ */
+declare const InteractiveTerminal: react.ForwardRefExoticComponent<InteractiveTerminalProps & react.RefAttributes<InteractiveTerminalHandle>>;
+
+/**
+ * The readiness of the preview, derived from the input (see loading-states.md):
+ * - `idle`    — nothing requested yet (empty input, never rendered). Renders nothing.
+ * - `pending` — not-ready: `loading`, `isStreaming`, OR syntactically incomplete
+ *               input (a half-arrived tag). Builds up best-effort; the error slot
+ *               is suppressed; the skeleton shows until the first successful paint.
+ * - `ready`   — settled, parseable input is rendering.
+ * - `error`   — settled AND genuinely invalid input (the only state that surfaces
+ *               `JSXPreviewError`).
+ */
+type JSXPreviewStatus = "idle" | "pending" | "ready" | "error";
+interface JSXPreviewContextValue {
+    jsx: string;
+    processedJsx: string;
+    isStreaming: boolean;
+    loading: boolean;
+    status: JSXPreviewStatus;
+    hasRendered: boolean;
+    error: Error | null;
+    setError: (error: Error | null) => void;
+    setHasRendered: (value: boolean) => void;
+    components: TProps["components"];
+    bindings: TProps["bindings"];
+    onErrorProp?: (error: Error) => void;
+}
+declare const useJSXPreview: () => JSXPreviewContextValue;
+type JSXPreviewProps = ComponentProps<"div"> & {
+    jsx: string;
+    /** Content is arriving incrementally — build up, suppress transient errors. */
+    isStreaming?: boolean;
+    /**
+     * No renderable content yet (fetch-then-show). Forces the `pending` state so
+     * `JSXPreviewSkeleton` shows until `jsx` arrives. Orthogonal to `isStreaming`.
+     */
+    loading?: boolean;
+    components?: TProps["components"];
+    bindings?: TProps["bindings"];
+    onError?: (error: Error) => void;
+};
+declare const JSXPreview: react.MemoExoticComponent<({ jsx, isStreaming, loading, components, bindings, onError, className, children, ...props }: JSXPreviewProps) => react.JSX.Element>;
+type JSXPreviewContentProps = Omit<ComponentProps<"div">, "children">;
+declare const JSXPreviewContent: react.MemoExoticComponent<({ className, ...props }: JSXPreviewContentProps) => react.JSX.Element | null>;
+type JSXPreviewSkeletonProps = ComponentProps<"div">;
+/**
+ * The not-ready placeholder (loading-states.md §slot anatomy). Renders a
+ * layout-shaped `Skeleton` while the preview is `pending` and nothing has
+ * painted yet — so a streaming/incomplete surface BUILDS UP behind a skeleton
+ * instead of flashing the error box. Pass `children` to override the shape.
+ */
+declare const JSXPreviewSkeleton: react.MemoExoticComponent<({ className, children, ...props }: JSXPreviewSkeletonProps) => react.JSX.Element>;
+type JSXPreviewErrorProps = ComponentProps<"div"> & {
+    children?: ReactNode | ((error: Error) => ReactNode);
+};
+declare const JSXPreviewError: react.MemoExoticComponent<({ className, children, ...props }: JSXPreviewErrorProps) => react.JSX.Element | null>;
+
+/**
+ * A drop-in replacement for `@streamdown/mermaid`'s `mermaid` plugin that loads
+ * the Mermaid engine **on first diagram render** instead of at import time.
+ *
+ * Why this exists
+ * ---------------
+ * `@streamdown/mermaid`'s dist opens with a static `import n from "mermaid"`, and
+ * neither it nor `mermaid`/`dompurify`/`d3` declares `sideEffects`, so a bundler
+ * must keep the whole edge. `@elabs-ai/components-ai` imported that plugin from three modules
+ * (`message`, `reasoning`, `markdown-view`), which put Mermaid + d3 + DOMPurify —
+ * several MB — in the **entry chunk** of every consumer, including the vast
+ * majority that never render a diagram.
+ *
+ * How it avoids a render flash
+ * ----------------------------
+ * `DiagramPlugin` is not the engine; it is a lazy accessor. Streamdown calls
+ * `getMermaid()` only from inside its async diagram-render path (immediately
+ * before `await instance.render(...)`), never at module or component init. So the
+ * plugin object can be present from the very first frame — Streamdown always
+ * treats a ```mermaid fence as a diagram — while the engine itself arrives with a
+ * dynamic import inside `render()`. No content-sniffing, no plugin swap, no
+ * suspense seam at the call sites, and no "raw source flashes then becomes a
+ * diagram" transition.
+ *
+ * The upstream plugin is ~10 lines; its defaults and initialize-once semantics
+ * are mirrored exactly below. The `DiagramPlugin` type is still imported (as a
+ * type, so it erases) from `@streamdown/mermaid`, which keeps this honest against
+ * the real contract at typecheck time.
+ */
+
+/**
+ * Start fetching the Mermaid engine ahead of time.
+ *
+ * Optional. Call it when you already know the surface will render diagrams (on
+ * route entry, or when a conversation is known to contain them) so the first
+ * diagram doesn't pay the import latency. Safe to call repeatedly; safe to
+ * ignore — rendering a diagram loads the engine either way.
+ */
+declare const preloadMermaid: () => void;
+/**
+ * Create a lazy Mermaid diagram plugin for Streamdown.
+ *
+ * @param options.config Mermaid config merged over the brand defaults.
+ */
+declare const createLazyMermaidPlugin: (options?: {
+    config?: MermaidConfig;
+}) => DiagramPlugin;
+/**
+ * The shared lazy Mermaid plugin — the `@elabs-ai/components-ai` replacement for
+ * `@streamdown/mermaid`'s eager `mermaid` export. One instance for the whole
+ * app, so the engine and its initialize-once state are shared.
+ */
+declare const lazyMermaid: DiagramPlugin;
+
+interface MarkdownViewProps extends Omit<ComponentProps<typeof Streamdown>, "components" | "plugins"> {
+    /**
+     * The prose level a markdown `#` maps to; deeper headings shift with it
+     * (capped at 6). Default `1` (the full reading scale). Pass `2` in narrow
+     * embeds (a context rail) so headings stay on the constrained rung.
+     */
+    baseHeadingLevel?: ProseHeadingLevel;
+}
+declare const MarkdownView: ({ baseHeadingLevel, className, children, ...props }: MarkdownViewProps) => react.JSX.Element;
+
+type MessageProps = HTMLAttributes<HTMLDivElement> & {
+    from: UIMessage["role"];
+};
+declare const Message: ({ className, from, ...props }: MessageProps) => react.JSX.Element;
+type MessageContentProps = HTMLAttributes<HTMLDivElement>;
+declare const MessageContent: ({ children, className, ...props }: MessageContentProps) => react.JSX.Element;
+type MessageHeaderProps = HTMLAttributes<HTMLDivElement>;
+/**
+ * Optional identity row above the bubble — avatar + name + timestamp
+ * (research 11 §B.1 MSG-2). A slot, not baked structure.
+ */
+declare const MessageHeader: ({ className, ...props }: MessageHeaderProps) => react.JSX.Element;
+type MessageAvatarProps = ComponentProps<typeof Avatar> & {
+    /** Image source for the participant. */
+    src?: string;
+    /** Participant name — drives the image alt + the fallback initial, and the accessible label. */
+    name?: string;
+    /**
+     * Visual identity role.
+     * - `"user"` (default): shows the initial letter as a fallback.
+     * - `"agent"`: shows a branded Bot icon on a primary (green) ground instead
+     *   of a text initial, matching the agent identity convention.
+     */
+    role?: "user" | "agent";
+};
+/**
+ * Thin preset over the `@elabs-ai/components-ui` Avatar sized for inline chat (NOT a new
+ * avatar primitive — research 11 §B.1 MSG-2).
+ *
+ * When `role="agent"`, renders a filled primary-green circle with a centered
+ * Bot icon (lucide-react `BotIcon`) and an accessible label derived from
+ * `name`. The primary/primary-foreground token pair is the agent identity
+ * colour across both themes (green on light/dark; theme-adapted
+ * on others).
+ */
+declare const MessageAvatar: ({ src, name, role, className, children, ...props }: MessageAvatarProps) => react.JSX.Element;
+type UserMessageProps = Omit<MessageProps, "from">;
+/**
+ * Named front door for a user turn (research 11 §B.2) — a thin preset over
+ * `Message from="user"`; the chat-user fill comes from `MessageContent`.
+ */
+declare const UserMessage: (props: UserMessageProps) => react.JSX.Element;
+declare const agentMessageVariants: (props?: ({
+    emphasis?: "default" | "answer" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AgentMessageEmphasis = NonNullable<VariantProps<typeof agentMessageVariants>["emphasis"]>;
+type AgentMessageProps = Omit<MessageProps, "from"> & VariantProps<typeof agentMessageVariants>;
+/**
+ * Named front door for an assistant turn (research 11 §B.2). KPI band / prose /
+ * footer are COMPOSED children (`MetricGrid` + `MessageResponse` +
+ * `SourceList`), not baked-in layout.
+ */
+declare const AgentMessage: ({ className, emphasis, ...props }: AgentMessageProps) => react.JSX.Element;
+declare const messageActionsVariants: (props?: ({
+    appearance?: "bar" | "plain" | null | undefined;
+    reveal?: "always" | "hover" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type MessageActionsProps = ComponentProps<"div"> & VariantProps<typeof messageActionsVariants> & {
+    /**
+     * Accessible name for the group. Defaults to the `ai.message.actions`
+     * microcopy key. Naming matters more here than on an always-visible row:
+     * assistive tech reaches these controls whether or not a pointer ever
+     * revealed them, so the group has to say what they act on.
+     */
+    label?: string;
+};
+/**
+ * A row of per-message controls (copy, pin, retry, a `⋯` menu, …).
+ *
+ * **Presentational only** — it lays the controls out and decides when they are
+ * visible; it ships no clipboard call, no pin state and no persistence. Every
+ * `MessageAction` inside it is a bare `Button`: give it an `onClick`, and for a
+ * toggle (pin, bookmark) an `aria-pressed` the host owns. That is the D5
+ * boundary (`docs/DECISIONS.md` §D5) — brand-ui renders, the app acts.
+ *
+ * `reveal="hover"` reads the parent `Message`'s `group` class, so the row must
+ * be rendered INSIDE a `Message` for pointer-reveal to fire. Standing alone it
+ * still reveals on its own hover and on focus-within, but not from the bubble.
+ */
+declare const MessageActions: ({ appearance, className, children, label, reveal, ...props }: MessageActionsProps) => react.JSX.Element;
+type MessageActionProps = ComponentProps<typeof Button> & {
+    tooltip?: string;
+    label?: string;
+};
+declare const MessageAction: ({ tooltip, children, label, variant, size, ...props }: MessageActionProps) => react.JSX.Element;
+type MessageBranchProps = HTMLAttributes<HTMLDivElement> & {
+    /**
+     * Controlled current branch index. When set, `MessageBranch` no longer
+     * tracks its own state — the host owns it and must update `branch` from
+     * `onBranchChange` (or elsewhere) to move the selection. Omit for the
+     * uncontrolled default (see `defaultBranch`).
+     */
+    branch?: number;
+    defaultBranch?: number;
+    onBranchChange?: (branchIndex: number) => void;
+};
+declare const MessageBranch: ({ branch: branchProp, defaultBranch, onBranchChange, className, ...props }: MessageBranchProps) => react.JSX.Element;
+type MessageBranchContentProps = HTMLAttributes<HTMLDivElement>;
+declare const MessageBranchContent: ({ children, ...props }: MessageBranchContentProps) => react.JSX.Element[];
+type MessageBranchSelectorProps = ComponentProps<typeof ButtonGroup>;
+declare const MessageBranchSelector: ({ className, ...props }: MessageBranchSelectorProps) => react.JSX.Element | null;
+type MessageBranchPreviousProps = ComponentProps<typeof Button>;
+declare const MessageBranchPrevious: ({ children, ...props }: MessageBranchPreviousProps) => react.JSX.Element;
+type MessageBranchNextProps = ComponentProps<typeof Button>;
+declare const MessageBranchNext: ({ children, ...props }: MessageBranchNextProps) => react.JSX.Element;
+type MessageBranchPageProps = HTMLAttributes<HTMLSpanElement>;
+declare const MessageBranchPage: ({ className, ...props }: MessageBranchPageProps) => react.JSX.Element;
+type MessageResponseProps = ComponentProps<typeof Streamdown> & {
+    /**
+     * No content has arrived yet (loading-states.md `loading`) — renders
+     * skeleton lines at the body line-height instead of `<Streamdown>`, so the
+     * bubble reserves its space before the first token.
+     * @default false
+     */
+    loading?: boolean;
+};
+declare const MessageResponse: react.MemoExoticComponent<({ className, loading, ...props }: MessageResponseProps) => react.JSX.Element>;
+type MessageToolbarProps = ComponentProps<"div">;
+declare const MessageToolbar: ({ className, children, ...props }: MessageToolbarProps) => react.JSX.Element;
+
+interface MessageEditContextValue {
+    editing: boolean;
+    draft: string;
+    setDraft: (value: string) => void;
+    beginEdit: () => void;
+    cancel: () => void;
+    submit: () => void;
+    /** Ref for the trigger element so focus can be restored to it on exit. */
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+    editorId: string;
+}
+/** Read-only access to the edit state (for a custom trigger/toolbar). */
+declare function useMessageEdit(): Pick<MessageEditContextValue, "editing" | "draft" | "beginEdit" | "cancel" | "submit">;
+interface MessageEditProviderProps {
+    /** The editable source text (seeds the editor on begin). */
+    value: string;
+    /** Called with the new text on save. The consumer creates the branch. */
+    onEditSubmit?: (newText: string) => void;
+    /** Controlled editing state. When set, `onEditingChange` drives transitions. */
+    editing?: boolean;
+    /** Uncontrolled initial editing state. @default false */
+    defaultEditing?: boolean;
+    /** Called when editing begins/ends. */
+    onEditingChange?: (editing: boolean) => void;
+    children: ReactNode;
+}
+/** Lifts the edit state (editing + draft). Controlled or uncontrolled. */
+declare function MessageEditProvider({ value, onEditSubmit, editing: editingProp, defaultEditing, onEditingChange, children, }: MessageEditProviderProps): react.JSX.Element;
+type MessageEditFormProps = Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> & {
+    /** Save button label. @default "Save" */
+    saveLabel?: string;
+    /** Cancel button label. @default "Cancel" */
+    cancelLabel?: string;
+};
+/** The inline editor: an autofocused textarea + Save/Cancel, Enter/Esc wired. */
+declare const MessageEditForm: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> & {
+    /** Save button label. @default "Save" */
+    saveLabel?: string;
+    /** Cancel button label. @default "Cancel" */
+    cancelLabel?: string;
+} & react.RefAttributes<HTMLFormElement>>;
+type MessageEditContentProps = HTMLAttributes<HTMLDivElement>;
+/** Renders `children` in display mode, or the inline editor while editing. */
+declare const MessageEditContent: react.ForwardRefExoticComponent<MessageEditContentProps & react.RefAttributes<HTMLDivElement>>;
+type MessageEditTriggerProps = React.ComponentProps<typeof Button>;
+/** Begins editing. Focus is restored here on cancel/submit. Hidden while editing. */
+declare const MessageEditTrigger: react.ForwardRefExoticComponent<Omit<_elabs_ai_components_ui.ButtonProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+interface MessageEditProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSubmit" | "children"> {
+    /** The editable source text. */
+    value: string;
+    /** Called with the new text on save (consumer creates the branch). */
+    onEditSubmit?: (newText: string) => void;
+    /** Controlled editing state. */
+    editing?: boolean;
+    /** Uncontrolled initial editing state. */
+    defaultEditing?: boolean;
+    /** Called when editing begins/ends. */
+    onEditingChange?: (editing: boolean) => void;
+    /** The display content (usually the rendered message text). */
+    children: ReactNode;
+}
+/**
+ * Convenience composition: display `children` + an "Edit" trigger, swapping to
+ * the inline editor while editing. For toolbar-placed triggers, compose the
+ * parts (`MessageEditProvider` + `MessageEditTrigger` in your toolbar).
+ */
+declare const MessageEdit: react.ForwardRefExoticComponent<MessageEditProps & react.RefAttributes<HTMLDivElement>>;
+
+type FeedbackType = "positive" | "negative";
+declare const messageFeedbackVariants: (props?: ({
+    compact?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface MessageFeedbackProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSubmit" | "defaultValue">, VariantProps<typeof messageFeedbackVariants> {
+    /** Controlled selected feedback. When set, `onSubmit` is the only updater. */
+    value?: FeedbackType | null;
+    /** Uncontrolled initial selection. @default null */
+    defaultValue?: FeedbackType | null;
+    /** Called once with the chosen feedback. No persistence — host-owned. */
+    onSubmit?: (feedback: {
+        type: FeedbackType;
+    }) => void;
+    /** Force-disable both controls (e.g. while the message is still streaming). */
+    disabled?: boolean;
+    /** aria-label for the positive control. @default "Good response" */
+    positiveLabel?: string;
+    /** aria-label for the negative control. @default "Bad response" */
+    negativeLabel?: string;
+}
+/**
+ * Two icon buttons. The chosen one stays prominent after submit; the other
+ * recedes. `compact` tightens spacing/size for message toolbars.
+ */
+declare const MessageFeedback: react.ForwardRefExoticComponent<MessageFeedbackProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * message-form-spec.ts — Serializable FormSpec for MessageForm.
+ *
+ * These are pure data types + zod schemas with no React dependency. The shape is
+ * what an LLM tool-call emits when it wants the user to fill in a form inside a
+ * chat message. It is deliberately compatible with MCP elicitation's
+ * `requestedSchema` (spec 2025-11-25): flat primitive fields (string / number /
+ * integer / boolean / single- and multi-select enum), each with a label,
+ * optional description, `required`, and a `default`.
+ *
+ * The exported zod schemas are the source of truth downstream catalogs compile
+ * prompts + validators from. Field types are intentionally limited to the safe
+ * set — there is NO file input and NO password/credential type/format, so a spec
+ * that asks for one fails validation (rejected, never rendered).
+ */
+
+/** A single enum choice: a plain value, or a `{ const, title }` pair. */
+declare const enumOptionSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    const: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    const: string;
+    title?: string | undefined;
+}, {
+    const: string;
+    title?: string | undefined;
+}>]>;
+type EnumOption = z.infer<typeof enumOptionSchema>;
+/** The submitted value of an enum option. */
+declare function optionValue(option: EnumOption): string;
+/** The display label of an enum option (falls back to its value). */
+declare function optionLabel(option: EnumOption): string;
+/**
+ * A single-line or multi-line text field.
+ * `format` narrows the input type + validation. Note there is NO `"password"`
+ * format — credential capture is deliberately unsupported.
+ */
+declare const stringFieldSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["email", "uri", "date", "date-time"]>>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /** A serialized RegExp source string (client-enforced when present). */
+    pattern: z.ZodOptional<z.ZodString>;
+    /** Render a textarea instead of a single-line input. */
+    multiline: z.ZodOptional<z.ZodBoolean>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"string">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "string";
+    label?: string | undefined;
+    default?: string | undefined;
+    format?: "email" | "date" | "uri" | "date-time" | undefined;
+    pattern?: string | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+    multiline?: boolean | undefined;
+}, {
+    name: string;
+    type: "string";
+    label?: string | undefined;
+    default?: string | undefined;
+    format?: "email" | "date" | "uri" | "date-time" | undefined;
+    pattern?: string | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+    multiline?: boolean | undefined;
+}>;
+type StringFieldSpec = z.infer<typeof stringFieldSchema>;
+/** A floating-point number field. */
+declare const numberFieldSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"number">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "number";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "number";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>;
+type NumberFieldSpec = z.infer<typeof numberFieldSchema>;
+/** A whole-number field. */
+declare const integerFieldSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"integer">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "integer";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "integer";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>;
+type IntegerFieldSpec = z.infer<typeof integerFieldSchema>;
+/** A boolean checkbox field. */
+declare const booleanFieldSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodBoolean>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"boolean">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "boolean";
+    label?: string | undefined;
+    default?: boolean | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "boolean";
+    label?: string | undefined;
+    default?: boolean | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>;
+type BooleanFieldSpec = z.infer<typeof booleanFieldSchema>;
+/** A single-select enum (one value from `options`). */
+declare const enumFieldSchema: z.ZodObject<{
+    options: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        const: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        const: string;
+        title?: string | undefined;
+    }, {
+        const: string;
+        title?: string | undefined;
+    }>]>, "many">;
+    default: z.ZodOptional<z.ZodString>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"enum">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>;
+type EnumFieldSpec = z.infer<typeof enumFieldSchema>;
+/** A multi-select enum (zero or more values from `options`). */
+declare const multiEnumFieldSchema: z.ZodObject<{
+    options: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        const: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        const: string;
+        title?: string | undefined;
+    }, {
+        const: string;
+        title?: string | undefined;
+    }>]>, "many">;
+    default: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"multi-enum">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "multi-enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string[] | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "multi-enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string[] | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>;
+type MultiEnumFieldSpec = z.infer<typeof multiEnumFieldSchema>;
+/** Any one field in a FormSpec. */
+declare const fieldSpecSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    default: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["email", "uri", "date", "date-time"]>>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /** A serialized RegExp source string (client-enforced when present). */
+    pattern: z.ZodOptional<z.ZodString>;
+    /** Render a textarea instead of a single-line input. */
+    multiline: z.ZodOptional<z.ZodBoolean>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"string">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "string";
+    label?: string | undefined;
+    default?: string | undefined;
+    format?: "email" | "date" | "uri" | "date-time" | undefined;
+    pattern?: string | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+    multiline?: boolean | undefined;
+}, {
+    name: string;
+    type: "string";
+    label?: string | undefined;
+    default?: string | undefined;
+    format?: "email" | "date" | "uri" | "date-time" | undefined;
+    pattern?: string | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+    multiline?: boolean | undefined;
+}>, z.ZodObject<{
+    default: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"number">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "number";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "number";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    default: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"integer">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "integer";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "integer";
+    label?: string | undefined;
+    default?: number | undefined;
+    max?: number | undefined;
+    min?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    default: z.ZodOptional<z.ZodBoolean>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"boolean">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "boolean";
+    label?: string | undefined;
+    default?: boolean | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "boolean";
+    label?: string | undefined;
+    default?: boolean | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    options: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        const: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        const: string;
+        title?: string | undefined;
+    }, {
+        const: string;
+        title?: string | undefined;
+    }>]>, "many">;
+    default: z.ZodOptional<z.ZodString>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"enum">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    options: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        const: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        const: string;
+        title?: string | undefined;
+    }, {
+        const: string;
+        title?: string | undefined;
+    }>]>, "many">;
+    default: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Value key in the emitted form state (the `values` object key). */
+    name: z.ZodString;
+    /** Human label. Falls back to a humanized `name` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** Helper text shown under the control. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether a value is required before the form can submit. */
+    required: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"multi-enum">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "multi-enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string[] | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    type: "multi-enum";
+    options: (string | {
+        const: string;
+        title?: string | undefined;
+    })[];
+    label?: string | undefined;
+    default?: string[] | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+}>]>;
+type FieldSpec = z.infer<typeof fieldSpecSchema>;
+/**
+ * The serializable form specification produced by an LLM tool-call.
+ * MessageForm reads this, renders the fields, and emits `{ formName, values }`.
+ *
+ * Export target for downstream catalogs: compile the prompt + a validator from
+ * `formSpecSchema`.
+ */
+declare const formSpecSchema: z.ZodObject<{
+    /** Stable identifier echoed back in the submit payload. */
+    formName: z.ZodString;
+    /** Heading rendered above the fields (also the accessible form name). */
+    title: z.ZodOptional<z.ZodString>;
+    /** Supplemental description under the title. */
+    description: z.ZodOptional<z.ZodString>;
+    /** The ordered fields to render. */
+    fields: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        default: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<["email", "uri", "date", "date-time"]>>;
+        minLength: z.ZodOptional<z.ZodNumber>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        /** A serialized RegExp source string (client-enforced when present). */
+        pattern: z.ZodOptional<z.ZodString>;
+        /** Render a textarea instead of a single-line input. */
+        multiline: z.ZodOptional<z.ZodBoolean>;
+        /** Value key in the emitted form state (the `values` object key). */
+        name: z.ZodString;
+        /** Human label. Falls back to a humanized `name` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** Helper text shown under the control. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether a value is required before the form can submit. */
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"string">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "string";
+        label?: string | undefined;
+        default?: string | undefined;
+        format?: "email" | "date" | "uri" | "date-time" | undefined;
+        pattern?: string | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+        multiline?: boolean | undefined;
+    }, {
+        name: string;
+        type: "string";
+        label?: string | undefined;
+        default?: string | undefined;
+        format?: "email" | "date" | "uri" | "date-time" | undefined;
+        pattern?: string | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+        multiline?: boolean | undefined;
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        /** Value key in the emitted form state (the `values` object key). */
+        name: z.ZodString;
+        /** Human label. Falls back to a humanized `name` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** Helper text shown under the control. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether a value is required before the form can submit. */
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"number">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "number";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }, {
+        name: string;
+        type: "number";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        /** Value key in the emitted form state (the `values` object key). */
+        name: z.ZodString;
+        /** Human label. Falls back to a humanized `name` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** Helper text shown under the control. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether a value is required before the form can submit. */
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"integer">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "integer";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }, {
+        name: string;
+        type: "integer";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodBoolean>;
+        /** Value key in the emitted form state (the `values` object key). */
+        name: z.ZodString;
+        /** Human label. Falls back to a humanized `name` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** Helper text shown under the control. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether a value is required before the form can submit. */
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"boolean">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "boolean";
+        label?: string | undefined;
+        default?: boolean | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }, {
+        name: string;
+        type: "boolean";
+        label?: string | undefined;
+        default?: boolean | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }>, z.ZodObject<{
+        options: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            const: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            const: string;
+            title?: string | undefined;
+        }, {
+            const: string;
+            title?: string | undefined;
+        }>]>, "many">;
+        default: z.ZodOptional<z.ZodString>;
+        /** Value key in the emitted form state (the `values` object key). */
+        name: z.ZodString;
+        /** Human label. Falls back to a humanized `name` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** Helper text shown under the control. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether a value is required before the form can submit. */
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"enum">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }, {
+        name: string;
+        type: "enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }>, z.ZodObject<{
+        options: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            const: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            const: string;
+            title?: string | undefined;
+        }, {
+            const: string;
+            title?: string | undefined;
+        }>]>, "many">;
+        default: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Value key in the emitted form state (the `values` object key). */
+        name: z.ZodString;
+        /** Human label. Falls back to a humanized `name` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** Helper text shown under the control. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether a value is required before the form can submit. */
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"multi-enum">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "multi-enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string[] | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }, {
+        name: string;
+        type: "multi-enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string[] | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    }>]>, "many">;
+    /** Submit button label. @default "Submit" */
+    submitLabel: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    formName: string;
+    fields: ({
+        name: string;
+        type: "string";
+        label?: string | undefined;
+        default?: string | undefined;
+        format?: "email" | "date" | "uri" | "date-time" | undefined;
+        pattern?: string | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+        multiline?: boolean | undefined;
+    } | {
+        name: string;
+        type: "number";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "integer";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "boolean";
+        label?: string | undefined;
+        default?: boolean | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "multi-enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string[] | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    })[];
+    title?: string | undefined;
+    description?: string | undefined;
+    submitLabel?: string | undefined;
+}, {
+    formName: string;
+    fields: ({
+        name: string;
+        type: "string";
+        label?: string | undefined;
+        default?: string | undefined;
+        format?: "email" | "date" | "uri" | "date-time" | undefined;
+        pattern?: string | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+        multiline?: boolean | undefined;
+    } | {
+        name: string;
+        type: "number";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "integer";
+        label?: string | undefined;
+        default?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "boolean";
+        label?: string | undefined;
+        default?: boolean | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    } | {
+        name: string;
+        type: "multi-enum";
+        options: (string | {
+            const: string;
+            title?: string | undefined;
+        })[];
+        label?: string | undefined;
+        default?: string[] | undefined;
+        required?: boolean | undefined;
+        description?: string | undefined;
+    })[];
+    title?: string | undefined;
+    description?: string | undefined;
+    submitLabel?: string | undefined;
+}>;
+type FormSpec = z.infer<typeof formSpecSchema>;
+/** A single field's value in the form state. */
+type FormValue = string | number | boolean | string[] | undefined;
+/** The `values` object keyed by field `name`. */
+type FormValues = Record<string, FormValue>;
+/** The payload passed to `onSubmit`. */
+interface FormSubmitState {
+    /** Echoes `spec.formName`. */
+    formName: string;
+    /** The current field values keyed by field name. */
+    values: FormValues;
+}
+/** A validated, render-ready FormSpec. */
+interface NormalizedFormSpec {
+    formName: string;
+    title?: string;
+    description?: string;
+    submitLabel?: string;
+    fields: FieldSpec[];
+}
+/**
+ * Lenient parse for the render path. Mirrors AutoChart's guard philosophy:
+ * NEVER throws. Individually invalid or half-streamed fields are dropped (not
+ * fatal), so a partial spec still renders progressively. Returns `{ ok: false }`
+ * only when the whole spec is unusable (not an object) — the caller then shows
+ * `MessageFormFallback`.
+ */
+declare function normalizeFormSpec(spec: unknown): {
+    ok: true;
+    spec: NormalizedFormSpec;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The label to show for a field (explicit `label`, else a humanized `name`). */
+declare function fieldLabel(field: FieldSpec): string;
+/** Seed the initial values from each field's `default` (+ sensible empties). */
+declare function initialFormValues(fields: FieldSpec[]): FormValues;
+/**
+ * Validate one field's value against its declarative constraints.
+ * Returns a short human error message, or `null` when the value is valid.
+ * The vocabulary: required · email · url · min · max · minLength · maxLength ·
+ * pattern · numeric (integer whole-number).
+ */
+declare function validateField(field: FieldSpec, value: FormValue): string | null;
+/** Validate every field; returns a `{ [name]: error | null }` map. */
+declare function validateForm(fields: FieldSpec[], values: FormValues): Record<string, string | null>;
+
+interface MessageFormProviderProps {
+    /** A validated/normalized spec (a plain `FormSpec` also satisfies this). */
+    spec: NormalizedFormSpec;
+    /**
+     * Controlled values. When provided the component is controlled and `onChange`
+     * is the only way to update state.
+     */
+    values?: FormValues;
+    /** Called with the next full values object on any field change. */
+    onChange?: (values: FormValues) => void;
+    /** Called with `{ formName, values }` when a valid form is submitted. */
+    onSubmit?: (state: FormSubmitState) => void;
+    /** Disable every control (form is not interactable). */
+    disabled?: boolean;
+    /** Terminal submitted state: controls are inert, values visible, no submit. */
+    submitted?: boolean;
+    /** In-flight submit: controls disabled, the submit button shows a spinner. */
+    submitting?: boolean;
+    /** The spec is still streaming in (renders a skeleton when no fields yet). */
+    streaming?: boolean;
+    children: ReactNode;
+}
+/**
+ * Lifts the form values. Controlled (pass `values`) or uncontrolled.
+ * Derives `isControlled = values !== undefined` and never flips modes.
+ */
+declare function MessageFormProvider({ spec, values: valuesProp, onChange, onSubmit, disabled, submitted, submitting, streaming, children, }: MessageFormProviderProps): react.JSX.Element;
+interface MessageFormFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The field's `name` (its key in the spec + values). */
+    name: string;
+}
+/**
+ * Renders one field by name: label, control, description, inline error.
+ * Boolean fields render their own inline label (checkbox + label), so the
+ * standalone `<Label>` above is suppressed for them.
+ */
+declare const MessageFormField: react.ForwardRefExoticComponent<MessageFormFieldProps & react.RefAttributes<HTMLDivElement>>;
+type MessageFormFieldsProps = HTMLAttributes<HTMLDivElement>;
+/** Renders every field in the spec, in order. A skeleton while streaming empty. */
+declare const MessageFormFields: react.ForwardRefExoticComponent<MessageFormFieldsProps & react.RefAttributes<HTMLDivElement>>;
+interface MessageFormSubmitProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Submit button label (overrides `spec.submitLabel`). @default "Submit" */
+    label?: string;
+}
+/**
+ * The submit affordance. Enabled until the request starts (validation runs on
+ * click), then a spinner. A submitted form shows an inert "Submitted" note.
+ */
+declare const MessageFormSubmit: react.ForwardRefExoticComponent<MessageFormSubmitProps & react.RefAttributes<HTMLDivElement>>;
+type MessageFormRootProps = Omit<HTMLAttributes<HTMLFormElement>, "onSubmit">;
+/**
+ * The `<form>` element wired to the context's `submit`. Never nest inside
+ * another `<form>` — compose it as its own message-body block.
+ */
+declare const MessageFormRoot: react.ForwardRefExoticComponent<MessageFormRootProps & react.RefAttributes<HTMLFormElement>>;
+type MessageFormTitleProps = HTMLAttributes<HTMLParagraphElement>;
+/** The form heading. Its id is the `<form>`'s `aria-labelledby` target. */
+declare const MessageFormTitle: react.ForwardRefExoticComponent<MessageFormTitleProps & react.RefAttributes<HTMLParagraphElement>>;
+type MessageFormDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+/** Supplemental description under the title. */
+declare const MessageFormDescription: react.ForwardRefExoticComponent<MessageFormDescriptionProps & react.RefAttributes<HTMLParagraphElement>>;
+interface MessageFormFallbackProps extends HTMLAttributes<HTMLDivElement> {
+    /** Short human reason the form could not render. */
+    message?: string;
+}
+/**
+ * Shown when the spec is unusable. Mirrors `ChartFallback`: a calm, bordered
+ * status box with a short reason — never a thrown error.
+ */
+declare const MessageFormFallback: react.ForwardRefExoticComponent<MessageFormFallbackProps & react.RefAttributes<HTMLDivElement>>;
+interface MessageFormProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSubmit" | "onChange" | "title"> {
+    /** The serializable form specification produced by an LLM tool-call. */
+    spec: FormSpec | unknown;
+    /** Controlled values (`{ [fieldName]: value }`). Omit for uncontrolled. */
+    values?: FormValues;
+    /** Called with the next full values object on any change. */
+    onChange?: (values: FormValues) => void;
+    /** Called with `{ formName, values }` on a valid submit. */
+    onSubmit?: (state: FormSubmitState) => void;
+    /** Submit button label (overrides `spec.submitLabel`). */
+    submitLabel?: string;
+    /** Disable every control. */
+    disabled?: boolean;
+    /** Terminal submitted state: inert, values visible, submit replaced. */
+    submitted?: boolean;
+    /** In-flight submit: controls disabled, spinner on submit. */
+    submitting?: boolean;
+    /** The spec is still streaming (renders a skeleton when no fields yet). */
+    streaming?: boolean;
+}
+/**
+ * Convenience composition: `Provider → Root(form) → title/description → Fields →
+ * Submit`. For a custom layout, compose `MessageFormProvider` + the parts.
+ * A malformed spec renders `MessageFormFallback` (never throws).
+ */
+declare const MessageForm: react.ForwardRefExoticComponent<MessageFormProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * message-table-spec.ts — Serializable TableSpec for MessageTable.
+ *
+ * Pure data types + zod schemas (no React). The shape is what an LLM tool-call
+ * emits when it wants to show tabular data inside a chat message. It is
+ * column-oriented: `columns` declare the shape + per-column `format`, and each
+ * `rows` entry is an object keyed by column `key`.
+ *
+ * The exported zod schemas are the source of truth downstream catalogs compile
+ * prompts + validators from. Specs carry NO style-bearing props — the model
+ * chooses the data and its semantic format, never the look.
+ */
+
+/**
+ * How a cell's value is rendered + aligned.
+ * - `text` (default) — as-is, start-aligned.
+ * - `number` / `currency` / `percent` — `Intl`-formatted, end-aligned, tabular.
+ * - `date` — localized date.
+ * - `badge` — a tonal badge whose tone is inferred from the value's semantics.
+ */
+declare const cellFormatSchema: z.ZodEnum<["text", "number", "currency", "percent", "date", "badge"]>;
+type CellFormat = z.infer<typeof cellFormatSchema>;
+/** One column definition. */
+declare const columnSpecSchema: z.ZodObject<{
+    /** The row-object key this column reads. */
+    key: z.ZodString;
+    /** Header label. Falls back to the `key` when omitted. */
+    label: z.ZodOptional<z.ZodString>;
+    /** How cells in this column are formatted + aligned. @default "text" */
+    format: z.ZodOptional<z.ZodEnum<["text", "number", "currency", "percent", "date", "badge"]>>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    label?: string | undefined;
+    format?: "number" | "text" | "percent" | "currency" | "date" | "badge" | undefined;
+}, {
+    key: string;
+    label?: string | undefined;
+    format?: "number" | "text" | "percent" | "currency" | "date" | "badge" | undefined;
+}>;
+type ColumnSpec = z.infer<typeof columnSpecSchema>;
+/** A single row: an object keyed by column `key`. */
+type TableRowData = Record<string, unknown>;
+/**
+ * The serializable table specification produced by an LLM tool-call.
+ * MessageTable reads this and renders a lightweight, message-body table.
+ */
+declare const tableSpecSchema: z.ZodObject<{
+    /** Optional heading + accessible label for the table. */
+    title: z.ZodOptional<z.ZodString>;
+    /** Ordered column definitions. */
+    columns: z.ZodArray<z.ZodObject<{
+        /** The row-object key this column reads. */
+        key: z.ZodString;
+        /** Header label. Falls back to the `key` when omitted. */
+        label: z.ZodOptional<z.ZodString>;
+        /** How cells in this column are formatted + aligned. @default "text" */
+        format: z.ZodOptional<z.ZodEnum<["text", "number", "currency", "percent", "date", "badge"]>>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        label?: string | undefined;
+        format?: "number" | "text" | "percent" | "currency" | "date" | "badge" | undefined;
+    }, {
+        key: string;
+        label?: string | undefined;
+        format?: "number" | "text" | "percent" | "currency" | "date" | "badge" | undefined;
+    }>, "many">;
+    /** Row objects keyed by column `key`. */
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    /** Message shown when there are zero rows. @default "No rows to display" */
+    emptyText: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    columns: {
+        key: string;
+        label?: string | undefined;
+        format?: "number" | "text" | "percent" | "currency" | "date" | "badge" | undefined;
+    }[];
+    rows: Record<string, unknown>[];
+    title?: string | undefined;
+    emptyText?: string | undefined;
+}, {
+    columns: {
+        key: string;
+        label?: string | undefined;
+        format?: "number" | "text" | "percent" | "currency" | "date" | "badge" | undefined;
+    }[];
+    rows: Record<string, unknown>[];
+    title?: string | undefined;
+    emptyText?: string | undefined;
+}>;
+type TableSpec = z.infer<typeof tableSpecSchema>;
+/** A validated, render-ready TableSpec. */
+interface NormalizedTableSpec {
+    title?: string;
+    columns: ColumnSpec[];
+    rows: TableRowData[];
+    emptyText?: string;
+}
+/**
+ * Lenient parse for the render path. NEVER throws. Individually invalid columns
+ * are dropped and non-object rows are filtered out, so a partial (streaming)
+ * spec still renders progressively. Returns `{ ok: false }` only when the whole
+ * spec is unusable (not an object).
+ */
+declare function normalizeTableSpec(spec: unknown): {
+    ok: true;
+    spec: NormalizedTableSpec;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The em-dash shown for a missing / empty cell. */
+declare const EMPTY_CELL = "\u2014";
+/** Whether a format is numeric (drives end-alignment + `tabular-nums`). */
+declare function isNumericFormat(format: CellFormat | undefined): boolean;
+/** Whether a value is considered empty (renders the em-dash). */
+declare function isEmptyCell(value: unknown): boolean;
+/**
+ * Format a present value to a display string per its column format.
+ * Unknown formats fall through to `String(value)` (never throws). Empty values
+ * are the caller's concern (render `EMPTY_CELL`). `percent` follows `Intl`
+ * semantics — pass fractions (0.42 → "42%").
+ */
+declare function formatCellValue(value: unknown, format: CellFormat | undefined): string;
+type BadgeTone = "secondary" | "success" | "warning" | "destructive" | "info";
+/** Infer a badge tone from a value's semantics (status vocabulary). */
+declare function badgeToneForValue(value: unknown): BadgeTone;
+/** Compare two cell values for sorting, honoring numeric/date formats. */
+declare function compareCellValues(a: unknown, b: unknown, format: CellFormat | undefined): number;
+
+interface TableSort {
+    /** The sorted column's key. */
+    key: string;
+    direction: "asc" | "desc";
+}
+/** Per-cell render override — return `undefined` to fall back to default rendering. */
+type RenderCell = (args: {
+    value: unknown;
+    column: ColumnSpec;
+    row: TableRowData;
+    rowIndex: number;
+}) => ReactNode;
+interface MessageTableFallbackProps extends HTMLAttributes<HTMLDivElement> {
+    /** Short human reason the table could not render. */
+    message?: string;
+}
+/** Shown when the spec is unusable. Mirrors `ChartFallback` semantics. */
+declare const MessageTableFallback: react.ForwardRefExoticComponent<MessageTableFallbackProps & react.RefAttributes<HTMLDivElement>>;
+interface MessageTableProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** The serializable table specification produced by an LLM tool-call. */
+    spec: TableSpec | unknown;
+    /** Enable click-to-sort column headers. @default false */
+    sortable?: boolean;
+    /** Controlled sort. When provided, `onSortChange` is the only way to update it. */
+    sort?: TableSort | null;
+    /** Uncontrolled initial sort. */
+    defaultSort?: TableSort | null;
+    /** Called with the next sort (or `null`) when a header is clicked. */
+    onSortChange?: (sort: TableSort | null) => void;
+    /** Cap the number of rendered rows; shows a "Showing N of M rows" notice. */
+    maxRows?: number;
+    /** Per-cell render override for custom composition. */
+    renderCell?: RenderCell;
+    /** The spec is still streaming (columns-but-no-rows shows skeleton rows). */
+    streaming?: boolean;
+}
+/**
+ * MessageTable — renders a `TableSpec` as a lightweight message-body table.
+ *
+ * Intentionally bare: no toolbar, no expand chrome. Growing one here would be
+ * `ChartFrame` re-implemented inside this package.
+ *
+ * **To make it expandable, wrap it in `ExpandDialog`**
+ * (`@elabs-ai/components-ui`) — the shared two-pane expand surface,
+ * the same one a chart opens. Do NOT hand-roll a lightbox or a full-screen
+ * breakout; four of those already existed before the component was shared, and
+ * each one taught users a different meaning for the same button.
+ *
+ * The context pane for a table is its SHAPE, not statistics: row count,
+ * "showing N of M", column count, each column's declared `format`. A
+ * model-emitted table's numerics may already be formatted strings, so min/max/avg
+ * over them is wrong more often than right.
+ */
+declare const MessageTable: react.ForwardRefExoticComponent<MessageTableProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const useAudioDevices: () => {
+    devices: MediaDeviceInfo[];
+    error: string | null;
+    hasPermission: boolean;
+    loadDevices: () => Promise<void>;
+    loading: boolean;
+};
+type MicSelectorProps = ComponentProps<typeof Popover> & {
+    defaultValue?: string;
+    value?: string | undefined;
+    onValueChange?: (value: string | undefined) => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare const MicSelector: ({ defaultValue, value: controlledValue, onValueChange: controlledOnValueChange, defaultOpen, open: controlledOpen, onOpenChange: controlledOnOpenChange, ...props }: MicSelectorProps) => react.JSX.Element;
+type MicSelectorTriggerProps = ComponentProps<typeof Button>;
+declare const MicSelectorTrigger: ({ children, ...props }: MicSelectorTriggerProps) => react.JSX.Element;
+type MicSelectorContentProps = ComponentProps<typeof Command> & {
+    popoverOptions?: ComponentProps<typeof PopoverContent>;
+};
+declare const MicSelectorContent: ({ className, popoverOptions, ...props }: MicSelectorContentProps) => react.JSX.Element;
+type MicSelectorInputProps = ComponentProps<typeof CommandInput> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+declare const MicSelectorInput: ({ ...props }: MicSelectorInputProps) => react.JSX.Element;
+type MicSelectorListProps = Omit<ComponentProps<typeof CommandList>, "children"> & {
+    children: (devices: MediaDeviceInfo[]) => ReactNode;
+};
+declare const MicSelectorList: ({ children, ...props }: MicSelectorListProps) => react.JSX.Element;
+type MicSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+declare const MicSelectorEmpty: ({ children, ...props }: MicSelectorEmptyProps) => react.JSX.Element;
+type MicSelectorItemProps = ComponentProps<typeof CommandItem>;
+declare const MicSelectorItem: (props: MicSelectorItemProps) => react.JSX.Element;
+type MicSelectorLabelProps = ComponentProps<"span"> & {
+    device: MediaDeviceInfo;
+};
+declare const MicSelectorLabel: ({ device, className, ...props }: MicSelectorLabelProps) => react.JSX.Element;
+type MicSelectorValueProps = ComponentProps<"span">;
+declare const MicSelectorValue: ({ className, ...props }: MicSelectorValueProps) => react.JSX.Element;
+
+type ModelSelectorProps = ComponentProps<typeof Dialog>;
+declare const ModelSelector: (props: ModelSelectorProps) => react.JSX.Element;
+type ModelSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+declare const ModelSelectorTrigger: (props: ModelSelectorTriggerProps) => react.JSX.Element;
+type ModelSelectorContentProps = ComponentProps<typeof DialogContent> & {
+    title?: ReactNode;
+};
+declare const ModelSelectorContent: ({ className, children, title, ...props }: ModelSelectorContentProps) => react.JSX.Element;
+type ModelSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+declare const ModelSelectorDialog: (props: ModelSelectorDialogProps) => react.JSX.Element;
+type ModelSelectorInputProps = ComponentProps<typeof CommandInput>;
+declare const ModelSelectorInput: ({ className, ...props }: ModelSelectorInputProps) => react.JSX.Element;
+type ModelSelectorListProps = ComponentProps<typeof CommandList>;
+declare const ModelSelectorList: (props: ModelSelectorListProps) => react.JSX.Element;
+type ModelSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+declare const ModelSelectorEmpty: (props: ModelSelectorEmptyProps) => react.JSX.Element;
+type ModelSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+declare const ModelSelectorGroup: (props: ModelSelectorGroupProps) => react.JSX.Element;
+type ModelSelectorItemProps = ComponentProps<typeof CommandItem>;
+declare const ModelSelectorItem: (props: ModelSelectorItemProps) => react.JSX.Element;
+type ModelSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+declare const ModelSelectorShortcut: (props: ModelSelectorShortcutProps) => react.JSX.Element;
+type ModelSelectorSeparatorProps = ComponentProps<typeof CommandSeparator>;
+declare const ModelSelectorSeparator: (props: ModelSelectorSeparatorProps) => react.JSX.Element;
+/**
+ * Where provider logos are fetched from by default.
+ *
+ * This is a REMOTE origin: a deployment with a restrictive `img-src` blocks it.
+ * Self-host the SVGs and pass `src` (or set a `fallback`) — see
+ * `docs/CSP-AND-NETWORK.md`.
+ */
+declare const MODEL_SELECTOR_LOGO_BASE_URL = "https://models.dev/logos";
+type ModelSelectorLogoProps = Omit<ComponentProps<"img">, "alt"> & {
+    /**
+     * Override the logo URL — point at a self-hosted or bundled asset when a CSP
+     * blocks `models.dev`. Defaults to `${MODEL_SELECTOR_LOGO_BASE_URL}/<provider>.svg`.
+     */
+    src?: string;
+    /**
+     * Rendered when the logo fails to load (blocked, offline, or unknown
+     * provider). Defaults to a neutral Lucide glyph, so the row never collapses
+     * to a broken image.
+     */
+    fallback?: ReactNode;
+    provider: "moonshotai-cn" | "lucidquery" | "moonshotai" | "zai-coding-plan" | "alibaba" | "xai" | "vultr" | "nvidia" | "upstage" | "groq" | "github-copilot" | "mistral" | "vercel" | "nebius" | "deepseek" | "alibaba-cn" | "google-vertex-anthropic" | "venice" | "chutes" | "cortecs" | "github-models" | "togetherai" | "azure" | "baseten" | "huggingface" | "opencode" | "fastrouter" | "google" | "google-vertex" | "cloudflare-workers-ai" | "inception" | "wandb" | "openai" | "zhipuai-coding-plan" | "perplexity" | "openrouter" | "zenmux" | "v0" | "iflowcn" | "synthetic" | "deepinfra" | "zhipuai" | "submodel" | "zai" | "inference" | "requesty" | "morph" | "lmstudio" | "anthropic" | "aihubmix" | "fireworks-ai" | "modelscope" | "llama" | "scaleway" | "amazon-bedrock" | "cerebras" | (string & {});
+};
+declare const ModelSelectorLogo: ({ provider, className, src, fallback, onError, ...props }: ModelSelectorLogoProps) => react.JSX.Element;
+type ModelSelectorLogoGroupProps = ComponentProps<"div">;
+declare const ModelSelectorLogoGroup: ({ className, ...props }: ModelSelectorLogoGroupProps) => react.JSX.Element;
+type ModelSelectorNameProps = ComponentProps<"span">;
+declare const ModelSelectorName: ({ className, ...props }: ModelSelectorNameProps) => react.JSX.Element;
+
+interface BrandMotionConfigProps {
+    children: ReactNode;
+    /** Override the default transition handed to descendant Motion components. */
+    transition?: Transition;
+}
+/**
+ * App-level wrapper that bridges the brand-ui motion preference into Motion
+ * (motion.dev). It drives Motion's `reducedMotion` from `useReducedMotion()`
+ * (user choice > OS setting) so JS-driven Motion components honor the SAME gate
+ * as the CSS `--motion-factor` layer, and supplies a token-mirrored default
+ * transition. Provider-OPTIONAL: without a `<ThemeProvider>` it degrades to
+ * OS-only reduced-motion detection.
+ *
+ * Wrap the Motion-using subtree (e.g. the chat surface) once near the app root.
+ *
+ * NOTE: Motion's `reducedMotion="always"` disables only transform/layout
+ * animations (opacity/color persist — "reduced != none"). Components that loop
+ * on other properties (e.g. {@link Shimmer}, which animates backgroundPosition)
+ * must still branch on `useReducedMotion()` themselves.
+ */
+declare function BrandMotionConfig({ children, transition, }: BrandMotionConfigProps): react.JSX.Element;
+
+type NodeProps = ComponentProps<typeof Card> & {
+    handles: {
+        target: boolean;
+        source: boolean;
+    };
+};
+declare const Node: (props: NodeProps) => react.JSX.Element;
+type NodeHeaderProps = ComponentProps<typeof CardHeader>;
+declare const NodeHeader: ({ className, ...props }: NodeHeaderProps) => react.JSX.Element;
+type NodeTitleProps = ComponentProps<typeof CardTitle>;
+declare const NodeTitle: (props: NodeTitleProps) => react.JSX.Element;
+type NodeDescriptionProps = ComponentProps<typeof CardDescription>;
+declare const NodeDescription: (props: NodeDescriptionProps) => react.JSX.Element;
+type NodeActionProps = ComponentProps<typeof CardAction>;
+declare const NodeAction: (props: NodeActionProps) => react.JSX.Element;
+type NodeContentProps = ComponentProps<typeof CardContent>;
+declare const NodeContent: ({ className, ...props }: NodeContentProps) => react.JSX.Element;
+type NodeFooterProps = ComponentProps<typeof CardFooter>;
+declare const NodeFooter: ({ className, ...props }: NodeFooterProps) => react.JSX.Element;
+
+type OpenInProps = ComponentProps<typeof DropdownMenu> & {
+    query: string;
+};
+declare const OpenIn: ({ query, ...props }: OpenInProps) => react.JSX.Element;
+type OpenInContentProps = ComponentProps<typeof DropdownMenuContent>;
+declare const OpenInContent: ({ className, ...props }: OpenInContentProps) => react.JSX.Element;
+type OpenInItemProps = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInItem: (props: OpenInItemProps) => react.JSX.Element;
+type OpenInLabelProps = ComponentProps<typeof DropdownMenuLabel>;
+declare const OpenInLabel: (props: OpenInLabelProps) => react.JSX.Element;
+type OpenInSeparatorProps = ComponentProps<typeof DropdownMenuSeparator>;
+declare const OpenInSeparator: (props: OpenInSeparatorProps) => react.JSX.Element;
+type OpenInTriggerProps = ComponentProps<typeof DropdownMenuTrigger>;
+declare const OpenInTrigger: ({ children, ...props }: OpenInTriggerProps) => react.JSX.Element;
+type OpenInChatGPTProps = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInChatGPT: (props: OpenInChatGPTProps) => react.JSX.Element;
+type OpenInClaudeProps = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInClaude: (props: OpenInClaudeProps) => react.JSX.Element;
+type OpenInT3Props = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInT3: (props: OpenInT3Props) => react.JSX.Element;
+type OpenInSciraProps = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInScira: (props: OpenInSciraProps) => react.JSX.Element;
+type OpenInv0Props = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInv0: (props: OpenInv0Props) => react.JSX.Element;
+type OpenInCursorProps = ComponentProps<typeof DropdownMenuItem>;
+declare const OpenInCursor: (props: OpenInCursorProps) => react.JSX.Element;
+
+type ChangeType = "major" | "minor" | "patch" | "added" | "removed";
+type PackageInfoHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const PackageInfoHeader: ({ className, children, ...props }: PackageInfoHeaderProps) => react.JSX.Element;
+type PackageInfoNameProps = HTMLAttributes<HTMLDivElement>;
+declare const PackageInfoName: ({ className, children, ...props }: PackageInfoNameProps) => react.JSX.Element;
+type PackageInfoChangeTypeProps = HTMLAttributes<HTMLDivElement>;
+declare const PackageInfoChangeType: ({ className, children, ...props }: PackageInfoChangeTypeProps) => react.JSX.Element | null;
+type PackageInfoVersionProps = HTMLAttributes<HTMLDivElement>;
+declare const PackageInfoVersion: ({ className, children, ...props }: PackageInfoVersionProps) => react.JSX.Element | null;
+type PackageInfoProps = HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    currentVersion?: string;
+    newVersion?: string;
+    changeType?: ChangeType;
+};
+declare const PackageInfo: ({ name, currentVersion, newVersion, changeType, className, children, ...props }: PackageInfoProps) => react.JSX.Element;
+type PackageInfoDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+declare const PackageInfoDescription: ({ className, children, ...props }: PackageInfoDescriptionProps) => react.JSX.Element;
+type PackageInfoContentProps = HTMLAttributes<HTMLDivElement>;
+declare const PackageInfoContent: ({ className, children, ...props }: PackageInfoContentProps) => react.JSX.Element;
+type PackageInfoDependenciesProps = HTMLAttributes<HTMLDivElement>;
+declare const PackageInfoDependencies: ({ className, children, ...props }: PackageInfoDependenciesProps) => react.JSX.Element;
+type PackageInfoDependencyProps = HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    version?: string;
+};
+declare const PackageInfoDependency: ({ name, version, className, children, ...props }: PackageInfoDependencyProps) => react.JSX.Element;
+
+type PanelProps = ComponentProps<typeof Panel$1>;
+declare const Panel: (props: PanelProps) => react.JSX.Element;
+
+/**
+ * Persona artwork sources — a plain data module shared by `persona.tsx` (the
+ * public shell) and `_persona-rive.tsx` (the lazily-loaded Rive half), so
+ * neither has to import the other.
+ */
+type PersonaState = "idle" | "listening" | "thinking" | "speaking" | "asleep";
+/**
+ * Where the shipped `.riv` artwork is fetched from.
+ *
+ * ⚠️ These are REMOTE origins fetched at runtime by the Rive runtime — a
+ * deployment with a restrictive `connect-src` blocks them, and the component
+ * falls back to a token-driven orb. Self-host the six files and pass
+ * `<Persona src={…}>` to point at your own copies. See `docs/CSP-AND-NETWORK.md`.
+ */
+declare const PERSONA_SOURCES: {
+    readonly command: {
+        readonly dynamicColor: true;
+        readonly hasModel: true;
+        readonly source: "https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/command-2.0.riv";
+    };
+    readonly glint: {
+        readonly dynamicColor: true;
+        readonly hasModel: true;
+        readonly source: "https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/glint-2.0.riv";
+    };
+    readonly halo: {
+        readonly dynamicColor: true;
+        readonly hasModel: true;
+        readonly source: "https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/halo-2.0.riv";
+    };
+    readonly mana: {
+        readonly dynamicColor: false;
+        readonly hasModel: true;
+        readonly source: "https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/mana-2.0.riv";
+    };
+    readonly obsidian: {
+        readonly dynamicColor: true;
+        readonly hasModel: true;
+        readonly source: "https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/obsidian-2.0.riv";
+    };
+    readonly opal: {
+        readonly dynamicColor: false;
+        readonly hasModel: false;
+        readonly source: "https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/orb-1.2.riv";
+    };
+};
+type PersonaVariant = keyof typeof PERSONA_SOURCES;
+
+interface PersonaProps {
+    className?: string;
+    /**
+     * Rendered while the artwork loads, and permanently if it fails (blocked by a
+     * `connect-src` CSP, offline, or a bad `src`). Defaults to a token-driven orb,
+     * so a blocked fetch never leaves an empty box.
+     */
+    fallback?: ReactNode;
+    onLoad?: RiveParameters["onLoad"];
+    onLoadError?: RiveParameters["onLoadError"];
+    onPause?: RiveParameters["onPause"];
+    onPlay?: RiveParameters["onPlay"];
+    onReady?: () => void;
+    onStop?: RiveParameters["onStop"];
+    /**
+     * Override the `.riv` artwork URL — point at a self-hosted copy when a CSP
+     * blocks the default origin. Defaults to `PERSONA_SOURCES[variant].source`.
+     * Mirrors the `mapStyle` override on `MapCanvas`.
+     */
+    src?: string;
+    state: PersonaState;
+    /**
+     * Visually-hidden text announced when `state` changes. Defaults to a
+     * localized label for the current `state`; pass `null` when the consuming
+     * surface already renders its own `role="status"` line, so AT is not told
+     * twice.
+     */
+    statusLabel?: ReactNode | null;
+    variant?: PersonaVariant;
+}
+declare const Persona: FC<PersonaProps>;
+
+type PlanProps = ComponentProps<typeof Collapsible> & {
+    isStreaming?: boolean;
+};
+declare const Plan: ({ className, isStreaming, children, ...props }: PlanProps) => react.JSX.Element;
+type PlanHeaderProps = ComponentProps<typeof CardHeader>;
+declare const PlanHeader: ({ className, ...props }: PlanHeaderProps) => react.JSX.Element;
+type PlanTitleProps = Omit<ComponentProps<typeof CardTitle>, "children"> & {
+    children: string;
+};
+declare const PlanTitle: ({ children, ...props }: PlanTitleProps) => react.JSX.Element;
+type PlanDescriptionProps = Omit<ComponentProps<typeof CardDescription>, "children"> & {
+    children: string;
+};
+declare const PlanDescription: ({ className, children, ...props }: PlanDescriptionProps) => react.JSX.Element;
+type PlanActionProps = ComponentProps<typeof CardAction>;
+declare const PlanAction: (props: PlanActionProps) => react.JSX.Element;
+type PlanContentProps = ComponentProps<typeof CardContent>;
+declare const PlanContent: ({ className, ...props }: PlanContentProps) => react.JSX.Element;
+type PlanFooterProps = ComponentProps<"div">;
+declare const PlanFooter: (props: PlanFooterProps) => react.JSX.Element;
+type PlanTriggerProps = ComponentProps<typeof CollapsibleTrigger>;
+declare const PlanTrigger: ({ className, ...props }: PlanTriggerProps) => react.JSX.Element;
+
+interface QueueMessagePart {
+    type: string;
+    text?: string;
+    url?: string;
+    filename?: string;
+    mediaType?: string;
+}
+interface QueueMessage {
+    id: string;
+    parts: QueueMessagePart[];
+}
+interface QueueTodo {
+    id: string;
+    title: string;
+    description?: string;
+    status?: "pending" | "completed";
+}
+type QueueItemProps = ComponentProps<"li">;
+declare const QueueItem: ({ className, ...props }: QueueItemProps) => react.JSX.Element;
+type QueueItemIndicatorProps = ComponentProps<"span"> & {
+    completed?: boolean;
+};
+declare const QueueItemIndicator: ({ completed, className, ...props }: QueueItemIndicatorProps) => react.JSX.Element;
+type QueueItemContentProps = ComponentProps<"span"> & {
+    completed?: boolean;
+};
+declare const QueueItemContent: ({ completed, className, ...props }: QueueItemContentProps) => react.JSX.Element;
+type QueueItemDescriptionProps = ComponentProps<"div"> & {
+    completed?: boolean;
+};
+declare const QueueItemDescription: ({ completed, className, ...props }: QueueItemDescriptionProps) => react.JSX.Element;
+type QueueItemActionsProps = ComponentProps<"div">;
+declare const QueueItemActions: ({ className, ...props }: QueueItemActionsProps) => react.JSX.Element;
+type QueueItemActionProps = Omit<ComponentProps<typeof Button>, "variant" | "size">;
+declare const QueueItemAction: ({ className, ...props }: QueueItemActionProps) => react.JSX.Element;
+type QueueItemAttachmentProps = ComponentProps<"div">;
+declare const QueueItemAttachment: ({ className, ...props }: QueueItemAttachmentProps) => react.JSX.Element;
+type QueueItemImageProps = ComponentProps<"img">;
+declare const QueueItemImage: ({ className, ...props }: QueueItemImageProps) => react.JSX.Element;
+type QueueItemFileProps = ComponentProps<"span">;
+declare const QueueItemFile: ({ children, className, ...props }: QueueItemFileProps) => react.JSX.Element;
+type QueueListProps = ComponentProps<typeof ScrollArea>;
+declare const QueueList: ({ children, className, ...props }: QueueListProps) => react.JSX.Element;
+type QueueSectionProps = ComponentProps<typeof Collapsible>;
+declare const QueueSection: ({ className, defaultOpen, ...props }: QueueSectionProps) => react.JSX.Element;
+type QueueSectionTriggerProps = ComponentProps<"button">;
+declare const QueueSectionTrigger: ({ children, className, ...props }: QueueSectionTriggerProps) => react.JSX.Element;
+type QueueSectionLabelProps = ComponentProps<"span"> & {
+    count?: number;
+    label: string;
+    icon?: React.ReactNode;
+};
+declare const QueueSectionLabel: ({ count, label, icon, className, ...props }: QueueSectionLabelProps) => react.JSX.Element;
+type QueueSectionContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const QueueSectionContent: ({ className, ...props }: QueueSectionContentProps) => react.JSX.Element;
+type QueueProps = ComponentProps<"div">;
+declare const Queue: ({ className, ...props }: QueueProps) => react.JSX.Element;
+
+interface ReasoningContextValue {
+    isStreaming: boolean;
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    duration: number | undefined;
+}
+declare const useReasoning: () => ReasoningContextValue;
+type ReasoningProps = ComponentProps<typeof Collapsible> & {
+    isStreaming?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    duration?: number;
+};
+declare const Reasoning: react.MemoExoticComponent<({ className, isStreaming, open, defaultOpen, onOpenChange, duration: durationProp, children, ...props }: ReasoningProps) => react.JSX.Element>;
+type ReasoningTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    getThinkingMessage?: (isStreaming: boolean, duration?: number) => ReactNode;
+};
+declare const ReasoningTrigger: react.MemoExoticComponent<({ className, children, getThinkingMessage, ...props }: ReasoningTriggerProps) => react.JSX.Element>;
+type ReasoningContentProps = Omit<ComponentProps<typeof CollapsibleContent>, "children"> & {
+    /**
+     * The reasoning body.
+     *
+     * A **string** is rendered as streamed markdown (Streamdown) — the default for
+     * model reasoning text. Any other node renders **as-is**, so a structured live
+     * ledger (a timeline, per-step status) can live inside the disclosure without
+     * being handed to a markdown parser. Mirrors the `getThinkingMessage` /
+     * `children` override seam on `ReasoningTrigger`.
+     *
+     * Note an **array** of strings is not a `string` — `{["a", "b"]}` renders raw.
+     * Pass one string if you want it parsed as markdown.
+     */
+    children: ReactNode;
+};
+declare const ReasoningContent: react.MemoExoticComponent<({ className, children, ...props }: ReasoningContentProps) => react.JSX.Element>;
+
+type SandboxProps = ComponentProps<typeof Collapsible> & {
+    /**
+     * The run output has not arrived yet (loading-states.md loading signal).
+     * SandboxContent renders a layout-shaped skeleton instead of its children;
+     * SandboxHeader keeps rendering as passed.
+     * @default false
+     */
+    loading?: boolean;
+};
+/** @deprecated Renamed to `SandboxProps`. */
+type SandboxRootProps = SandboxProps;
+declare const Sandbox: ({ className, loading, children, ...props }: SandboxProps) => react.JSX.Element;
+interface SandboxHeaderProps {
+    title?: string;
+    state: ToolUIPart["state"];
+    className?: string;
+}
+declare const SandboxHeader: ({ className, title, state, ...props }: SandboxHeaderProps) => react.JSX.Element;
+type SandboxContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const SandboxContent: ({ className, children, ...props }: SandboxContentProps) => react.JSX.Element;
+type SandboxTabsProps = ComponentProps<typeof Tabs>;
+declare const SandboxTabs: ({ className, ...props }: SandboxTabsProps) => react.JSX.Element;
+type SandboxTabsBarProps = ComponentProps<"div">;
+declare const SandboxTabsBar: ({ className, ...props }: SandboxTabsBarProps) => react.JSX.Element;
+type SandboxTabsListProps = ComponentProps<typeof TabsList>;
+declare const SandboxTabsList: ({ className, ...props }: SandboxTabsListProps) => react.JSX.Element;
+type SandboxTabsTriggerProps = ComponentProps<typeof TabsTrigger>;
+declare const SandboxTabsTrigger: ({ className, ...props }: SandboxTabsTriggerProps) => react.JSX.Element;
+type SandboxTabContentProps = ComponentProps<typeof TabsContent>;
+declare const SandboxTabContent: ({ className, ...props }: SandboxTabContentProps) => react.JSX.Element;
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface SchemaParameter {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+    location?: "path" | "query" | "header";
+}
+interface SchemaProperty {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+    properties?: SchemaProperty[];
+    items?: SchemaProperty;
+}
+type SchemaDisplayHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const SchemaDisplayHeader: ({ className, children, ...props }: SchemaDisplayHeaderProps) => react.JSX.Element;
+type SchemaDisplayMethodProps = ComponentProps<typeof Badge>;
+declare const SchemaDisplayMethod: ({ className, children, ...props }: SchemaDisplayMethodProps) => react.JSX.Element;
+type SchemaDisplayPathProps = HTMLAttributes<HTMLSpanElement>;
+declare const SchemaDisplayPath: ({ className, children, ...props }: SchemaDisplayPathProps) => react.JSX.Element;
+type SchemaDisplayDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+declare const SchemaDisplayDescription: ({ className, children, ...props }: SchemaDisplayDescriptionProps) => react.JSX.Element;
+type SchemaDisplayContentProps = HTMLAttributes<HTMLDivElement>;
+declare const SchemaDisplayContent: ({ className, children, ...props }: SchemaDisplayContentProps) => react.JSX.Element;
+type SchemaDisplayParameterProps = HTMLAttributes<HTMLDivElement> & SchemaParameter;
+declare const SchemaDisplayParameter: ({ name, type, required, description, location, className, ...props }: SchemaDisplayParameterProps) => react.JSX.Element;
+type SchemaDisplayParametersProps = ComponentProps<typeof Collapsible>;
+declare const SchemaDisplayParameters: ({ className, children, ...props }: SchemaDisplayParametersProps) => react.JSX.Element;
+type SchemaDisplayPropertyProps = HTMLAttributes<HTMLDivElement> & SchemaProperty & {
+    depth?: number;
+};
+declare const SchemaDisplayProperty: ({ name, type, required, description, properties, items, depth, className, ...props }: SchemaDisplayPropertyProps) => react.JSX.Element;
+type SchemaDisplayRequestProps = ComponentProps<typeof Collapsible>;
+declare const SchemaDisplayRequest: ({ className, children, ...props }: SchemaDisplayRequestProps) => react.JSX.Element;
+type SchemaDisplayResponseProps = ComponentProps<typeof Collapsible>;
+declare const SchemaDisplayResponse: ({ className, children, ...props }: SchemaDisplayResponseProps) => react.JSX.Element;
+type SchemaDisplayProps = HTMLAttributes<HTMLDivElement> & {
+    method: HttpMethod;
+    path: string;
+    description?: string;
+    parameters?: SchemaParameter[];
+    requestBody?: SchemaProperty[];
+    responseBody?: SchemaProperty[];
+};
+declare const SchemaDisplay: ({ method, path, description, parameters, requestBody, responseBody, className, children, ...props }: SchemaDisplayProps) => react.JSX.Element;
+type SchemaDisplayBodyProps = HTMLAttributes<HTMLDivElement>;
+declare const SchemaDisplayBody: ({ className, children, ...props }: SchemaDisplayBodyProps) => react.JSX.Element;
+type SchemaDisplayExampleProps = HTMLAttributes<HTMLPreElement>;
+declare const SchemaDisplayExample: ({ className, children, ...props }: SchemaDisplayExampleProps) => react.JSX.Element;
+
+/** A captured selection snapshot: the trimmed text + its viewport rect. */
+interface SelectionSnapshot {
+    text: string;
+    rect: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Read the current selection if it is a non-empty range fully inside
+ * `container` (and not inside a form field / editor). Returns `null` otherwise.
+ * Exported for testing + custom integrations.
+ */
+declare function readSelectionWithin(container: HTMLElement | null): SelectionSnapshot | null;
+interface SelectionToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Called with the selected text when the user clicks Quote. */
+    onQuote?: (selectedText: string) => void;
+    /** Quote button label. @default "Quote" */
+    quoteLabel?: string;
+    /** Extra toolbar controls rendered after the Quote button. */
+    actions?: ReactNode;
+    /** Disable selection detection entirely. */
+    disabled?: boolean;
+    /** The transcript region to watch for selections. */
+    children: ReactNode;
+}
+/**
+ * Wraps a region and shows a floating Quote toolbar over selected text.
+ * The wrapper renders inline (`display: contents` is avoided — it's a real
+ * relative box) so the anchor + portal position correctly.
+ */
+declare const SelectionToolbar: react.ForwardRefExoticComponent<SelectionToolbarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TextShimmerProps {
+    children: string;
+    as?: ElementType;
+    className?: string;
+    duration?: number;
+    spread?: number;
+}
+declare const Shimmer: react.MemoExoticComponent<({ children, as: Component, className, duration, spread, }: TextShimmerProps) => JSX.Element>;
+
+type SnippetProps = ComponentProps<typeof InputGroup> & {
+    code: string;
+};
+declare const Snippet: ({ code, className, children, ...props }: SnippetProps) => react.JSX.Element;
+type SnippetAddonProps = ComponentProps<typeof InputGroupAddon>;
+declare const SnippetAddon: (props: SnippetAddonProps) => react.JSX.Element;
+type SnippetTextProps = ComponentProps<typeof InputGroupText>;
+declare const SnippetText: ({ className, ...props }: SnippetTextProps) => react.JSX.Element;
+type SnippetInputProps = Omit<ComponentProps<typeof InputGroupInput>, "readOnly" | "value">;
+declare const SnippetInput: ({ className, ...props }: SnippetInputProps) => react.JSX.Element;
+type SnippetCopyButtonProps = ComponentProps<typeof InputGroupButton> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+declare const SnippetCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: SnippetCopyButtonProps) => react.JSX.Element;
+
+type SourcesProps = ComponentProps<"div">;
+declare const Sources: ({ className, ...props }: SourcesProps) => react.JSX.Element;
+type SourcesTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    count: number;
+};
+declare const SourcesTrigger: ({ className, count, children, ...props }: SourcesTriggerProps) => react.JSX.Element;
+type SourcesContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const SourcesContent: ({ className, ...props }: SourcesContentProps) => react.JSX.Element;
+type SourceProps = ComponentProps<"a">;
+declare const Source: ({ href, title, children, className, ...props }: SourceProps) => react.JSX.Element;
+interface SourceListItem {
+    href: string;
+    title?: string;
+}
+type SourceListProps = Omit<ComponentProps<typeof Sources>, "children"> & {
+    /** The grounding sources, rendered as the named list. */
+    sources: SourceListItem[];
+    /** Extra rows appended after the named list (escape hatch). */
+    children?: ReactNode;
+};
+/**
+ * SourceList — the per-answer grounding footer (research 11 §B.4): a green
+ * "Grounded in N sources" header + the named source list. Sugar over the fixed
+ * `Sources`/`Source` primitives, reused by the context panel (research 09).
+ */
+declare const SourceList: ({ sources, children, ...props }: SourceListProps) => react.JSX.Element;
+
+interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    start(): void;
+    stop(): void;
+    onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onend: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void) | null;
+    onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void) | null;
+}
+interface SpeechRecognitionEvent extends Event {
+    results: SpeechRecognitionResultList;
+    resultIndex: number;
+}
+interface SpeechRecognitionResultList {
+    readonly length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResult;
+}
+interface SpeechRecognitionResult {
+    readonly length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+    isFinal: boolean;
+}
+interface SpeechRecognitionAlternative {
+    transcript: string;
+    confidence: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    error: string;
+}
+declare global {
+    interface Window {
+        SpeechRecognition: new () => SpeechRecognition;
+        webkitSpeechRecognition: new () => SpeechRecognition;
+    }
+}
+type SpeechInputProps = ComponentProps<typeof Button> & {
+    onTranscriptionChange?: (text: string) => void;
+    /**
+     * Callback for when audio is recorded using MediaRecorder fallback.
+     * This is called in browsers that don't support the Web Speech API (Firefox, Safari).
+     * The callback receives an audio Blob that should be sent to a transcription service.
+     * Return the transcribed text, which will be passed to onTranscriptionChange.
+     */
+    onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+    lang?: string;
+};
+declare const SpeechInput: ({ className, onTranscriptionChange, onAudioRecorded, lang, ...props }: SpeechInputProps) => react.JSX.Element;
+
+type StackTraceProps = ComponentProps<"div"> & {
+    trace: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+};
+declare const StackTrace: react.MemoExoticComponent<({ trace, className, open, defaultOpen, onOpenChange, onFilePathClick, children, ...props }: StackTraceProps) => react.JSX.Element>;
+type StackTraceHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+declare const StackTraceHeader: react.MemoExoticComponent<({ className, children, ...props }: StackTraceHeaderProps) => react.JSX.Element>;
+type StackTraceErrorProps = ComponentProps<"div">;
+declare const StackTraceError: react.MemoExoticComponent<({ className, children, ...props }: StackTraceErrorProps) => react.JSX.Element>;
+type StackTraceErrorTypeProps = ComponentProps<"span">;
+declare const StackTraceErrorType: react.MemoExoticComponent<({ className, children, ...props }: StackTraceErrorTypeProps) => react.JSX.Element>;
+type StackTraceErrorMessageProps = ComponentProps<"span">;
+declare const StackTraceErrorMessage: react.MemoExoticComponent<({ className, children, ...props }: StackTraceErrorMessageProps) => react.JSX.Element>;
+type StackTraceActionsProps = ComponentProps<"div">;
+declare const StackTraceActions: react.MemoExoticComponent<({ className, children, ...props }: StackTraceActionsProps) => react.JSX.Element>;
+type StackTraceCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+declare const StackTraceCopyButton: react.MemoExoticComponent<({ onCopy, onError, timeout, className, children, ...props }: StackTraceCopyButtonProps) => react.JSX.Element>;
+type StackTraceExpandButtonProps = ComponentProps<"div">;
+declare const StackTraceExpandButton: react.MemoExoticComponent<({ className, ...props }: StackTraceExpandButtonProps) => react.JSX.Element>;
+type StackTraceContentProps = ComponentProps<typeof CollapsibleContent> & {
+    maxHeight?: number;
+};
+declare const StackTraceContent: react.MemoExoticComponent<({ className, maxHeight, children, ...props }: StackTraceContentProps) => react.JSX.Element>;
+type StackTraceFramesProps = ComponentProps<"div"> & {
+    showInternalFrames?: boolean;
+};
+declare const StackTraceFrames: react.MemoExoticComponent<({ className, showInternalFrames, ...props }: StackTraceFramesProps) => react.JSX.Element>;
+
+type SuggestionsProps = ComponentProps<typeof ScrollArea>;
+declare const Suggestions: ({ className, children, ...props }: SuggestionsProps) => react.JSX.Element;
+type SuggestionProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+    suggestion: string;
+    onClick?: (suggestion: string) => void;
+};
+declare const Suggestion: ({ suggestion, onClick, className, variant, size, children, ...props }: SuggestionProps) => react.JSX.Element;
+type SuggestionLoadingProps = HTMLAttributes<HTMLDivElement> & {
+    /** Shimmering label shown while the suggestion set is still generating. */
+    label?: string;
+};
+/**
+ * A non-interactive trailing chip that shimmers while suggestions stream in.
+ * Shaped like a `Suggestion` pill; composes `Shimmer` (motion-reduce aware) and
+ * announces via `role="status"`. Render it after the chips while loading.
+ */
+declare const SuggestionLoading: ({ label, className, ...props }: SuggestionLoadingProps) => react.JSX.Element;
+type StreamingSuggestionsProps = Omit<SuggestionsProps, "children"> & {
+    /** The suggestions to render. As this array grows, new chips appear in place. */
+    suggestions: string[];
+    /** While true, a shimmering trailing chip is shown until the set settles. */
+    loading?: boolean;
+    /** Click handler for a suggestion chip. */
+    onSuggestionClick?: (suggestion: string) => void;
+    /** Label for the trailing loading chip. @default "Thinking…" */
+    loadingLabel?: string;
+};
+/**
+ * Suggestions that appear progressively while a generator streams. Each chip
+ * fades in on mount (existing chips don't re-animate — keys are the suggestion
+ * text); a shimmering trailing chip shows until `loading` flips false.
+ */
+declare const StreamingSuggestions: ({ suggestions, loading, onSuggestionClick, loadingLabel, ...props }: StreamingSuggestionsProps) => react.JSX.Element;
+
+type TaskItemFileProps = ComponentProps<"span">;
+/**
+ * A quiet inline file chip. Unbordered since #192 (the fill is the gesture;
+ * a border on a filled chip is the redundant-border anti-pattern). For a
+ * navigable list of produced files, prefer the asset-tree idiom (research 09).
+ */
+declare const TaskItemFile: ({ children, className, ...props }: TaskItemFileProps) => react.JSX.Element;
+type TaskItemProps = Omit<AgentStepProps, "name" | "children"> & {
+    children?: ReactNode;
+};
+/**
+ * One line of the run summary — an `AgentStep` on the canonical rail.
+ * Defaults to `status="complete"` (the task reports finished work) with the
+ * badge hidden (the rail node carries the status; a badge per log line would
+ * shout).
+ */
+declare const TaskItem: ({ children, status, hideBadge, ...props }: TaskItemProps) => react.JSX.Element;
+type TaskProps = ComponentProps<typeof Collapsible>;
+/** Collapsed by default since #192 (`defaultOpen` flipped `true`→`false`). */
+declare const Task: ({ className, ...props }: TaskProps) => react.JSX.Element;
+type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    title: string;
+};
+declare const TaskTrigger: ({ children, className, title, ...props }: TaskTriggerProps) => react.JSX.Element;
+type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const TaskContent: ({ children, className, ...props }: TaskContentProps) => react.JSX.Element;
+
+type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const TerminalHeader: ({ className, children, ...props }: TerminalHeaderProps) => react.JSX.Element;
+type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+declare const TerminalTitle: ({ className, children, ...props }: TerminalTitleProps) => react.JSX.Element;
+type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+declare const TerminalStatus: ({ className, children, ...props }: TerminalStatusProps) => react.JSX.Element | null;
+type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+declare const TerminalActions: ({ className, children, ...props }: TerminalActionsProps) => react.JSX.Element;
+type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+declare const TerminalCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: TerminalCopyButtonProps) => react.JSX.Element;
+type TerminalClearButtonProps = ComponentProps<typeof Button>;
+declare const TerminalClearButton: ({ children, className, ...props }: TerminalClearButtonProps) => react.JSX.Element | null;
+type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+declare const TerminalContent: ({ className, children, ...props }: TerminalContentProps) => react.JSX.Element;
+type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+    output: string;
+    isStreaming?: boolean;
+    autoScroll?: boolean;
+    onClear?: () => void;
+};
+declare const Terminal: ({ output, isStreaming, autoScroll, onClear, className, children, ...props }: TerminalProps) => react.JSX.Element;
+
+type TestResultsHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const TestResultsHeader: ({ className, children, ...props }: TestResultsHeaderProps) => react.JSX.Element;
+type TestResultsDurationProps = HTMLAttributes<HTMLSpanElement>;
+declare const TestResultsDuration: ({ className, children, ...props }: TestResultsDurationProps) => react.JSX.Element | null;
+type TestResultsSummaryProps = HTMLAttributes<HTMLDivElement>;
+interface TestResultsSummary {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+    duration?: number;
+}
+declare const TestResultsSummary: ({ className, children, ...props }: TestResultsSummaryProps) => react.JSX.Element | null;
+type TestResultsProps = HTMLAttributes<HTMLDivElement> & {
+    summary?: TestResultsSummary;
+};
+declare const TestResults: ({ summary, className, children, ...props }: TestResultsProps) => react.JSX.Element;
+type TestResultsProgressProps = HTMLAttributes<HTMLDivElement>;
+declare const TestResultsProgress: ({ className, children, ...props }: TestResultsProgressProps) => react.JSX.Element | null;
+/**
+ * TestResultsMeta — the summary badges + progress bar block that sits between
+ * the header and the suite list. Provides consistent `px-4 pt-3 pb-4` padding
+ * so callers do not need ad-hoc wrapper divs.
+ */
+type TestResultsMetaProps = HTMLAttributes<HTMLDivElement>;
+declare const TestResultsMeta: ({ className, children, ...props }: TestResultsMetaProps) => react.JSX.Element;
+/**
+ * TestResultsContent — the suite list. Uses `divide-y` instead of `space-y`
+ * so suites are separated by a single structural divider, not nested boxes.
+ */
+type TestResultsContentProps = HTMLAttributes<HTMLDivElement>;
+declare const TestResultsContent: ({ className, children, ...props }: TestResultsContentProps) => react.JSX.Element;
+type TestSuiteProps = ComponentProps<typeof Collapsible> & {
+    name: string;
+    status: TestStatus;
+};
+/**
+ * TestSuite — one expandable file/suite row. Uses a quiet left rail
+ * (`border-s-2`) as the sole focal separation gesture inside the divider-
+ * separated list. No nested rounded box: that was redundant border-on-region
+ * with no fill change (separation grammar).
+ */
+declare const TestSuite: ({ name, status, className, children, ...props }: TestSuiteProps) => react.JSX.Element;
+type TestSuiteNameProps = ComponentProps<typeof CollapsibleTrigger>;
+declare const TestSuiteName: ({ className, children, ...props }: TestSuiteNameProps) => react.JSX.Element;
+type TestSuiteStatsProps = HTMLAttributes<HTMLDivElement> & {
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+};
+declare const TestSuiteStats: ({ passed, failed, skipped, className, children, ...props }: TestSuiteStatsProps) => react.JSX.Element;
+type TestSuiteContentProps = ComponentProps<typeof CollapsibleContent>;
+/**
+ * TestSuiteContent — the rows inside an expanded suite. A left rail
+ * (`border-s-2 border-s-border ms-6`) indents the block under the suite
+ * trigger and separates it structurally without a box. Rows are divided by
+ * `divide-y`.
+ */
+declare const TestSuiteContent: ({ className, children, ...props }: TestSuiteContentProps) => react.JSX.Element;
+type TestNameProps = HTMLAttributes<HTMLSpanElement>;
+declare const TestName: ({ className, children, ...props }: TestNameProps) => react.JSX.Element;
+type TestDurationProps = HTMLAttributes<HTMLSpanElement>;
+declare const TestDuration: ({ className, children, ...props }: TestDurationProps) => react.JSX.Element | null;
+type TestStatusProps = HTMLAttributes<HTMLSpanElement>;
+type TestStatus = "passed" | "failed" | "skipped" | "running";
+declare const TestStatus: ({ className, children, ...props }: TestStatusProps) => react.JSX.Element;
+type TestProps = HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    status: TestStatus;
+    duration?: number;
+};
+/**
+ * Test — a single test-case row. `ps-10` aligns the status icon with the
+ * suite's status icon (after the trigger's chevron + gap), giving a clean
+ * left-column across the expansion.
+ */
+declare const Test: ({ name, status, duration, className, children, ...props }: TestProps) => react.JSX.Element;
+type TestErrorProps = HTMLAttributes<HTMLDivElement>;
+declare const TestError: ({ className, children, ...props }: TestErrorProps) => react.JSX.Element;
+type TestErrorMessageProps = HTMLAttributes<HTMLParagraphElement>;
+declare const TestErrorMessage: ({ className, children, ...props }: TestErrorMessageProps) => react.JSX.Element;
+type TestErrorStackProps = HTMLAttributes<HTMLPreElement>;
+declare const TestErrorStack: ({ className, children, ...props }: TestErrorStackProps) => react.JSX.Element;
+
+type ToolProps = ComponentProps<typeof Collapsible>;
+declare const Tool: ({ className, ...props }: ToolProps) => react.JSX.Element;
+type ToolPart = ToolUIPart | DynamicToolUIPart;
+type ToolHeaderProps = {
+    title?: string;
+    /**
+     * The business summary line ("3 documents found", "8 rows reconciled"),
+     * shown beside the name + StatusBadge (#192, research 10 §B.5). Falls back
+     * to nothing — the derived tool name still labels the row.
+     */
+    summary?: ReactNode;
+    className?: string;
+} & ({
+    type: ToolUIPart["type"];
+    state: ToolUIPart["state"];
+    toolName?: never;
+} | {
+    type: DynamicToolUIPart["type"];
+    state: DynamicToolUIPart["state"];
+    toolName: string;
+});
+/**
+ * Map the AI-SDK `ToolUIPart` 7-state machine onto the canonical `Status`
+ * enum (#189, research 10 §B.1 mapping a). Lives here — not in `@elabs-ai/components-ui` —
+ * because it is typed against the SDK union; the `ai` import stays TYPES-ONLY
+ * (D6, gate-enforced by `pnpm ai:types-only`).
+ */
+declare const statusFromToolState: (state: ToolPart["state"]) => Status;
+/** Same signature as before #189; renders the canonical StatusBadge. */
+declare const getStatusBadge: (status: ToolPart["state"]) => react.JSX.Element;
+declare const ToolHeader: ({ className, title, summary, type, state, toolName, ...props }: ToolHeaderProps) => react.JSX.Element;
+type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const ToolContent: ({ className, ...props }: ToolContentProps) => react.JSX.Element;
+type ToolDetailsProps = ComponentProps<typeof Collapsible> & {
+    /** The disclosure label. */
+    label?: ReactNode;
+};
+/**
+ * The technical view, behind disclosure — the PACKAGE DEFAULT for tool JSON
+ * (#192, research 10 §B.5): a nested collapsible, COLLAPSED by default,
+ * holding `ToolInput`/`ToolOutput`. The header carries the business `summary`;
+ * the raw payload is one expand away, never the headline.
+ */
+declare const ToolDetails: ({ className, label, defaultOpen, children, ...props }: ToolDetailsProps) => react.JSX.Element;
+type ToolInputProps = ComponentProps<"div"> & {
+    input: ToolPart["input"];
+};
+declare const ToolInput: ({ className, input, ...props }: ToolInputProps) => react.JSX.Element;
+type ToolOutputProps = ComponentProps<"div"> & {
+    /**
+     * The tool result. Objects/strings render as JSON inside the technical view.
+     *
+     * @deprecated Passing a pre-rendered **React element** here (the "rich
+     * output under a muted Result heading" path) is deprecated since #192
+     * (research 10 §B.5): a produced artifact is the HEADLINE, not a technical
+     * detail — host it in a `<ToolResultCard>` and keep `ToolOutput` for the
+     * JSON payload behind `<ToolDetails>`. The element path still renders for
+     * existing consumers (e.g. the copy-owned `ai-chart` registry block) but
+     * will be removed in a future release.
+     */
+    output: ToolPart["output"];
+    errorText: ToolPart["errorText"];
+    /**
+     * The call has not produced output yet (loading-states.md `isStreaming`) —
+     * derive it from the existing `statusFromToolState(state)` mapping
+     * (`"input-streaming"`/`"input-available"` → not yet `"complete"`/`"failed"`)
+     * rather than a second source of truth. While true and no `output`/
+     * `errorText` has arrived, renders a layout-shaped skeleton in the Result
+     * slot instead of `null`, so the technical view reserves its space. A
+     * still-running call is never a terminal failure — the error branch is
+     * suppressed while `isStreaming` per the loading-states.md error rule, even
+     * if a stale `errorText` is still set from a previous render.
+     * @default false
+     */
+    isStreaming?: boolean;
+};
+declare const ToolOutput: ({ className, output, errorText, isStreaming, ...props }: ToolOutputProps) => react.JSX.Element | null;
+
+interface ToolResultCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Headline of the produced artifact (`text-subtitle`). */
+    title?: ReactNode;
+    /** The business summary line under the title (`text-meta`), not JSON. */
+    summary?: ReactNode;
+    /** Canonical execution status (closed enum); renders a `StatusBadge`. */
+    status?: Status;
+    /**
+     * Controls scoped to the whole artifact — expand, download, open. Rendered in
+     * the header row between the title and the status.
+     *
+     * A `ReactNode` slot, not a `role="toolbar"`: that role promises roving-tabindex
+     * traversal, which this row does not implement. Keep the payload's own controls
+     * out of here (see the note at the top of this file).
+     */
+    actions?: ReactNode;
+    /**
+     * The technical view, kept behind disclosure — pass a default-collapsed
+     * `<ToolDetails>` holding `ToolInput`/`ToolOutput` (research 10 §B.5).
+     */
+    details?: ReactNode;
+}
+/** The produced artifact IS the headline; pass it as `children`. */
+declare const ToolResultCard: react.ForwardRefExoticComponent<ToolResultCardProps & react.RefAttributes<HTMLDivElement>>;
+
+type NodeToolbarProps = ComponentProps<typeof NodeToolbar$1>;
+/**
+ * The floating control strip attached to a selected canvas NODE — it portals out
+ * of the node and follows it, and it is meaningless outside a `<Canvas>`.
+ *
+ * Named `NodeToolbar` (after the React Flow primitive it wraps) because
+ * `Toolbar` now means the general-purpose WAI-ARIA toolbar in
+ * `@elabs-ai/components-ui`: a keyboard row with a roving tabindex.
+ * The two solve unrelated problems, and the collision made "use the Toolbar"
+ * ambiguous at every call site.
+ */
+declare const NodeToolbar: (props: NodeToolbarProps) => react.JSX.Element;
+/**
+ * @deprecated Renamed to {@link NodeToolbar}. `Toolbar` is now the WAI-ARIA
+ * toolbar in `@elabs-ai/components-ui`. This alias will be removed in
+ * the next major.
+ */
+declare const Toolbar: (props: NodeToolbarProps) => react.JSX.Element;
+/** @deprecated Renamed to {@link NodeToolbarProps}. */
+type ToolbarProps = NodeToolbarProps;
+
+type TranscriptionProps = Omit<ComponentProps<"div">, "children"> & {
+    segments: TranscriptionSegment[];
+    currentTime?: number;
+    onSeek?: (time: number) => void;
+    children: (segment: TranscriptionSegment, index: number) => ReactNode;
+};
+declare const Transcription: ({ segments, currentTime: externalCurrentTime, onSeek, className, children, ...props }: TranscriptionProps) => react.JSX.Element;
+type TranscriptionSegmentProps = ComponentProps<"button"> & {
+    segment: TranscriptionSegment;
+    index: number;
+};
+type TranscriptionSegment = Experimental_TranscriptionResult["segments"][number];
+declare const TranscriptionSegment: ({ segment, index, className, onClick, ...props }: TranscriptionSegmentProps) => react.JSX.Element;
+
+interface VoiceSelectorContextValue {
+    value: string | undefined;
+    setValue: (value: string | undefined) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+}
+declare const useVoiceSelector: () => VoiceSelectorContextValue;
+type VoiceSelectorProps = ComponentProps<typeof Dialog> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string | undefined) => void;
+};
+declare const VoiceSelector: ({ value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, children, ...props }: VoiceSelectorProps) => react.JSX.Element;
+type VoiceSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+declare const VoiceSelectorTrigger: (props: VoiceSelectorTriggerProps) => react.JSX.Element;
+type VoiceSelectorContentProps = ComponentProps<typeof DialogContent> & {
+    title?: ReactNode;
+};
+declare const VoiceSelectorContent: ({ className, children, title, ...props }: VoiceSelectorContentProps) => react.JSX.Element;
+type VoiceSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+declare const VoiceSelectorDialog: (props: VoiceSelectorDialogProps) => react.JSX.Element;
+type VoiceSelectorInputProps = ComponentProps<typeof CommandInput>;
+declare const VoiceSelectorInput: ({ className, ...props }: VoiceSelectorInputProps) => react.JSX.Element;
+type VoiceSelectorListProps = ComponentProps<typeof CommandList>;
+declare const VoiceSelectorList: (props: VoiceSelectorListProps) => react.JSX.Element;
+type VoiceSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+declare const VoiceSelectorEmpty: (props: VoiceSelectorEmptyProps) => react.JSX.Element;
+type VoiceSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+declare const VoiceSelectorGroup: (props: VoiceSelectorGroupProps) => react.JSX.Element;
+type VoiceSelectorItemProps = ComponentProps<typeof CommandItem>;
+declare const VoiceSelectorItem: ({ className, ...props }: VoiceSelectorItemProps) => react.JSX.Element;
+type VoiceSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+declare const VoiceSelectorShortcut: (props: VoiceSelectorShortcutProps) => react.JSX.Element;
+type VoiceSelectorSeparatorProps = ComponentProps<typeof CommandSeparator>;
+declare const VoiceSelectorSeparator: (props: VoiceSelectorSeparatorProps) => react.JSX.Element;
+type VoiceSelectorGenderProps = ComponentProps<"span"> & {
+    value?: "male" | "female" | "transgender" | "androgyne" | "non-binary" | "intersex";
+};
+declare const VoiceSelectorGender: ({ className, value, children, ...props }: VoiceSelectorGenderProps) => react.JSX.Element;
+type VoiceSelectorAccentProps = ComponentProps<"span"> & {
+    value?: "american" | "british" | "australian" | "canadian" | "irish" | "scottish" | "indian" | "south-african" | "new-zealand" | "spanish" | "french" | "german" | "italian" | "portuguese" | "brazilian" | "mexican" | "argentinian" | "japanese" | "chinese" | "korean" | "russian" | "arabic" | "dutch" | "swedish" | "norwegian" | "danish" | "finnish" | "polish" | "turkish" | "greek" | string;
+};
+declare const VoiceSelectorAccent: ({ className, value, children, ...props }: VoiceSelectorAccentProps) => react.JSX.Element;
+type VoiceSelectorAgeProps = ComponentProps<"span">;
+declare const VoiceSelectorAge: ({ className, ...props }: VoiceSelectorAgeProps) => react.JSX.Element;
+type VoiceSelectorNameProps = ComponentProps<"span">;
+declare const VoiceSelectorName: ({ className, ...props }: VoiceSelectorNameProps) => react.JSX.Element;
+type VoiceSelectorDescriptionProps = ComponentProps<"span">;
+declare const VoiceSelectorDescription: ({ className, ...props }: VoiceSelectorDescriptionProps) => react.JSX.Element;
+type VoiceSelectorAttributesProps = ComponentProps<"div">;
+declare const VoiceSelectorAttributes: ({ className, children, ...props }: VoiceSelectorAttributesProps) => react.JSX.Element;
+type VoiceSelectorBulletProps = ComponentProps<"span">;
+declare const VoiceSelectorBullet: ({ className, ...props }: VoiceSelectorBulletProps) => react.JSX.Element;
+type VoiceSelectorPreviewProps = Omit<ComponentProps<"button">, "children"> & {
+    playing?: boolean;
+    loading?: boolean;
+    onPlay?: () => void;
+};
+declare const VoiceSelectorPreview: ({ className, playing, loading, onPlay, onClick, ...props }: VoiceSelectorPreviewProps) => react.JSX.Element;
+
+interface WebPreviewContextValue {
+    url: string;
+    setUrl: (url: string) => void;
+    consoleOpen: boolean;
+    setConsoleOpen: (open: boolean) => void;
+}
+type WebPreviewProps = ComponentProps<"div"> & {
+    defaultUrl?: string;
+    onUrlChange?: (url: string) => void;
+};
+declare const WebPreview: ({ className, children, defaultUrl, onUrlChange, ...props }: WebPreviewProps) => react.JSX.Element;
+type WebPreviewNavigationProps = ComponentProps<"div">;
+declare const WebPreviewNavigation: ({ className, children, ...props }: WebPreviewNavigationProps) => react.JSX.Element;
+type WebPreviewNavigationButtonProps = ComponentProps<typeof Button> & {
+    tooltip?: string;
+};
+declare const WebPreviewNavigationButton: ({ onClick, disabled, tooltip, children, ...props }: WebPreviewNavigationButtonProps) => react.JSX.Element;
+type WebPreviewUrlProps = ComponentProps<typeof Input>;
+declare const WebPreviewUrl: ({ value, onChange, onKeyDown, ...props }: WebPreviewUrlProps) => react.JSX.Element;
+type WebPreviewBodyProps = Omit<ComponentProps<"iframe">, "loading"> & {
+    /**
+     * Not-ready placeholder over the iframe (loading-states.md `loading`
+     * signal). Pass `true` for the default layout-shaped Skeleton filling the
+     * iframe box, or a ReactNode to override with custom placeholder content.
+     * `false`/`undefined` (default) renders nothing. Shadows (rather than
+     * forwards) the native `<iframe loading="eager"|"lazy">` attribute — this
+     * component's box is always fully reserved, so lazy-loading the iframe
+     * itself is not a use case here.
+     * @default false
+     */
+    loading?: boolean | ReactNode;
+};
+declare const WebPreviewBody: ({ className, loading, src, ...props }: WebPreviewBodyProps) => react.JSX.Element;
+type WebPreviewConsoleProps = ComponentProps<"div"> & {
+    logs?: {
+        level: "log" | "warn" | "error";
+        message: string;
+        timestamp: Date;
+    }[];
+};
+declare const WebPreviewConsole: ({ className, logs, children, ...props }: WebPreviewConsoleProps) => react.JSX.Element;
+
+interface ChatShellProps {
+    /** Scrollable transcript — typically a <Conversation>. */
+    children: ReactNode;
+    /** Sticky composer — typically a <Composer> (the standard chat input). */
+    composer?: ReactNode;
+    /** Optional header row (title, model picker, actions). */
+    header?: ReactNode;
+    /** Optional right-side context rail (sources, files, memory). */
+    aside?: ReactNode;
+    /**
+     * Layout treatment:
+     * - `"card"` (default) — a self-contained rounded, bordered chat card. Use
+     *   when the shell sits on a page among other content and needs its own frame.
+     * - `"bare"` — an immersive pane that fills its container with NO frame: the
+     *   transcript fades under the header and above the composer (a token-driven
+     *   top/bottom scrim) and the composer floats on the pane background instead
+     *   of a hard bordered bar. Use when the shell already lives inside a bounded
+     *   region (an AppShell `SidebarInset`, a full-page workspace) so it doesn't
+     *   draw a redundant second frame.
+     */
+    variant?: "card" | "bare";
+    className?: string;
+}
+/**
+ * Layout shell for an AI chat built from the AI Elements: a header, a scrollable
+ * transcript (give it a <Conversation>, which is `flex-1`), a sticky composer
+ * (a <Composer>, the standard chat input), and an optional context rail. Fills
+ * its parent's height.
+ *
+ * Two layout modes (`variant`): a framed `"card"` for in-page use, and a
+ * frameless `"bare"` immersive pane for when the shell already sits inside a
+ * bounded region and a second frame would just read as boxy.
+ */
+declare function ChatShell({ children, composer, header, aside, variant, className, }: ChatShellProps): react.JSX.Element;
+
+export { Agent, AgentContent, type AgentContentProps, AgentHeader, type AgentHeaderProps, AgentInstructions, type AgentInstructionsProps, AgentMessage, type AgentMessageEmphasis, type AgentMessageProps, AgentOutput, type AgentOutputProps, type AgentProps, AgentStep, type AgentStepProps, AgentTimeline, type AgentTimelineProps, AgentTool, type AgentToolProps, AgentTools, type AgentToolsProps, ApprovalCard, ApprovalCardAccepted, type ApprovalCardAcceptedProps, ApprovalCardAction, type ApprovalCardActionProps, ApprovalCardActions, type ApprovalCardActionsProps, ApprovalCardApprove, type ApprovalCardApproveProps, ApprovalCardDeny, type ApprovalCardDenyProps, ApprovalCardDescription, type ApprovalCardDescriptionProps, type ApprovalCardProps, ApprovalCardRejected, type ApprovalCardRejectedProps, ApprovalCardRequest, type ApprovalCardRequestProps, ApprovalCardTitle, type ApprovalCardTitleProps, Artifact, ArtifactAction, type ArtifactActionProps, ArtifactActions, type ArtifactActionsProps, ArtifactClose, type ArtifactCloseProps, ArtifactContent, type ArtifactContentProps, ArtifactDescription, type ArtifactDescriptionProps, ArtifactHeader, type ArtifactHeaderProps, type ArtifactProps, ArtifactTitle, type ArtifactTitleProps, AssetPreview, type AssetPreviewMode, type AssetPreviewProps, type AssetPreviewRenderer, Attachment, type AttachmentData, AttachmentEmpty, type AttachmentEmptyProps, AttachmentHoverCard, AttachmentHoverCardContent, type AttachmentHoverCardContentProps, type AttachmentHoverCardProps, AttachmentHoverCardTrigger, type AttachmentHoverCardTriggerProps, AttachmentInfo, type AttachmentInfoProps, type AttachmentMediaCategory, AttachmentPreview, type AttachmentPreviewProps, type AttachmentProps, AttachmentRemove, type AttachmentRemoveProps, type AttachmentVariant, Attachments, type AttachmentsContext, type AttachmentsProps, AudioPlayer, AudioPlayerControlBar, type AudioPlayerControlBarProps, AudioPlayerDurationDisplay, type AudioPlayerDurationDisplayProps, AudioPlayerElement, type AudioPlayerElementProps, AudioPlayerMuteButton, type AudioPlayerMuteButtonProps, AudioPlayerPlayButton, type AudioPlayerPlayButtonProps, type AudioPlayerProps, AudioPlayerSeekBackwardButton, type AudioPlayerSeekBackwardButtonProps, AudioPlayerSeekForwardButton, type AudioPlayerSeekForwardButtonProps, AudioPlayerTimeDisplay, type AudioPlayerTimeDisplayProps, AudioPlayerTimeRange, type AudioPlayerTimeRangeProps, AudioPlayerVolumeRange, type AudioPlayerVolumeRangeProps, type BadgeTone, type BooleanFieldSpec, BrandMotionConfig, type BrandMotionConfigProps, Canvas, type CanvasProps, type CellFormat, ChainOfThought, ChainOfThoughtContent, type ChainOfThoughtContentProps, ChainOfThoughtHeader, type ChainOfThoughtHeaderProps, ChainOfThoughtImage, type ChainOfThoughtImageProps, type ChainOfThoughtProps, ChainOfThoughtSearchResult, type ChainOfThoughtSearchResultProps, ChainOfThoughtSearchResults, type ChainOfThoughtSearchResultsProps, ChainOfThoughtStep, type ChainOfThoughtStepProps, ChatGreeting, type ChatGreetingProps, ChatShell, type ChatShellProps, Checkpoint, CheckpointIcon, type CheckpointIconProps, type CheckpointProps, CheckpointTrigger, type CheckpointTriggerProps, CodeBlock, CodeBlockActions, CodeBlockContainer, CodeBlockContent, CodeBlockCopyButton, type CodeBlockCopyButtonProps, CodeBlockFilename, CodeBlockHeader, CodeBlockLanguageSelector, CodeBlockLanguageSelectorContent, type CodeBlockLanguageSelectorContentProps, CodeBlockLanguageSelectorItem, type CodeBlockLanguageSelectorItemProps, type CodeBlockLanguageSelectorProps, CodeBlockLanguageSelectorTrigger, type CodeBlockLanguageSelectorTriggerProps, CodeBlockLanguageSelectorValue, type CodeBlockLanguageSelectorValueProps, type CodeBlockProps, CodeBlockTitle, type ColumnSpec, Commit, CommitActions, type CommitActionsProps, CommitAuthor, CommitAuthorAvatar, type CommitAuthorAvatarProps, type CommitAuthorProps, CommitContent, type CommitContentProps, CommitCopyButton, type CommitCopyButtonProps, CommitFile, CommitFileAdditions, type CommitFileAdditionsProps, CommitFileChanges, type CommitFileChangesProps, CommitFileDeletions, type CommitFileDeletionsProps, CommitFileIcon, type CommitFileIconProps, CommitFileInfo, type CommitFileInfoProps, CommitFilePath, type CommitFilePathProps, type CommitFileProps, CommitFileStatus, type CommitFileStatusProps, CommitFiles, type CommitFilesProps, CommitHash, type CommitHashProps, CommitHeader, type CommitHeaderProps, CommitInfo, type CommitInfoProps, CommitMessage, type CommitMessageProps, CommitMetadata, type CommitMetadataProps, type CommitProps, CommitSeparator, type CommitSeparatorProps, CommitTimestamp, type CommitTimestampProps, Composer, type ComposerProps, Confirmation, ConfirmationAccepted, type ConfirmationAcceptedProps, ConfirmationAction, type ConfirmationActionProps, ConfirmationActions, type ConfirmationActionsProps, ConfirmationApprove, type ConfirmationApproveProps, ConfirmationDeny, type ConfirmationDenyProps, ConfirmationDescription, type ConfirmationDescriptionProps, type ConfirmationProps, ConfirmationRejected, type ConfirmationRejectedProps, ConfirmationRequest, type ConfirmationRequestProps, ConfirmationTitle, type ConfirmationTitleProps, Connection, Context, type ContextAsset, type ContextAssetType, ContextCacheUsage, type ContextCacheUsageProps, ContextContent, ContextContentBody, type ContextContentBodyProps, ContextContentFooter, type ContextContentFooterProps, ContextContentHeader, type ContextContentHeaderProps, type ContextContentProps, ContextInputUsage, type ContextInputUsageProps, ContextOutputUsage, type ContextOutputUsageProps, ContextPanel, ContextPanelBody, type ContextPanelBodyProps, type ContextPanelContextValue, ContextPanelDetail, type ContextPanelDetailProps, ContextPanelHeader, type ContextPanelHeaderProps, type ContextPanelProps, ContextPanelProvider, type ContextPanelProviderProps, ContextPanelSection, type ContextPanelSectionProps, ContextPanelTrigger, type ContextPanelTriggerProps, type ContextPanelView, type ContextProps, ContextReasoningUsage, type ContextReasoningUsageProps, ContextTrigger, type ContextTriggerProps, Controls, type ControlsProps, Conversation, ConversationContent, type ConversationContentProps, ConversationDownload, type ConversationDownloadProps, ConversationEmptyState, type ConversationEmptyStateProps, type ConversationProps, ConversationScrollButton, type ConversationScrollButtonProps, EMPTY_CELL, Edge, type EnumFieldSpec, type EnumOption, EnvironmentVariable, EnvironmentVariableCopyButton, type EnvironmentVariableCopyButtonProps, EnvironmentVariableGroup, type EnvironmentVariableGroupProps, EnvironmentVariableName, type EnvironmentVariableNameProps, type EnvironmentVariableProps, EnvironmentVariableRequired, type EnvironmentVariableRequiredProps, EnvironmentVariableValue, type EnvironmentVariableValueProps, EnvironmentVariables, EnvironmentVariablesContent, type EnvironmentVariablesContentProps, EnvironmentVariablesHeader, type EnvironmentVariablesHeaderProps, type EnvironmentVariablesProps, EnvironmentVariablesTitle, type EnvironmentVariablesTitleProps, EnvironmentVariablesToggle, type EnvironmentVariablesToggleProps, EvidenceChip, type EvidenceChipProps, type FeedbackType, type FieldSpec, FileTree, FileTreeActions, type FileTreeActionsProps, FileTreeFile, type FileTreeFileProps, FileTreeFolder, type FileTreeFolderProps, FileTreeIcon, type FileTreeIconProps, FileTreeName, type FileTreeNameProps, type FileTreeProps, type FileTreeVariant, type FormSpec, type FormSubmitState, type FormValue, type FormValues, Gallery, type GalleryImage, type GalleryMetaItem, type GalleryProps, type GetPartStatus, type GroupBy, type GroupByContext, type GroupKey, type GroupPartByTypeOptions, type GroupStatus, type GroupablePart, type GroupedNode, type GroupedPartRenderArgs, type GroupedPartRenderer, GroupedParts, type GroupedPartsProps, Image, type ImageProps, InlineCitation, InlineCitationCard, InlineCitationCardBody, type InlineCitationCardBodyProps, type InlineCitationCardProps, InlineCitationCardTrigger, type InlineCitationCardTriggerProps, InlineCitationCarousel, InlineCitationCarouselContent, type InlineCitationCarouselContentProps, InlineCitationCarouselHeader, type InlineCitationCarouselHeaderProps, InlineCitationCarouselIndex, type InlineCitationCarouselIndexProps, InlineCitationCarouselItem, type InlineCitationCarouselItemProps, InlineCitationCarouselNext, type InlineCitationCarouselNextProps, InlineCitationCarouselPrev, type InlineCitationCarouselPrevProps, type InlineCitationCarouselProps, type InlineCitationProps, InlineCitationQuote, type InlineCitationQuoteProps, InlineCitationSource, type InlineCitationSourceProps, type InlineCitationSourceRef, InlineCitationText, type InlineCitationTextProps, type IntegerFieldSpec, InteractiveTerminal, type InteractiveTerminalHandle, type InteractiveTerminalProps, JSXPreview, JSXPreviewContent, type JSXPreviewContentProps, JSXPreviewError, type JSXPreviewErrorProps, type JSXPreviewProps, JSXPreviewSkeleton, type JSXPreviewSkeletonProps, type JSXPreviewStatus, LocalReferencedSourcesContext, MODEL_SELECTOR_LOGO_BASE_URL, MarkdownView, type MarkdownViewProps, Message, MessageAction, type MessageActionProps, MessageActions, type MessageActionsProps, MessageAvatar, type MessageAvatarProps, MessageBranch, MessageBranchContent, type MessageBranchContentProps, MessageBranchNext, type MessageBranchNextProps, MessageBranchPage, type MessageBranchPageProps, MessageBranchPrevious, type MessageBranchPreviousProps, type MessageBranchProps, MessageBranchSelector, type MessageBranchSelectorProps, MessageContent, type MessageContentProps, MessageEdit, MessageEditContent, type MessageEditContentProps, MessageEditForm, type MessageEditFormProps, type MessageEditProps, MessageEditProvider, type MessageEditProviderProps, MessageEditTrigger, type MessageEditTriggerProps, MessageFeedback, type MessageFeedbackProps, MessageForm, MessageFormDescription, type MessageFormDescriptionProps, MessageFormFallback, type MessageFormFallbackProps, MessageFormField, type MessageFormFieldProps, MessageFormFields, type MessageFormFieldsProps, type MessageFormProps, MessageFormProvider, type MessageFormProviderProps, MessageFormRoot, type MessageFormRootProps, MessageFormSubmit, type MessageFormSubmitProps, MessageFormTitle, type MessageFormTitleProps, MessageHeader, type MessageHeaderProps, type MessageProps, MessageResponse, type MessageResponseProps, MessageTable, MessageTableFallback, type MessageTableFallbackProps, type MessageTableProps, MessageToolbar, type MessageToolbarProps, MicSelector, MicSelectorContent, type MicSelectorContentProps, MicSelectorEmpty, type MicSelectorEmptyProps, MicSelectorInput, type MicSelectorInputProps, MicSelectorItem, type MicSelectorItemProps, MicSelectorLabel, type MicSelectorLabelProps, MicSelectorList, type MicSelectorListProps, type MicSelectorProps, MicSelectorTrigger, type MicSelectorTriggerProps, MicSelectorValue, type MicSelectorValueProps, ModelSelector, ModelSelectorContent, type ModelSelectorContentProps, ModelSelectorDialog, type ModelSelectorDialogProps, ModelSelectorEmpty, type ModelSelectorEmptyProps, ModelSelectorGroup, type ModelSelectorGroupProps, ModelSelectorInput, type ModelSelectorInputProps, ModelSelectorItem, type ModelSelectorItemProps, ModelSelectorList, type ModelSelectorListProps, ModelSelectorLogo, ModelSelectorLogoGroup, type ModelSelectorLogoGroupProps, type ModelSelectorLogoProps, ModelSelectorName, type ModelSelectorNameProps, type ModelSelectorProps, ModelSelectorSeparator, type ModelSelectorSeparatorProps, ModelSelectorShortcut, type ModelSelectorShortcutProps, ModelSelectorTrigger, type ModelSelectorTriggerProps, type MultiEnumFieldSpec, Node, NodeAction, type NodeActionProps, NodeContent, type NodeContentProps, NodeDescription, type NodeDescriptionProps, NodeFooter, type NodeFooterProps, NodeHeader, type NodeHeaderProps, type NodeProps, NodeTitle, type NodeTitleProps, NodeToolbar, type NodeToolbarProps, type NormalizedFormSpec, type NormalizedTableSpec, type NumberFieldSpec, OpenIn, OpenInChatGPT, type OpenInChatGPTProps, OpenInClaude, type OpenInClaudeProps, OpenInContent, type OpenInContentProps, OpenInCursor, type OpenInCursorProps, OpenInItem, type OpenInItemProps, OpenInLabel, type OpenInLabelProps, type OpenInProps, OpenInScira, type OpenInSciraProps, OpenInSeparator, type OpenInSeparatorProps, OpenInT3, type OpenInT3Props, OpenInTrigger, type OpenInTriggerProps, OpenInv0, type OpenInv0Props, PERSONA_SOURCES, PRODUCED_ASSET_ICONS, PackageInfo, PackageInfoChangeType, type PackageInfoChangeTypeProps, PackageInfoContent, type PackageInfoContentProps, PackageInfoDependencies, type PackageInfoDependenciesProps, PackageInfoDependency, type PackageInfoDependencyProps, PackageInfoDescription, type PackageInfoDescriptionProps, PackageInfoHeader, type PackageInfoHeaderProps, PackageInfoName, type PackageInfoNameProps, type PackageInfoProps, PackageInfoVersion, type PackageInfoVersionProps, Panel, type PanelProps, type PartDisplay, type PartGroupNode, Persona, type PersonaProps, type PersonaState, type PersonaVariant, Plan, PlanAction, type PlanActionProps, PlanContent, type PlanContentProps, PlanDescription, type PlanDescriptionProps, PlanFooter, type PlanFooterProps, PlanHeader, type PlanHeaderProps, type PlanProps, PlanTitle, type PlanTitleProps, PlanTrigger, type PlanTriggerProps, ProducedAssetTree, type ProducedAssetTreeProps, PromptInput, PromptInputActionAddAttachments, type PromptInputActionAddAttachmentsProps, PromptInputActionAddScreenshot, type PromptInputActionAddScreenshotProps, PromptInputActionMenu, PromptInputActionMenuContent, type PromptInputActionMenuContentProps, PromptInputActionMenuItem, type PromptInputActionMenuItemProps, type PromptInputActionMenuProps, PromptInputActionMenuTrigger, type PromptInputActionMenuTriggerProps, PromptInputBody, type PromptInputBodyProps, PromptInputButton, type PromptInputButtonProps, type PromptInputButtonTooltip, PromptInputCommand, PromptInputCommandEmpty, type PromptInputCommandEmptyProps, PromptInputCommandGroup, type PromptInputCommandGroupProps, PromptInputCommandInput, type PromptInputCommandInputProps, PromptInputCommandItem, type PromptInputCommandItemProps, PromptInputCommandList, type PromptInputCommandListProps, type PromptInputCommandProps, PromptInputCommandSeparator, type PromptInputCommandSeparatorProps, type PromptInputControllerProps, PromptInputFooter, type PromptInputFooterProps, PromptInputHeader, type PromptInputHeaderProps, PromptInputHoverCard, PromptInputHoverCardContent, type PromptInputHoverCardContentProps, type PromptInputHoverCardProps, PromptInputHoverCardTrigger, type PromptInputHoverCardTriggerProps, type PromptInputMessage, type PromptInputProps, PromptInputProvider, type PromptInputProviderProps, PromptInputSelect, PromptInputSelectContent, type PromptInputSelectContentProps, PromptInputSelectItem, type PromptInputSelectItemProps, type PromptInputSelectProps, PromptInputSelectTrigger, type PromptInputSelectTriggerProps, PromptInputSelectValue, type PromptInputSelectValueProps, PromptInputStop, type PromptInputStopProps, PromptInputSubmit, type PromptInputSubmitAction, type PromptInputSubmitProps, PromptInputTab, PromptInputTabBody, type PromptInputTabBodyProps, PromptInputTabItem, type PromptInputTabItemProps, PromptInputTabLabel, type PromptInputTabLabelProps, type PromptInputTabProps, PromptInputTabsList, type PromptInputTabsListProps, PromptInputTextarea, type PromptInputTextareaProps, PromptInputTools, type PromptInputToolsProps, Queue, QueueItem, QueueItemAction, type QueueItemActionProps, QueueItemActions, type QueueItemActionsProps, QueueItemAttachment, type QueueItemAttachmentProps, QueueItemContent, type QueueItemContentProps, QueueItemDescription, type QueueItemDescriptionProps, QueueItemFile, type QueueItemFileProps, QueueItemImage, type QueueItemImageProps, QueueItemIndicator, type QueueItemIndicatorProps, type QueueItemProps, QueueList, type QueueListProps, type QueueMessage, type QueueMessagePart, type QueueProps, QueueSection, QueueSectionContent, type QueueSectionContentProps, QueueSectionLabel, type QueueSectionLabelProps, type QueueSectionProps, QueueSectionTrigger, type QueueSectionTriggerProps, type QueueTodo, Reasoning, ReasoningContent, type ReasoningContentProps, type ReasoningProps, ReasoningTrigger, type ReasoningTriggerProps, type ReferencedSourcesContext, type RenderCell, Sandbox, SandboxContent, type SandboxContentProps, SandboxHeader, type SandboxHeaderProps, type SandboxProps, type SandboxRootProps, SandboxTabContent, type SandboxTabContentProps, SandboxTabs, SandboxTabsBar, type SandboxTabsBarProps, SandboxTabsList, type SandboxTabsListProps, type SandboxTabsProps, SandboxTabsTrigger, type SandboxTabsTriggerProps, SchemaDisplay, SchemaDisplayBody, type SchemaDisplayBodyProps, SchemaDisplayContent, type SchemaDisplayContentProps, SchemaDisplayDescription, type SchemaDisplayDescriptionProps, SchemaDisplayExample, type SchemaDisplayExampleProps, SchemaDisplayHeader, type SchemaDisplayHeaderProps, SchemaDisplayMethod, type SchemaDisplayMethodProps, SchemaDisplayParameter, type SchemaDisplayParameterProps, SchemaDisplayParameters, type SchemaDisplayParametersProps, SchemaDisplayPath, type SchemaDisplayPathProps, SchemaDisplayProperty, type SchemaDisplayPropertyProps, type SchemaDisplayProps, SchemaDisplayRequest, type SchemaDisplayRequestProps, SchemaDisplayResponse, type SchemaDisplayResponseProps, type SelectionSnapshot, SelectionToolbar, type SelectionToolbarProps, Shimmer, Snippet, SnippetAddon, type SnippetAddonProps, SnippetCopyButton, type SnippetCopyButtonProps, SnippetInput, type SnippetInputProps, type SnippetProps, SnippetText, type SnippetTextProps, Source, SourceList, type SourceListItem, type SourceListProps, type SourceProps, Sources, SourcesContent, type SourcesContentProps, type SourcesProps, SourcesTrigger, type SourcesTriggerProps, SpeechInput, type SpeechInputProps, StackTrace, StackTraceActions, type StackTraceActionsProps, StackTraceContent, type StackTraceContentProps, StackTraceCopyButton, type StackTraceCopyButtonProps, StackTraceError, StackTraceErrorMessage, type StackTraceErrorMessageProps, type StackTraceErrorProps, StackTraceErrorType, type StackTraceErrorTypeProps, StackTraceExpandButton, type StackTraceExpandButtonProps, StackTraceFrames, type StackTraceFramesProps, StackTraceHeader, type StackTraceHeaderProps, type StackTraceProps, StreamingSuggestions, type StreamingSuggestionsProps, type StringFieldSpec, Suggestion, SuggestionLoading, type SuggestionLoadingProps, type SuggestionProps, Suggestions, type SuggestionsProps, type TableRowData, type TableSort, type TableSpec, Task, TaskContent, type TaskContentProps, TaskItem, TaskItemFile, type TaskItemFileProps, type TaskItemProps, type TaskProps, TaskTrigger, type TaskTriggerProps, Terminal, TerminalActions, type TerminalActionsProps, TerminalClearButton, type TerminalClearButtonProps, TerminalContent, type TerminalContentProps, TerminalCopyButton, type TerminalCopyButtonProps, TerminalHeader, type TerminalHeaderProps, type TerminalProps, TerminalStatus, type TerminalStatusProps, TerminalTitle, type TerminalTitleProps, Test, TestDuration, type TestDurationProps, TestError, TestErrorMessage, type TestErrorMessageProps, type TestErrorProps, TestErrorStack, type TestErrorStackProps, TestName, type TestNameProps, type TestProps, TestResults, TestResultsContent, type TestResultsContentProps, TestResultsDuration, type TestResultsDurationProps, TestResultsHeader, type TestResultsHeaderProps, TestResultsMeta, type TestResultsMetaProps, TestResultsProgress, type TestResultsProgressProps, type TestResultsProps, TestResultsSummary, type TestResultsSummaryProps, TestStatus, type TestStatusProps, TestSuite, TestSuiteContent, type TestSuiteContentProps, TestSuiteName, type TestSuiteNameProps, type TestSuiteProps, TestSuiteStats, type TestSuiteStatsProps, type TextInputContext, type TextShimmerProps, Tool, ToolContent, type ToolContentProps, ToolDetails, type ToolDetailsProps, ToolHeader, type ToolHeaderProps, ToolInput, type ToolInputProps, ToolOutput, type ToolOutputProps, type ToolPart, type ToolProps, ToolResultCard, type ToolResultCardProps, Toolbar, type ToolbarProps, Transcription, type TranscriptionProps, TranscriptionSegment, type TranscriptionSegmentProps, UserMessage, type UserMessageProps, VoiceSelector, VoiceSelectorAccent, type VoiceSelectorAccentProps, VoiceSelectorAge, type VoiceSelectorAgeProps, VoiceSelectorAttributes, type VoiceSelectorAttributesProps, VoiceSelectorBullet, type VoiceSelectorBulletProps, VoiceSelectorContent, type VoiceSelectorContentProps, VoiceSelectorDescription, type VoiceSelectorDescriptionProps, VoiceSelectorDialog, type VoiceSelectorDialogProps, VoiceSelectorEmpty, type VoiceSelectorEmptyProps, VoiceSelectorGender, type VoiceSelectorGenderProps, VoiceSelectorGroup, type VoiceSelectorGroupProps, VoiceSelectorInput, type VoiceSelectorInputProps, VoiceSelectorItem, type VoiceSelectorItemProps, VoiceSelectorList, type VoiceSelectorListProps, VoiceSelectorName, type VoiceSelectorNameProps, VoiceSelectorPreview, type VoiceSelectorPreviewProps, type VoiceSelectorProps, VoiceSelectorSeparator, type VoiceSelectorSeparatorProps, VoiceSelectorShortcut, type VoiceSelectorShortcutProps, VoiceSelectorTrigger, type VoiceSelectorTriggerProps, WebPreview, WebPreviewBody, type WebPreviewBodyProps, WebPreviewConsole, type WebPreviewConsoleProps, type WebPreviewContextValue, WebPreviewNavigation, WebPreviewNavigationButton, type WebPreviewNavigationButtonProps, type WebPreviewNavigationProps, type WebPreviewProps, WebPreviewUrl, type WebPreviewUrlProps, agentMessageVariants, badgeToneForValue, booleanFieldSchema, buildInteractiveTerminalTheme, buildPartGroups, cellFormatSchema, columnSpecSchema, compareCellValues, createLazyMermaidPlugin, defaultPartStatus, enumFieldSchema, enumOptionSchema, fieldLabel, fieldSpecSchema, formSpecSchema, formatCellValue, getAttachmentLabel, getMediaCategory, getStatusBadge, groupPartByType, highlightCode, initialFormValues, inlineCitationSourceLabel, integerFieldSchema, isEmptyCell, isGroupNode, isNumericFormat, lazyMermaid, messageActionsVariants, messageFeedbackVariants, messagesToMarkdown, multiEnumFieldSchema, normalizeFormSpec, normalizeTableSpec, numberFieldSchema, optionLabel, optionValue, partsFingerprint, preloadMermaid, readSelectionWithin, rollupStatus, statusFromToolState, stringFieldSchema, tableSpecSchema, useAssetPreviewRenderer, useAttachmentContext, useAttachmentsContext, useAudioDevices, useContextPanel, useJSXPreview, useMessageEdit, usePromptInputAttachments, usePromptInputController, usePromptInputReferencedSources, useProviderAttachments, useReasoning, useVoiceSelector, validateField, validateForm };