@arc-lo/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,515 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, TextareaHTMLAttributes } from 'react';
+
+type StreamingState = "pending" | "streaming" | "done" | "interrupted" | "error" | "ratelimit";
+type ConfidenceLevel = "high" | "medium" | "low" | "unknown";
+type ChunkSize = "char" | "word" | "line";
+
+interface UseStreamingTextOptions {
+    /** ReadableStream of text chunks from an AI response */
+    stream?: ReadableStream<string> | null;
+    /** Plain text to stream (alternative to stream) */
+    text?: string;
+    /** Delay in ms between rendering chunks. Default: 30 */
+    speed?: number;
+    /** How to chunk the text for rendering. Default: "char" */
+    chunkSize?: ChunkSize;
+    /** Called when streaming completes */
+    onDone?: (text: string) => void;
+    /** Called on error */
+    onError?: (error: Error) => void;
+    /** Called when interrupted by user */
+    onInterrupt?: (partialText: string) => void;
+}
+interface UseStreamingTextReturn {
+    /** The text rendered so far */
+    displayedText: string;
+    /** The full text received (may be ahead of displayedText during animation) */
+    fullText: string;
+    /** Current state of the streaming component */
+    state: StreamingState;
+    /** Stop streaming and rendering */
+    interrupt: () => void;
+    /** Reset to pending state */
+    reset: () => void;
+    /** Jump to showing all received text immediately */
+    skipAnimation: () => void;
+}
+declare function useStreamingText({ stream, text, speed, chunkSize, onDone, onError, onInterrupt, }: UseStreamingTextOptions): UseStreamingTextReturn;
+
+interface StreamingTextContextValue {
+    displayedText: string;
+    fullText: string;
+    state: StreamingState;
+    interrupt: () => void;
+    reset: () => void;
+    skipAnimation: () => void;
+}
+declare function useStreamingTextContext(): StreamingTextContextValue;
+interface StreamingTextRootProps extends UseStreamingTextOptions, Omit<HTMLAttributes<HTMLDivElement>, "children" | "onError"> {
+    children?: ReactNode;
+}
+declare const Root$5: react.ForwardRefExoticComponent<StreamingTextRootProps & react.RefAttributes<HTMLDivElement>>;
+interface StreamingTextContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** Custom render function for the text */
+    render?: (text: string) => ReactNode;
+}
+declare const Content$1: react.ForwardRefExoticComponent<StreamingTextContentProps & react.RefAttributes<HTMLDivElement>>;
+interface StreamingTextCursorProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Character to use as cursor. Default: "▋" */
+    char?: string;
+}
+declare const Cursor: react.ForwardRefExoticComponent<StreamingTextCursorProps & react.RefAttributes<HTMLSpanElement>>;
+interface StreamingTextSkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    /** Number of skeleton lines. Default: 3 */
+    lines?: number;
+}
+declare const Skeleton: react.ForwardRefExoticComponent<StreamingTextSkeletonProps & react.RefAttributes<HTMLDivElement>>;
+interface StreamingTextErrorProps extends HTMLAttributes<HTMLDivElement> {
+    /** Custom error message */
+    message?: string;
+    /** Show retry button */
+    onRetry?: () => void;
+}
+declare const ErrorFallback: react.ForwardRefExoticComponent<StreamingTextErrorProps & react.RefAttributes<HTMLDivElement>>;
+interface StreamingTextRateLimitProps extends HTMLAttributes<HTMLDivElement> {
+    /** Retry delay in seconds */
+    retryAfter?: number;
+    message?: string;
+}
+declare const RateLimit: react.ForwardRefExoticComponent<StreamingTextRateLimitProps & react.RefAttributes<HTMLDivElement>>;
+interface StreamingTextToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Only show toolbar in these states. Default: ["done", "interrupted"] */
+    showIn?: StreamingState[];
+}
+declare const Toolbar: react.ForwardRefExoticComponent<StreamingTextToolbarProps & react.RefAttributes<HTMLDivElement>>;
+interface StreamingTextStopProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const Stop: react.ForwardRefExoticComponent<StreamingTextStopProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare const index$5_Cursor: typeof Cursor;
+declare const index$5_ErrorFallback: typeof ErrorFallback;
+declare const index$5_RateLimit: typeof RateLimit;
+declare const index$5_Skeleton: typeof Skeleton;
+declare const index$5_Stop: typeof Stop;
+type index$5_StreamingTextContentProps = StreamingTextContentProps;
+type index$5_StreamingTextCursorProps = StreamingTextCursorProps;
+type index$5_StreamingTextErrorProps = StreamingTextErrorProps;
+type index$5_StreamingTextRateLimitProps = StreamingTextRateLimitProps;
+type index$5_StreamingTextRootProps = StreamingTextRootProps;
+type index$5_StreamingTextSkeletonProps = StreamingTextSkeletonProps;
+type index$5_StreamingTextStopProps = StreamingTextStopProps;
+type index$5_StreamingTextToolbarProps = StreamingTextToolbarProps;
+declare const index$5_Toolbar: typeof Toolbar;
+type index$5_UseStreamingTextOptions = UseStreamingTextOptions;
+type index$5_UseStreamingTextReturn = UseStreamingTextReturn;
+declare const index$5_useStreamingText: typeof useStreamingText;
+declare const index$5_useStreamingTextContext: typeof useStreamingTextContext;
+declare namespace index$5 {
+  export { Content$1 as Content, index$5_Cursor as Cursor, index$5_ErrorFallback as ErrorFallback, index$5_RateLimit as RateLimit, Root$5 as Root, index$5_Skeleton as Skeleton, index$5_Stop as Stop, type index$5_StreamingTextContentProps as StreamingTextContentProps, type index$5_StreamingTextCursorProps as StreamingTextCursorProps, type index$5_StreamingTextErrorProps as StreamingTextErrorProps, type index$5_StreamingTextRateLimitProps as StreamingTextRateLimitProps, type index$5_StreamingTextRootProps as StreamingTextRootProps, type index$5_StreamingTextSkeletonProps as StreamingTextSkeletonProps, type index$5_StreamingTextStopProps as StreamingTextStopProps, type index$5_StreamingTextToolbarProps as StreamingTextToolbarProps, index$5_Toolbar as Toolbar, type index$5_UseStreamingTextOptions as UseStreamingTextOptions, type index$5_UseStreamingTextReturn as UseStreamingTextReturn, index$5_useStreamingText as useStreamingText, index$5_useStreamingTextContext as useStreamingTextContext };
+}
+
+interface PromptBoxContextValue {
+    value: string;
+    setValue: (v: string) => void;
+    submit: () => void;
+    isSubmitting: boolean;
+    disabled: boolean;
+}
+declare function usePromptBoxContext(): PromptBoxContextValue;
+interface PromptBoxRootProps extends Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    /** Controlled value */
+    value?: string;
+    /** Default uncontrolled value */
+    defaultValue?: string;
+    /** Called when the prompt is submitted */
+    onSubmit?: (value: string) => void;
+    /** Called when value changes */
+    onValueChange?: (value: string) => void;
+    /** Whether a submission is in progress */
+    isSubmitting?: boolean;
+    /** Disable the entire prompt box */
+    disabled?: boolean;
+    children?: ReactNode;
+}
+declare const Root$4: react.ForwardRefExoticComponent<PromptBoxRootProps & react.RefAttributes<HTMLFormElement>>;
+interface PromptBoxChipsProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Chips: react.ForwardRefExoticComponent<PromptBoxChipsProps & react.RefAttributes<HTMLDivElement>>;
+interface PromptBoxChipProps extends HTMLAttributes<HTMLSpanElement> {
+    onRemove?: () => void;
+}
+declare const Chip: react.ForwardRefExoticComponent<PromptBoxChipProps & react.RefAttributes<HTMLSpanElement>>;
+interface PromptBoxInputProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "onChange"> {
+    /** Min rows. Default: 1 */
+    minRows?: number;
+    /** Max rows before scroll. Default: 8 */
+    maxRows?: number;
+}
+declare const Input$1: react.ForwardRefExoticComponent<PromptBoxInputProps & react.RefAttributes<HTMLTextAreaElement>>;
+interface PromptBoxFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Footer: react.ForwardRefExoticComponent<PromptBoxFooterProps & react.RefAttributes<HTMLDivElement>>;
+interface PromptBoxSubmitProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const SubmitButton: react.ForwardRefExoticComponent<PromptBoxSubmitProps & react.RefAttributes<HTMLButtonElement>>;
+interface PromptBoxSuggestionsProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    suggestions: string[];
+    onSelect?: (suggestion: string) => void;
+}
+declare const Suggestions: react.ForwardRefExoticComponent<PromptBoxSuggestionsProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const index$4_Chip: typeof Chip;
+declare const index$4_Chips: typeof Chips;
+declare const index$4_Footer: typeof Footer;
+type index$4_PromptBoxChipProps = PromptBoxChipProps;
+type index$4_PromptBoxChipsProps = PromptBoxChipsProps;
+type index$4_PromptBoxFooterProps = PromptBoxFooterProps;
+type index$4_PromptBoxInputProps = PromptBoxInputProps;
+type index$4_PromptBoxRootProps = PromptBoxRootProps;
+type index$4_PromptBoxSubmitProps = PromptBoxSubmitProps;
+type index$4_PromptBoxSuggestionsProps = PromptBoxSuggestionsProps;
+declare const index$4_SubmitButton: typeof SubmitButton;
+declare const index$4_Suggestions: typeof Suggestions;
+declare const index$4_usePromptBoxContext: typeof usePromptBoxContext;
+declare namespace index$4 {
+  export { index$4_Chip as Chip, index$4_Chips as Chips, index$4_Footer as Footer, Input$1 as Input, type index$4_PromptBoxChipProps as PromptBoxChipProps, type index$4_PromptBoxChipsProps as PromptBoxChipsProps, type index$4_PromptBoxFooterProps as PromptBoxFooterProps, type index$4_PromptBoxInputProps as PromptBoxInputProps, type index$4_PromptBoxRootProps as PromptBoxRootProps, type index$4_PromptBoxSubmitProps as PromptBoxSubmitProps, type index$4_PromptBoxSuggestionsProps as PromptBoxSuggestionsProps, Root$4 as Root, index$4_SubmitButton as SubmitButton, index$4_Suggestions as Suggestions, index$4_usePromptBoxContext as usePromptBoxContext };
+}
+
+type FeedbackValue = "up" | "down" | null;
+interface FeedbackBarRootProps extends HTMLAttributes<HTMLDivElement> {
+    /** Called when thumbs feedback changes */
+    onFeedback?: (value: FeedbackValue) => void;
+    children?: ReactNode;
+}
+declare const Root$3: react.ForwardRefExoticComponent<FeedbackBarRootProps & react.RefAttributes<HTMLDivElement>>;
+interface FeedbackBarThumbsUpProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const ThumbsUp: react.ForwardRefExoticComponent<FeedbackBarThumbsUpProps & react.RefAttributes<HTMLButtonElement>>;
+interface FeedbackBarThumbsDownProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const ThumbsDown: react.ForwardRefExoticComponent<FeedbackBarThumbsDownProps & react.RefAttributes<HTMLButtonElement>>;
+interface FeedbackBarCopyProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Text to copy. If not provided, copies the closest [data-arclo-copyable] ancestor's textContent */
+    text?: string;
+}
+declare const Copy: react.ForwardRefExoticComponent<FeedbackBarCopyProps & react.RefAttributes<HTMLButtonElement>>;
+interface FeedbackBarRegenerateProps extends HTMLAttributes<HTMLButtonElement> {
+    onRegenerate?: () => void;
+}
+declare const Regenerate: react.ForwardRefExoticComponent<FeedbackBarRegenerateProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare const index$3_Copy: typeof Copy;
+type index$3_FeedbackBarCopyProps = FeedbackBarCopyProps;
+type index$3_FeedbackBarRegenerateProps = FeedbackBarRegenerateProps;
+type index$3_FeedbackBarRootProps = FeedbackBarRootProps;
+type index$3_FeedbackBarThumbsDownProps = FeedbackBarThumbsDownProps;
+type index$3_FeedbackBarThumbsUpProps = FeedbackBarThumbsUpProps;
+declare const index$3_Regenerate: typeof Regenerate;
+declare const index$3_ThumbsDown: typeof ThumbsDown;
+declare const index$3_ThumbsUp: typeof ThumbsUp;
+declare namespace index$3 {
+  export { index$3_Copy as Copy, type index$3_FeedbackBarCopyProps as FeedbackBarCopyProps, type index$3_FeedbackBarRegenerateProps as FeedbackBarRegenerateProps, type index$3_FeedbackBarRootProps as FeedbackBarRootProps, type index$3_FeedbackBarThumbsDownProps as FeedbackBarThumbsDownProps, type index$3_FeedbackBarThumbsUpProps as FeedbackBarThumbsUpProps, index$3_Regenerate as Regenerate, Root$3 as Root, index$3_ThumbsDown as ThumbsDown, index$3_ThumbsUp as ThumbsUp };
+}
+
+type ThinkingState = "thinking" | "done" | "error";
+interface ThinkingBlockRootProps extends HTMLAttributes<HTMLDivElement> {
+    /** Current thinking state */
+    state?: ThinkingState;
+    /** Whether the block starts expanded. Default: true */
+    defaultOpen?: boolean;
+    /** Auto-collapse when state changes to "done". Default: true */
+    collapseOnDone?: boolean;
+    /** Thinking duration in seconds (shown in header) */
+    duration?: number | null;
+    children?: ReactNode;
+}
+declare const Root$2: react.ForwardRefExoticComponent<ThinkingBlockRootProps & react.RefAttributes<HTMLDivElement>>;
+interface ThinkingBlockTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+    /** Custom label. Default: auto from state */
+    label?: string;
+}
+declare const Trigger: react.ForwardRefExoticComponent<ThinkingBlockTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+interface ThinkingBlockContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Content: react.ForwardRefExoticComponent<ThinkingBlockContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const index$2_Content: typeof Content;
+type index$2_ThinkingBlockContentProps = ThinkingBlockContentProps;
+type index$2_ThinkingBlockRootProps = ThinkingBlockRootProps;
+type index$2_ThinkingBlockTriggerProps = ThinkingBlockTriggerProps;
+type index$2_ThinkingState = ThinkingState;
+declare const index$2_Trigger: typeof Trigger;
+declare namespace index$2 {
+  export { index$2_Content as Content, Root$2 as Root, type index$2_ThinkingBlockContentProps as ThinkingBlockContentProps, type index$2_ThinkingBlockRootProps as ThinkingBlockRootProps, type index$2_ThinkingBlockTriggerProps as ThinkingBlockTriggerProps, type index$2_ThinkingState as ThinkingState, index$2_Trigger as Trigger };
+}
+
+type ToolCallStatus = "pending" | "running" | "success" | "error";
+interface ToolCallRootProps extends HTMLAttributes<HTMLDivElement> {
+    /** Name of the tool being called */
+    toolName: string;
+    /** Current status */
+    status?: ToolCallStatus;
+    /** Whether result is expanded by default. Default: false */
+    defaultOpen?: boolean;
+    children?: ReactNode;
+}
+declare const Root$1: react.ForwardRefExoticComponent<ToolCallRootProps & react.RefAttributes<HTMLDivElement>>;
+interface ToolCallHeaderProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare const Header: react.ForwardRefExoticComponent<ToolCallHeaderProps & react.RefAttributes<HTMLButtonElement>>;
+interface ToolCallInputProps extends HTMLAttributes<HTMLDivElement> {
+    /** Label for the input section. Default: "Input" */
+    label?: string;
+}
+declare const Input: react.ForwardRefExoticComponent<ToolCallInputProps & react.RefAttributes<HTMLDivElement>>;
+interface ToolCallOutputProps extends HTMLAttributes<HTMLDivElement> {
+    /** Label for the output section. Default: "Output" */
+    label?: string;
+}
+declare const Output: react.ForwardRefExoticComponent<ToolCallOutputProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const index$1_Header: typeof Header;
+declare const index$1_Input: typeof Input;
+declare const index$1_Output: typeof Output;
+type index$1_ToolCallHeaderProps = ToolCallHeaderProps;
+type index$1_ToolCallInputProps = ToolCallInputProps;
+type index$1_ToolCallOutputProps = ToolCallOutputProps;
+type index$1_ToolCallRootProps = ToolCallRootProps;
+type index$1_ToolCallStatus = ToolCallStatus;
+declare namespace index$1 {
+  export { index$1_Header as Header, index$1_Input as Input, index$1_Output as Output, Root$1 as Root, type index$1_ToolCallHeaderProps as ToolCallHeaderProps, type index$1_ToolCallInputProps as ToolCallInputProps, type index$1_ToolCallOutputProps as ToolCallOutputProps, type index$1_ToolCallRootProps as ToolCallRootProps, type index$1_ToolCallStatus as ToolCallStatus };
+}
+
+type MessageRole = "user" | "assistant" | "system";
+interface ChatThreadRootProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const Root: react.ForwardRefExoticComponent<ChatThreadRootProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatThreadMessagesProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const Messages: react.ForwardRefExoticComponent<ChatThreadMessagesProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatThreadMessageProps extends HTMLAttributes<HTMLDivElement> {
+    /** The role determines visual styling and alignment */
+    role: MessageRole;
+    /** Optional avatar element (icon, image, etc.) */
+    avatar?: ReactNode;
+    /** Display name for the message author */
+    name?: string;
+    /** Timestamp string to display */
+    timestamp?: string;
+    children: ReactNode;
+}
+declare const Message: react.ForwardRefExoticComponent<ChatThreadMessageProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatThreadUserMessageProps extends Omit<ChatThreadMessageProps, "role"> {
+}
+declare const UserMessage: react.ForwardRefExoticComponent<ChatThreadUserMessageProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatThreadAssistantMessageProps extends Omit<ChatThreadMessageProps, "role"> {
+}
+declare const AssistantMessage: react.ForwardRefExoticComponent<ChatThreadAssistantMessageProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatThreadSystemMessageProps extends Omit<ChatThreadMessageProps, "role"> {
+}
+declare const SystemMessage: react.ForwardRefExoticComponent<ChatThreadSystemMessageProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatThreadScrollAnchorProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const ScrollAnchor: react.ForwardRefExoticComponent<ChatThreadScrollAnchorProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const index_AssistantMessage: typeof AssistantMessage;
+type index_ChatThreadAssistantMessageProps = ChatThreadAssistantMessageProps;
+type index_ChatThreadMessageProps = ChatThreadMessageProps;
+type index_ChatThreadMessagesProps = ChatThreadMessagesProps;
+type index_ChatThreadRootProps = ChatThreadRootProps;
+type index_ChatThreadScrollAnchorProps = ChatThreadScrollAnchorProps;
+type index_ChatThreadSystemMessageProps = ChatThreadSystemMessageProps;
+type index_ChatThreadUserMessageProps = ChatThreadUserMessageProps;
+declare const index_Message: typeof Message;
+type index_MessageRole = MessageRole;
+declare const index_Messages: typeof Messages;
+declare const index_Root: typeof Root;
+declare const index_ScrollAnchor: typeof ScrollAnchor;
+declare const index_SystemMessage: typeof SystemMessage;
+declare const index_UserMessage: typeof UserMessage;
+declare namespace index {
+  export { index_AssistantMessage as AssistantMessage, type index_ChatThreadAssistantMessageProps as ChatThreadAssistantMessageProps, type index_ChatThreadMessageProps as ChatThreadMessageProps, type index_ChatThreadMessagesProps as ChatThreadMessagesProps, type index_ChatThreadRootProps as ChatThreadRootProps, type index_ChatThreadScrollAnchorProps as ChatThreadScrollAnchorProps, type index_ChatThreadSystemMessageProps as ChatThreadSystemMessageProps, type index_ChatThreadUserMessageProps as ChatThreadUserMessageProps, index_Message as Message, type index_MessageRole as MessageRole, index_Messages as Messages, index_Root as Root, index_ScrollAnchor as ScrollAnchor, index_SystemMessage as SystemMessage, index_UserMessage as UserMessage };
+}
+
+interface ConfidenceBadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Confidence level */
+    level: ConfidenceLevel;
+    /** Custom label override */
+    label?: string;
+    /** Show as a small dot indicator instead of full badge */
+    variant?: "badge" | "dot" | "inline";
+}
+declare const ConfidenceBadge: react.ForwardRefExoticComponent<ConfidenceBadgeProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface CitationInlineProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Citation index number */
+    index: number;
+    /** Source URL */
+    href?: string;
+    /** Source title */
+    sourceTitle?: string;
+    /** Preview content shown on hover */
+    preview?: ReactNode;
+    /** Visual variant */
+    variant?: "superscript" | "bracket" | "pill";
+}
+declare const CitationInline: react.ForwardRefExoticComponent<CitationInlineProps & react.RefAttributes<HTMLSpanElement>>;
+interface CitationGroupProps extends HTMLAttributes<HTMLSpanElement> {
+    children: ReactNode;
+}
+declare const CitationGroup: react.ForwardRefExoticComponent<CitationGroupProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface RefusalCardProps extends HTMLAttributes<HTMLDivElement> {
+    /** Why the request was refused */
+    reason?: string;
+    /** The type of refusal */
+    type?: "safety" | "capability" | "policy" | "context";
+    /** Suggested alternative prompts */
+    suggestions?: string[];
+    /** Called when user clicks a suggestion */
+    onSuggestionClick?: (suggestion: string) => void;
+    /** Custom icon */
+    icon?: ReactNode;
+}
+declare const RefusalCard: react.ForwardRefExoticComponent<RefusalCardProps & react.RefAttributes<HTMLDivElement>>;
+
+interface MarkdownRendererProps extends HTMLAttributes<HTMLDivElement> {
+    /** Markdown text to render */
+    content: string;
+    /** Custom code block renderer */
+    renderCode?: (code: string, lang?: string) => ReactNode;
+}
+declare const MarkdownRenderer: react.ForwardRefExoticComponent<MarkdownRendererProps & react.RefAttributes<HTMLDivElement>>;
+
+type StatusIndicatorState = "idle" | "thinking" | "streaming" | "tool-calling" | "error";
+interface StatusIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Current state */
+    state?: StatusIndicatorState;
+    /** Custom label. Default: auto from state */
+    label?: string;
+    /** Custom icon element */
+    icon?: ReactNode;
+    /** Color scheme. Default: auto from state */
+    color?: "purple" | "amber" | "blue" | "red" | "gray";
+    /** Animation style. "pulse" = fade in/out, "sweep" = light moves letter by letter. Default: "sweep" */
+    animation?: "pulse" | "sweep";
+}
+declare const StatusIndicator: react.ForwardRefExoticComponent<StatusIndicatorProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface TokenUsageProps extends HTMLAttributes<HTMLDivElement> {
+    /** Number of input tokens used */
+    inputTokens: number;
+    /** Number of output tokens used */
+    outputTokens: number;
+    /** Maximum token budget */
+    maxTokens: number;
+    /** Cost in dollars (optional) */
+    cost?: number;
+}
+declare const TokenUsage: react.ForwardRefExoticComponent<TokenUsageProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ModelOption {
+    /** Unique model identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Optional description shown in dropdown */
+    description?: string;
+    /** Optional badge text (e.g. "New", "Fast") */
+    badge?: string;
+}
+interface ModelSelectorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Available models */
+    models: ModelOption[];
+    /** Currently selected model id */
+    value: string;
+    /** Called when user selects a model */
+    onChange: (modelId: string) => void;
+}
+declare const ModelSelector: react.ForwardRefExoticComponent<ModelSelectorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SourceCardProps extends HTMLAttributes<HTMLDivElement> {
+    /** Source title */
+    title: string;
+    /** Source URL (optional) */
+    url?: string;
+    /** Preview text content */
+    content: string;
+    /** Relevance score from 0 to 1 */
+    relevance: number;
+    /** Display variant */
+    variant?: "compact" | "full";
+}
+declare const SourceCard: react.ForwardRefExoticComponent<SourceCardProps & react.RefAttributes<HTMLDivElement>>;
+
+type FileAttachmentType = "image" | "pdf" | "code" | "text" | "csv" | "other";
+interface FileAttachmentProps extends HTMLAttributes<HTMLDivElement> {
+    /** File name */
+    name: string;
+    /** Human-readable file size, e.g. "2.4 MB" */
+    size?: string;
+    /** File type — determines the icon */
+    type?: FileAttachmentType;
+    /** Image URL for thumbnail preview (card variant) */
+    preview?: string;
+    /** Upload progress 0-100 — shows progress bar when present */
+    progress?: number;
+    /** Called when remove button is clicked */
+    onRemove?: () => void;
+    /** Display variant */
+    variant?: "chip" | "card";
+}
+declare const FileAttachment: react.ForwardRefExoticComponent<FileAttachmentProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CodeBlockProps extends HTMLAttributes<HTMLDivElement> {
+    /** The code string to display */
+    code: string;
+    /** Language label shown in the header */
+    language?: string;
+    /** Show line numbers. Default: false */
+    showLineNumbers?: boolean;
+    /** Max height before scroll. Default: "400px" */
+    maxHeight?: string;
+    /** Called when the copy button is clicked */
+    onCopy?: () => void;
+}
+declare const CodeBlock: react.ForwardRefExoticComponent<CodeBlockProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ConversationBranchProps extends HTMLAttributes<HTMLDivElement> {
+    /** Current branch index (1-indexed) */
+    current: number;
+    /** Total number of branches */
+    total: number;
+    /** Called when navigating to the previous branch */
+    onPrevious?: () => void;
+    /** Called when navigating to the next branch */
+    onNext?: () => void;
+}
+declare const ConversationBranch: react.ForwardRefExoticComponent<ConversationBranchProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TopicCardProps extends Omit<HTMLAttributes<HTMLButtonElement>, "onSelect"> {
+    /** Card title / prompt summary */
+    title: string;
+    /** Optional description or subtitle (hidden in compact mode) */
+    description?: string;
+    /** Optional icon element */
+    icon?: ReactNode;
+    /** Called when the card is clicked */
+    onSelect?: (title: string) => void;
+    /** Visual variant — set automatically by SuggestTopics, but can be overridden */
+    variant?: "card" | "compact";
+}
+declare const TopicCard: react.ForwardRefExoticComponent<TopicCardProps & react.RefAttributes<HTMLButtonElement>>;
+interface SuggestTopicsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Layout variant. "grid" for cards, "compact" for horizontal scroll pills. Default: "grid" */
+    variant?: "grid" | "compact";
+    /** Number of columns (grid variant only). Default: 2 */
+    columns?: 1 | 2 | 3;
+    children: ReactNode;
+}
+declare const SuggestTopics: react.ForwardRefExoticComponent<SuggestTopicsProps & react.RefAttributes<HTMLDivElement>>;
+
+export { index as ChatThread, type ChatThreadMessageProps, type ChatThreadRootProps, type ChunkSize, CitationGroup, type CitationGroupProps, CitationInline, type CitationInlineProps, CodeBlock, type CodeBlockProps, ConfidenceBadge, type ConfidenceBadgeProps, type ConfidenceLevel, ConversationBranch, type ConversationBranchProps, index$3 as FeedbackBar, FileAttachment, type FileAttachmentProps, type FileAttachmentType, MarkdownRenderer, type MarkdownRendererProps, type MessageRole, type ModelOption, ModelSelector, type ModelSelectorProps, index$4 as PromptBox, RefusalCard, type RefusalCardProps, SourceCard, type SourceCardProps, StatusIndicator, type StatusIndicatorProps, type StatusIndicatorState, type StreamingState, index$5 as StreamingText, SuggestTopics, type SuggestTopicsProps, index$2 as ThinkingBlock, type ThinkingBlockRootProps, type ThinkingState, TokenUsage, type TokenUsageProps, index$1 as ToolCall, type ToolCallRootProps, type ToolCallStatus, TopicCard, type TopicCardProps, type UseStreamingTextOptions, type UseStreamingTextReturn, useStreamingText };