@omniviewdev/ai-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,785 @@
+import { ComponentSize } from '../../../../base-ui/src/index.ts';
+import { ComponentType } from 'react';
+import { ComponentVariant } from '../../../../base-ui/src/index.ts';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { NamedExoticComponent } from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+
+export declare const AgentControls: ForwardRefExoticComponent<AgentControlsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AgentControlsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Current agent status */
+    status: AgentStatus;
+    onStart?: () => void;
+    onStop?: () => void;
+    onPause?: () => void;
+    onResume?: () => void;
+}
+
+export declare type AgentStatus = 'idle' | 'running' | 'paused' | 'complete' | 'error';
+
+export declare const AgentStatusItem: ForwardRefExoticComponent<AgentStatusItemProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AgentStatusItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Task label */
+    label: string;
+    /** Current status */
+    status: AgentStatus;
+    /** Optional detail text */
+    detail?: string;
+}
+
+export declare interface AgentTask {
+    id: string;
+    label: string;
+    status: AgentStatus;
+    detail?: string;
+}
+
+export declare const AgentTaskList: ForwardRefExoticComponent<AgentTaskListProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AgentTaskListProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** List of agent tasks */
+    tasks: AgentTask[];
+}
+
+export declare const AIActionConfirmation: ForwardRefExoticComponent<AIActionConfirmationProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIActionConfirmationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** Action title */
+    title: string;
+    /** Description of the action */
+    description: string;
+    /** Whether this is a destructive action */
+    destructive?: boolean;
+    /** Optional resource identifier (e.g. "production/web-deploy") */
+    resource?: string;
+    /** Optional custom icon override */
+    icon?: ReactNode;
+    /** Confirm button label. Default: "Apply" (or "Confirm" for destructive). */
+    confirmLabel?: string;
+    /** Cancel button label. Default: "Cancel". */
+    cancelLabel?: string;
+    /** Confirm callback */
+    onConfirm: () => void;
+    /** Cancel callback */
+    onCancel: () => void;
+}
+
+export declare const AIArtifact: ForwardRefExoticComponent<AIArtifactProps & RefAttributes<HTMLDivElement>>;
+
+export declare const AIArtifactAction: ForwardRefExoticComponent<AIArtifactActionProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AIArtifactActionProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+    /** Tooltip text */
+    tooltip?: string;
+    /** Button label (for accessibility, may be visually hidden) */
+    label: string;
+    /** Icon component */
+    icon?: ComponentType<{
+        size?: number;
+    }>;
+    /** Destructive action styling */
+    destructive?: boolean;
+}
+
+export declare const AIArtifactActions: ForwardRefExoticComponent<AIArtifactActionsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIArtifactActionsProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare const AIArtifactClose: ForwardRefExoticComponent<AIArtifactCloseProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AIArtifactCloseProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+}
+
+export declare const AIArtifactContent: ForwardRefExoticComponent<AIArtifactContentProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIArtifactContentProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare const AIArtifactDescription: ForwardRefExoticComponent<AIArtifactDescriptionProps & RefAttributes<HTMLParagraphElement>>;
+
+export declare interface AIArtifactDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {
+    children: ReactNode;
+}
+
+export declare const AIArtifactHeader: ForwardRefExoticComponent<AIArtifactHeaderProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIArtifactHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare interface AIArtifactProps extends HTMLAttributes<HTMLDivElement> {
+    /** Whether the artifact panel is open (for panel mode) */
+    open?: boolean;
+    /** Visual mode */
+    variant?: 'embedded' | 'panel';
+    children: ReactNode;
+}
+
+export declare const AIArtifactTitle: ForwardRefExoticComponent<AIArtifactTitleProps & RefAttributes<HTMLHeadingElement>>;
+
+export declare interface AIArtifactTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+    children: ReactNode;
+}
+
+export declare const AIAttachment: ForwardRefExoticComponent<AIAttachmentProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIAttachmentProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** File name */
+    name: string;
+    /** File size in bytes */
+    size?: number;
+    /** File type category */
+    type: 'file' | 'image' | 'code' | 'document';
+    /** Preview URL (for images) */
+    previewUrl?: string;
+    /** Remove callback */
+    onRemove?: () => void;
+}
+
+export declare const AIBranch: ForwardRefExoticComponent<AIBranchProps & RefAttributes<HTMLDivElement>>;
+
+export declare const AIBranchContent: ForwardRefExoticComponent<AIBranchContentProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIBranchContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** Branch index this content belongs to */
+    index: number;
+    children: ReactNode;
+}
+
+export declare const AIBranchIndicator: ForwardRefExoticComponent<AIBranchIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface AIBranchIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+}
+
+export declare const AIBranchNext: ForwardRefExoticComponent<AIBranchNextProps & RefAttributes<HTMLElement>>;
+
+export declare interface AIBranchNextProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+}
+
+export declare const AIBranchPrevious: ForwardRefExoticComponent<AIBranchPreviousProps & RefAttributes<HTMLElement>>;
+
+export declare interface AIBranchPreviousProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+}
+
+export declare interface AIBranchProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Total number of branches */
+    count: number;
+    /** Currently active branch index (0-based) */
+    active: number;
+    /** Called when the user navigates to a different branch */
+    onChange?: (index: number) => void;
+    children: ReactNode;
+}
+
+export declare const AIBranchSelector: ForwardRefExoticComponent<AIBranchSelectorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIBranchSelectorProps extends HTMLAttributes<HTMLDivElement> {
+    /** Alignment hint for positioning */
+    align?: 'start' | 'end';
+}
+
+export declare const AICodeBlock: ForwardRefExoticComponent<AICodeBlockProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AICodeBlockProps extends HTMLAttributes<HTMLDivElement> {
+    /** Code content */
+    code: string;
+    /** Programming language */
+    language?: string;
+    /** Optional filename header */
+    filename?: string;
+    /** Show line numbers (default: false) */
+    showLineNumbers?: boolean;
+    /** Action buttons (copy, apply, insert) */
+    actions?: ReactNode;
+}
+
+export declare const AICommandSuggestion: ForwardRefExoticComponent<AICommandSuggestionProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AICommandSuggestionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** The command to suggest */
+    command: string;
+    /** Description of what the command does */
+    description?: string;
+    /** Whether the command is destructive */
+    destructive?: boolean;
+    /** Apply/execute callback */
+    onApply?: () => void;
+    /** Copy callback */
+    onCopy?: () => void;
+}
+
+export declare const AIContextIndicator: ForwardRefExoticComponent<AIContextIndicatorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIContextIndicatorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** Context items available */
+    items: ContextItem[];
+    /** Max items to show before "+N more" (default: 3) */
+    maxVisible?: number;
+}
+
+export declare const AIConversationHeader: ForwardRefExoticComponent<AIConversationHeaderProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIConversationHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    /** Conversation title */
+    title: string;
+    /** Model name or info */
+    model?: string;
+    /** New chat callback */
+    onNewChat?: () => void;
+    /** Settings callback */
+    onSettings?: () => void;
+    /** Additional actions slot */
+    actions?: ReactNode;
+}
+
+export declare const AICostIndicator: ForwardRefExoticComponent<AICostIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface AICostIndicatorProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    /** Cost value */
+    cost: number;
+    /** Currency symbol (default: "$") */
+    currency?: string;
+}
+
+export declare const AIErrorMessage: ForwardRefExoticComponent<AIErrorMessageProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIErrorMessageProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** Error title (default: "Generation failed") */
+    title?: string;
+    /** Error message/description */
+    message: string;
+    /** Retry callback */
+    onRetry?: () => void;
+}
+
+export declare const AIFollowUp: ForwardRefExoticComponent<AIFollowUpProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIFollowUpProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color' | 'onSelect'> {
+    /** Suggested follow-up questions */
+    suggestions: string[];
+    /** Called when a suggestion is selected */
+    onSelect?: (suggestion: string) => void;
+}
+
+export declare const AIImageGeneration: ForwardRefExoticComponent<AIImageGenerationProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIImageGenerationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** Generated image URL */
+    src?: string;
+    /** Alt text */
+    alt: string;
+    /** Whether image is still generating */
+    loading?: boolean;
+    /** Image prompt used */
+    prompt?: string;
+    /** Expected aspect ratio (width / height). Default: 1 (square). */
+    aspectRatio?: number;
+}
+
+export declare const AIInferenceStats: ForwardRefExoticComponent<AIInferenceStatsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIInferenceStatsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Tokens per second throughput */
+    throughput?: number;
+    /** Total tokens generated */
+    tokenCount?: number;
+    /** Latency in seconds */
+    latency?: number;
+    /** Stop reason (e.g. "EOS Token Found", "max_tokens") */
+    stopReason?: string;
+    /** Optional input token breakdown */
+    inputTokens?: number;
+    /** Optional output token breakdown */
+    outputTokens?: number;
+}
+
+export declare const AIInlineCitation: ForwardRefExoticComponent<AIInlineCitationProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface AIInlineCitationProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Citation index number */
+    index: number;
+    /** Source label (shown in tooltip) */
+    source?: string;
+    /** Click handler to navigate to source */
+    onNavigate?: () => void;
+}
+
+export declare const AIMarkdown: ForwardRefExoticComponent<AIMarkdownProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIMarkdownProps extends HTMLAttributes<HTMLDivElement> {
+    /** Async iterable that yields markdown chunks (e.g., from an LLM API) */
+    stream?: AsyncIterable<string>;
+    /** Static markdown content */
+    content?: string;
+    /** Whether content is still actively streaming (only needed when using content prop directly) */
+    streaming?: boolean;
+    /** Show blinking cursor while streaming (default: true) */
+    cursor?: boolean;
+    /** Callback when streaming completes */
+    onComplete?: () => void;
+    /** Callback with accumulated markdown on each chunk */
+    onChunk?: (accumulated: string) => void;
+}
+
+export declare const AIMessageActions: ForwardRefExoticComponent<AIMessageActionsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIMessageActionsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Copy message content */
+    onCopy?: () => void;
+    /** Regenerate response */
+    onRegenerate?: () => void;
+    /** Edit message */
+    onEdit?: () => void;
+    /** Share or forward message */
+    onShare?: () => void;
+    /** Branch/fork conversation from this message */
+    onBranch?: () => void;
+    /** Delete message */
+    onDelete?: () => void;
+    /** Feedback value: 'positive' | 'negative' | null */
+    feedback?: 'positive' | 'negative' | null;
+    /** Feedback callback */
+    onFeedback?: (value: 'positive' | 'negative') => void;
+}
+
+export declare const AIMessageEditor: ForwardRefExoticComponent<AIMessageEditorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIMessageEditorProps extends HTMLAttributes<HTMLDivElement> {
+    /** Initial text content to edit */
+    defaultValue: string;
+    /** Called with the edited text when the user saves */
+    onSave: (value: string) => void;
+    /** Called when the user cancels editing */
+    onCancel: () => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the save action is in progress (disables controls) */
+    saving?: boolean;
+    /** Auto-focus the textarea on mount (default: true) */
+    autoFocus?: boolean;
+}
+
+export declare const AIMessageGroup: ForwardRefExoticComponent<AIMessageGroupProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIMessageGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Chat role for the group */
+    role: ChatRole;
+    /** Avatar to show once for the group */
+    avatar?: ReactNode;
+    children: ReactNode;
+}
+
+export declare interface AIModel {
+    id: string;
+    name: string;
+    description?: string;
+}
+
+export declare const AIModelSelector: ForwardRefExoticComponent<AIModelSelectorProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AIModelSelectorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color' | 'onChange'> {
+    /** Available models */
+    models: AIModel[];
+    /** Currently selected model ID */
+    value?: string;
+    /** Selection callback */
+    onChange?: (modelId: string) => void;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Size variant. Default: 'sm'. */
+    size?: ComponentSize;
+    /** Visual variant. Default: 'outline'. */
+    variant?: ComponentVariant;
+    /** Whether to show the bot icon. Default: true. */
+    showIcon?: boolean;
+}
+
+export declare const AIRetryButton: ForwardRefExoticComponent<AIRetryButtonProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AIRetryButtonProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+    /** Retry callback */
+    onRetry: () => void;
+    /** Whether retry is in progress */
+    retrying?: boolean;
+    /** Label (default: "Retry") */
+    label?: string;
+}
+
+export declare interface AISource {
+    id: string;
+    label: string;
+    url?: string;
+    detail?: string;
+}
+
+export declare const AISources: ForwardRefExoticComponent<AISourcesProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AISourcesProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** List of sources */
+    sources: AISource[];
+    /** Called when a source is clicked */
+    onNavigate?: (source: AISource) => void;
+}
+
+export declare const AIStopButton: ForwardRefExoticComponent<AIStopButtonProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface AIStopButtonProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'color'> {
+    /** Click handler to stop generation */
+    onStop: () => void;
+    /** Whether stop is in progress */
+    stopping?: boolean;
+    /** Button label (default: "Stop generating") */
+    label?: string;
+}
+
+export declare const AITokenUsage: ForwardRefExoticComponent<AITokenUsageProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface AITokenUsageProps extends HTMLAttributes<HTMLDivElement> {
+    /** Input/prompt token count */
+    inputTokens: number;
+    /** Output/completion token count */
+    outputTokens: number;
+    /** Optional total (defaults to input + output) */
+    total?: number;
+}
+
+/**
+ * Brain icon used by ThinkingBlock and ChainOfThought for visual consistency.
+ * Inline SVG to avoid dependency on a specific icon library for the "thinking" look.
+ */
+declare const BrainIcon: NamedExoticComponent<    {
+size?: number;
+}>;
+export { BrainIcon }
+export { BrainIcon as ThinkingBrainIcon }
+
+export declare const ChainOfThought: ForwardRefExoticComponent<ChainOfThoughtProps & RefAttributes<HTMLDivElement>>;
+
+export declare const ChainOfThoughtFile: NamedExoticComponent<ChainOfThoughtFileProps>;
+
+export declare interface ChainOfThoughtFileProps {
+    /** Display name (filename, resource name, etc.) */
+    name: string;
+    /** Resource type — determines the icon */
+    type?: 'file' | 'resource' | 'log' | 'config' | 'query' | 'url';
+    /** Full path or identifier (shown in tooltip) */
+    path?: string;
+    /** Click handler (e.g., navigate to resource) */
+    onClick?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+
+export declare function ChainOfThoughtFiles({ children, className, ...rest }: ChainOfThoughtFilesProps): JSX.Element;
+
+export declare interface ChainOfThoughtFilesProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare function ChainOfThoughtHeader({ children, className, ...rest }: ChainOfThoughtHeaderProps): JSX.Element;
+
+export declare interface ChainOfThoughtHeaderProps extends HTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode;
+}
+
+export declare function ChainOfThoughtImage({ caption, children, className, ...rest }: ChainOfThoughtImageProps): JSX.Element;
+
+export declare interface ChainOfThoughtImageProps extends HTMLAttributes<HTMLDivElement> {
+    caption?: string;
+}
+
+export declare interface ChainOfThoughtProps extends HTMLAttributes<HTMLDivElement> {
+    /** Declarative steps API (alternative to using children) */
+    steps?: ChainOfThoughtStepData[];
+    /** Start expanded (default: false) */
+    defaultOpen?: boolean;
+    /** Controlled open state */
+    open?: boolean;
+    /** Header text (default: "Chain of Thought") */
+    header?: string;
+    /** Custom header content (overrides header text) */
+    headerContent?: ReactNode;
+    /** Child elements (for compound component pattern) */
+    children?: ReactNode;
+}
+
+export declare function ChainOfThoughtSearchResult({ label, children, className, }: ChainOfThoughtSearchResultProps): JSX.Element;
+
+declare interface ChainOfThoughtSearchResultProps {
+    /** Text label for the chip */
+    label?: string;
+    children?: ReactNode;
+    className?: string;
+}
+
+export declare function ChainOfThoughtSearchResults({ children, className, ...rest }: HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+export declare function ChainOfThoughtStep({ icon: Icon, label, description, status, tags, children, className, ...rest }: ChainOfThoughtStepProps): JSX.Element;
+
+export declare interface ChainOfThoughtStepData {
+    id: string;
+    label: string;
+    content?: string;
+    description?: string;
+    status: StepStatus;
+    /** Icon component override */
+    icon?: ComponentType<{
+        size?: number | string;
+        className?: string;
+    }>;
+    /** Tags/chips to show under the step */
+    tags?: string[];
+    /** Arbitrary children rendered after description/tags */
+    children?: ReactNode;
+}
+
+export declare interface ChainOfThoughtStepProps extends HTMLAttributes<HTMLDivElement> {
+    /** Icon component for the step */
+    icon?: ComponentType<{
+        size?: number | string;
+        className?: string;
+    }>;
+    /** Step label text */
+    label: string;
+    /** Description text below label */
+    description?: string;
+    /** Step status */
+    status?: StepStatus;
+    /** Tags/chips to display */
+    tags?: string[];
+    /** Arbitrary children (rendered after description and tags) */
+    children?: ReactNode;
+}
+
+export declare const ChatAvatar: ForwardRefExoticComponent<ChatAvatarProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ChatAvatarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Role determines default icon/color */
+    role: ChatRole;
+    /** Image source for the avatar */
+    src?: string;
+    /** Display name (used for initials fallback) */
+    name?: string;
+}
+
+export declare const ChatBubble: ForwardRefExoticComponent<ChatBubbleProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ChatBubbleProps extends HTMLAttributes<HTMLDivElement> {
+    /** Message role determines alignment and styling */
+    role: ChatRole;
+    /** Avatar node rendered beside the bubble */
+    avatar?: ReactNode;
+    /** Timestamp of the message */
+    timestamp?: Date;
+    /** Action buttons (copy, retry, edit) shown on hover */
+    actions?: ReactNode;
+}
+
+export declare const ChatInput: ForwardRefExoticComponent<ChatInputProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ChatInputProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'onSubmit'> {
+    /** Current input value */
+    value: string;
+    /** Callback when value changes */
+    onChange: (value: string) => void;
+    /** Callback when user submits (Enter without Shift) */
+    onSubmit: (value: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Disable input */
+    disabled?: boolean;
+    /** Auto-focus textarea on mount (default: false) */
+    autoFocus?: boolean;
+    /** Re-focus textarea when `disabled` transitions from true → false (default: true) */
+    focusOnEnable?: boolean;
+    /** Re-focus textarea when the window regains focus (default: true) */
+    focusOnWindowFocus?: boolean;
+    /** Left-aligned toolbar items (e.g. attachment button, model selector, capability chips) */
+    startActions?: ReactNode;
+    /** Right-aligned toolbar items (e.g. token counter, send/stop button) */
+    endActions?: ReactNode;
+}
+
+export declare const ChatMessageList: ForwardRefExoticComponent<ChatMessageListProps & RefAttributes<ChatMessageListHandle>>;
+
+export declare interface ChatMessageListHandle {
+    scrollToBottom: () => void;
+    scrollToIndex: (index: number) => void;
+    getScrollElement: () => HTMLDivElement | null;
+}
+
+export declare interface ChatMessageListProps extends HTMLAttributes<HTMLDivElement> {
+    /** Auto-scroll to bottom on new children (default: true) */
+    autoScroll?: boolean;
+    /** Callback when user scrolls to top (for loading older messages) */
+    onScrollToTop?: () => void;
+    /** Total number of items for virtualization */
+    count: number;
+    /** Estimated height per item in pixels (default: 80) */
+    estimateSize?: number;
+    /** Render function for each item by index */
+    renderItem: (index: number) => React.ReactNode;
+}
+
+export declare type ChatRole = 'user' | 'assistant' | 'system';
+
+export declare interface ChatSuggestion {
+    label: string;
+    value: string;
+}
+
+export declare const ChatSuggestions: ForwardRefExoticComponent<ChatSuggestionsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ChatSuggestionsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** List of suggested prompts */
+    suggestions: ChatSuggestion[];
+    /** Called when a suggestion is selected */
+    onSelect: (value: string) => void;
+}
+
+export declare interface ContextItem {
+    type: 'file' | 'tool' | 'database' | 'custom';
+    label: string;
+    icon?: ReactNode;
+}
+
+export declare const PermissionRequest: ForwardRefExoticComponent<PermissionRequestProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface PermissionRequestProps extends Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** Tool requesting permission */
+    tool: string;
+    /** Human-readable description of the action */
+    description: string;
+    /** Permission scope (e.g. "workspace", "file:/path") */
+    scope: string;
+    /** Raw content to review — shell command, file path, script, etc. */
+    content?: string;
+    /** Allow this specific action */
+    onAllow: () => void;
+    /** Deny this action */
+    onDeny: () => void;
+    /** Allow permanently for this tool */
+    onAllowAlways?: () => void;
+}
+
+export declare type StepStatus = 'pending' | 'active' | 'complete' | 'error';
+
+export declare const StreamingText: ForwardRefExoticComponent<StreamingTextProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface StreamingTextProps extends HTMLAttributes<HTMLDivElement> {
+    /** Async iterable that yields text chunks (e.g., from an LLM API) */
+    stream?: AsyncIterable<string>;
+    /** Static content to display (no streaming animation) */
+    content?: string;
+    /** Show blinking cursor while streaming (default: true) */
+    cursor?: boolean;
+    /** Callback when streaming completes */
+    onComplete?: () => void;
+    /** Callback with accumulated text on each chunk */
+    onChunk?: (accumulated: string) => void;
+}
+
+export declare const ThinkingBlock: ForwardRefExoticComponent<ThinkingBlockProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ThinkingBlockProps extends HTMLAttributes<HTMLDivElement> {
+    /** Static reasoning text content (use `stream` for incremental input) */
+    content?: string;
+    /** Async iterable that yields thinking text chunks — the primary API for
+     *  real model integrations where thinking tokens arrive incrementally.
+     *  Automatically manages streaming state and duration measurement. */
+    stream?: AsyncIterable<string>;
+    /** Start expanded (default: false) */
+    defaultExpanded?: boolean;
+    /** Whether content is still streaming in (only needed with `content` prop;
+     *  automatically managed when using `stream`) */
+    streaming?: boolean;
+    /** Thinking duration in ms (automatically measured when using `stream`) */
+    duration?: number;
+    /** Callback fired when the stream finishes */
+    onComplete?: () => void;
+    /** Auto-close after streaming completes (default: true) */
+    autoClose?: boolean;
+    /** Delay before auto-closing in ms (default: 1000) */
+    autoCloseDelay?: number;
+    /** Custom trigger content (replaces default trigger) */
+    trigger?: ReactNode;
+}
+
+export declare function ThinkingTrigger({ children, className, ...rest }: HTMLAttributes<HTMLButtonElement>): JSX.Element;
+
+export declare const ToolCall: ForwardRefExoticComponent<ToolCallProps & RefAttributes<HTMLDivElement>>;
+
+export declare const ToolCallList: ForwardRefExoticComponent<ToolCallListProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ToolCallListItem {
+    id: string;
+    name: string;
+    arguments?: Record<string, unknown>;
+    status: ToolCallStatus;
+    duration?: number;
+    /** Result content — can be a static ReactNode or a streaming component.
+     *  Rendered inside the ToolCall's collapsible children area. */
+    result?: ReactNode;
+    resultStatus?: 'success' | 'error';
+    /** Whether the item should be expanded (default: auto — expands when running
+     *  with result content, collapses when complete) */
+    expanded?: boolean;
+}
+
+export declare interface ToolCallListProps extends HTMLAttributes<HTMLDivElement> {
+    /** List of tool calls with optional results */
+    calls: ToolCallListItem[];
+}
+
+export declare interface ToolCallProps extends HTMLAttributes<HTMLDivElement> {
+    /** Tool function name */
+    name: string;
+    /** Tool arguments (shown in collapsible detail section) */
+    arguments?: Record<string, unknown>;
+    /** Current execution status */
+    status: ToolCallStatus;
+    /** Execution duration in ms */
+    duration?: number;
+    /** Whether the detail section (args + children) starts expanded.
+     *  Defaults to false. Automatically opens when status transitions to
+     *  'running' if there are children to show. */
+    defaultExpanded?: boolean;
+    /** Controlled expanded state (overrides internal state) */
+    expanded?: boolean;
+    /** Result content rendered below the arguments. Use this for tool output —
+     *  can be a static ReactNode or a streaming component like
+     *  `<StreamingText stream={...} />`. Content is visible when expanded. */
+    children?: ReactNode;
+}
+
+export declare type ToolCallStatus = 'pending' | 'running' | 'success' | 'error';
+
+export declare const ToolResult: ForwardRefExoticComponent<ToolResultProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ToolResultProps extends Omit<HTMLAttributes<HTMLDivElement>, 'content' | 'color'> {
+    /** Result content */
+    content: ReactNode;
+    /** Result status */
+    status: 'success' | 'error';
+    /** Whether the content is truncated */
+    truncated?: boolean;
+    /** Callback to expand truncated content */
+    onExpand?: () => void;
+}
+
+export declare const TypingIndicator: ForwardRefExoticComponent<TypingIndicatorProps & RefAttributes<HTMLSpanElement>>;
+
+export declare interface TypingIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Optional label text beside the dots (e.g. "Claude is thinking...") */
+    label?: string;
+}
+
+export { }