import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';

type ChatRole = 'user' | 'assistant' | 'system' | 'error';
interface ChatMessageProps {
    role: ChatRole;
    name?: string;
    timestamp?: Date;
    /**
     * Legacy boolean — shows a dots typing indicator.
     * Auto-set to true when `stream` or `streamText` is provided.
     */
    streaming?: boolean;
    collapsed?: boolean;
    children?: ReactNode;
    /**
     * Animate a pre-buffered string in character-by-character.
     * Uses StreamingText internally with `animate={true}`.
     */
    streamText?: string;
    /**
     * Consume a real AsyncIterable<string> (e.g. from an LLM SDK).
     * Chunks are appended live as they arrive.
     */
    stream?: AsyncIterable<string>;
    /** Speed in ms/char for `streamText` animation. Default: 18 */
    streamSpeed?: number;
    /** Called when streaming or animation completes. */
    onStreamComplete?: (fullText: string) => void;
    /**
     * Show prefix + content inline instead of a header row above the content.
     * Default: false
     */
    inline?: boolean;
    /**
     * Override the inline prefix character.
     * Defaults per role: user → `›`, assistant → `◆`, system → `·`, error → `✗`
     */
    prefix?: string;
    /**
     * Show a full-width `─` separator line above the message.
     * Default: true
     */
    showSeparator?: boolean;
    /**
     * Clamp plain-string children to this many lines, appending `… (+N more)`.
     */
    maxLines?: number;
}
declare function ChatMessage({ role, name, timestamp, streaming: streamingProp, collapsed: initialCollapsed, children, streamText, stream, streamSpeed, onStreamComplete, inline, prefix, showSeparator, maxLines, }: ChatMessageProps): react_jsx_runtime.JSX.Element;

interface ChatThreadProps {
    maxHeight?: number;
    autoScroll?: boolean;
    children?: ReactNode;
}
declare function ChatThread({ maxHeight, autoScroll, children }: ChatThreadProps): react_jsx_runtime.JSX.Element;

type ToolCallStatus = 'pending' | 'running' | 'success' | 'error';
interface ToolCallProps {
    name: string;
    args?: Record<string, unknown>;
    status: ToolCallStatus;
    result?: unknown;
    duration?: number;
    collapsible?: boolean;
    defaultCollapsed?: boolean;
}
declare function ToolCall({ name, args, status, result, duration, collapsible, defaultCollapsed, }: ToolCallProps): react_jsx_runtime.JSX.Element;

interface ThinkingBlockProps {
    content: string;
    streaming?: boolean;
    defaultCollapsed?: boolean;
    label?: string;
    tokenCount?: number;
    duration?: number;
}
declare function ThinkingBlock({ content, streaming, defaultCollapsed, label, tokenCount, duration, }: ThinkingBlockProps): react_jsx_runtime.JSX.Element;

type RiskLevel = 'low' | 'medium' | 'high';
interface ToolApprovalProps {
    name: string;
    description?: string;
    args?: Record<string, unknown>;
    risk?: RiskLevel;
    onApprove: () => void;
    onDeny: () => void;
    onAlwaysAllow?: () => void;
    /** Auto-deny timeout in seconds */
    timeout?: number;
}
declare function ToolApproval({ name, description, args, risk, onApprove, onDeny, onAlwaysAllow, timeout, }: ToolApprovalProps): react_jsx_runtime.JSX.Element;

interface TokenUsageProps {
    prompt: number;
    completion: number;
    model?: string;
    showCost?: boolean;
}
declare function TokenUsage({ prompt, completion, model, showCost }: TokenUsageProps): react_jsx_runtime.JSX.Element;
interface ContextMeterProps {
    used: number;
    limit: number;
    label?: string;
    showPercent?: boolean;
    warnAt?: number;
    criticalAt?: number;
    width?: number;
}
declare function ContextMeter({ used, limit, label, showPercent, warnAt, criticalAt, width, }: ContextMeterProps): react_jsx_runtime.JSX.Element;

interface ModelOption {
    id: string;
    name: string;
    provider: string;
    context?: number;
}
interface ModelSelectorProps {
    models: ModelOption[];
    selected: string;
    onSelect: (id: string) => void;
    showContext?: boolean;
    showProvider?: boolean;
    groupByProvider?: boolean;
}
declare function ModelSelector({ models, selected, onSelect, showContext, showProvider, groupByProvider, }: ModelSelectorProps): react_jsx_runtime.JSX.Element;

type FileChangeType = 'modify' | 'create' | 'delete';
interface FileChangeItem {
    path: string;
    type: FileChangeType;
    diff?: string;
    content?: string;
}
interface FileChangeProps {
    changes: FileChangeItem[];
    onAccept?: (path: string) => void;
    onReject?: (path: string) => void;
    onAcceptAll?: () => void;
}
declare function FileChange({ changes, onAccept, onReject, onAcceptAll }: FileChangeProps): react_jsx_runtime.JSX.Element;

interface StreamOutputProps {
    /** Pre-buffered string to animate character-by-character */
    text?: string;
    /** Real AsyncIterable<string> from an LLM SDK */
    stream?: AsyncIterable<string>;
    /** ms/char for text animation. Default: 18 */
    speed?: number;
    /** Show blinking cursor. Default: true */
    cursor?: boolean;
    /** Label shown above the output (e.g. "Response"). Optional. */
    label?: string;
    /** Called when animation/streaming completes */
    onComplete?: (fullText: string) => void;
    /** Color for the label. Default: theme.colors.primary */
    labelColor?: string;
}
declare function StreamOutput({ text, stream, speed, cursor, label, onComplete, labelColor, }: StreamOutputProps): react_jsx_runtime.JSX.Element;

interface ConversationHistoryProps {
    /** Number of visible rows. Default: 20 */
    maxHeight?: number;
    children?: ReactNode;
    /** Show scroll position indicator. Default: true */
    showScrollHint?: boolean;
    /** Whether keyboard navigation is active. Default: true */
    isActive?: boolean;
}
declare function ConversationHistory({ maxHeight, children, showScrollHint, isActive, }: ConversationHistoryProps): react_jsx_runtime.JSX.Element;

interface ErrorRetryProps {
    error: Error | string;
    onRetry?: () => void;
    onDismiss?: () => void;
    /** Number of prior retry attempts. Shows "Retry attempt N" when > 0 */
    retryCount?: number;
    /** Max retries before disabling the retry action. Default: 3 */
    maxRetries?: number;
    /** Whether this component captures input. Default: true */
    isActive?: boolean;
}
declare function ErrorRetry({ error, onRetry, onDismiss, retryCount, maxRetries, isActive, }: ErrorRetryProps): react_jsx_runtime.JSX.Element;

export { ChatMessage, type ChatMessageProps, type ChatRole, ChatThread, type ChatThreadProps, ContextMeter, type ContextMeterProps, ConversationHistory, type ConversationHistoryProps, ErrorRetry, type ErrorRetryProps, FileChange, type FileChangeItem, type FileChangeProps, type FileChangeType, type ModelOption, ModelSelector, type ModelSelectorProps, type RiskLevel, StreamOutput, type StreamOutputProps, ThinkingBlock, type ThinkingBlockProps, TokenUsage, type TokenUsageProps, ToolApproval, type ToolApprovalProps, ToolCall, type ToolCallProps, type ToolCallStatus };