import * as React from 'react';
import { ReactNode } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { R as Run } from './run-PfLmDAox.js';
import { S as SessionPart, a as ToolPart, R as ReasoningPart } from './parts-dj7AcUg0.js';
import { AgentBranding } from './types.js';
import { C as CustomToolRenderer } from './tool-display-z4JcDmMQ.js';
export { F as FeedSegment, T as ToolCallData, a as ToolCallFeed, b as ToolCallFeedProps, c as ToolCallStatus, d as ToolCallType, p as parseToolEvent } from './tool-call-feed-D9iofJgW.js';
import './message-BHWbxBtT.js';

interface RunGroupProps {
    run: Run;
    partMap: Record<string, SessionPart[]>;
    collapsed: boolean;
    onToggle: () => void;
    branding?: AgentBranding;
    renderToolDetail?: CustomToolRenderer;
    headerActions?: ReactNode;
    renderToolActions?: (part: ToolPart, options: {
        run: Run;
        messageId: string;
        partIndex: number;
    }) => ReactNode;
}
/**
 * Collapsible container for a consecutive group of assistant messages (a "run").
 * Shows a summary header with stats and renders tool/thinking/text parts.
 */
declare const RunGroup: React.MemoExoticComponent<({ run, partMap, collapsed, onToggle, branding, renderToolDetail, headerActions, renderToolActions, }: RunGroupProps) => react_jsx_runtime.JSX.Element | null>;

type RunRowStatus = "running" | "success" | "error" | "idle";
/**
 * Trailing status indicator shared by every run row: a spinner while running,
 * a green/red dot on terminal states, nothing when idle. Status is shown here
 * — it never replaces the row's semantic lead icon.
 */
declare function RunRowStatusDot({ status }: {
    status: RunRowStatus;
}): react_jsx_runtime.JSX.Element | null;
interface RunRowShellProps {
    /** Semantic lead glyph — always visible; never replaced by status. */
    icon: ReactNode;
    /** Row title. A string in the common case; a node when the title carries its
     *  own treatment (e.g. an active-state shimmer sweep) — it renders inline in
     *  the shell's title slot either way. */
    title: ReactNode;
    /** Secondary inline text (tool path/command, or a reasoning preview). */
    description?: string;
    /** Render the description in mono (tools) vs prose (reasoning). */
    descriptionMono?: boolean;
    status?: RunRowStatus;
    /** Live-ticks a duration while running. */
    startTime?: number;
    /** Static duration shown once the row is no longer running. */
    durationMs?: number;
    /** Radius shaping when rows are stacked into a group. */
    groupPosition?: "single" | "first" | "middle" | "last";
    /** Message shown below the header while collapsed (tool errors). */
    collapsedError?: string;
    actions?: ReactNode;
    /** Controlled open state. Omit for internal (uncontrolled) state. */
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    defaultOpen?: boolean;
    className?: string;
    contentClassName?: string;
    /** Expanded body. When absent the row is not expandable. */
    children?: ReactNode;
}
/**
 * Shared shell for the agent activity rows (reasoning + tool). Owns the
 * bordered container, the lead icon badge, title/description, the trailing
 * meta cluster (duration + status + chevron) and the collapsible body, so
 * both row kinds read as one family instead of two bespoke layouts.
 */
declare function RunRowShell({ icon, title, description, descriptionMono, status, startTime, durationMs, groupPosition, collapsedError, actions, open: openProp, onOpenChange, defaultOpen, className, contentClassName, children, }: RunRowShellProps): react_jsx_runtime.JSX.Element;

interface InlineToolItemProps {
    part: ToolPart;
    renderToolDetail?: CustomToolRenderer;
    groupPosition?: "single" | "first" | "middle" | "last";
    className?: string;
    contentClassName?: string;
    actions?: ReactNode;
    /** Override the derived title (default: from `getToolDisplayMetadata`). */
    title?: string;
    /** Override the derived inline description. */
    description?: string;
}
/**
 * Compact single-line tool call display. Shows a category icon, title,
 * description, duration and status, and expands on click to show
 * ExpandedToolDetail. Rendered through the shared RunRowShell so it stays
 * consistent with the reasoning row.
 */
declare const InlineToolItem: React.MemoExoticComponent<({ part, renderToolDetail, groupPosition, className, contentClassName, actions, title: titleOverride, description: descriptionOverride, }: InlineToolItemProps) => react_jsx_runtime.JSX.Element>;

interface InlineThinkingItemProps {
    part: ReasoningPart;
    defaultOpen?: boolean;
    autoCollapse?: boolean;
    className?: string;
    contentClassName?: string;
}
declare const InlineThinkingItem: React.MemoExoticComponent<({ part, defaultOpen, autoCollapse, className, contentClassName, }: InlineThinkingItemProps) => react_jsx_runtime.JSX.Element>;

interface ExpandedToolDetailProps {
    part: ToolPart;
}
/**
 * Renders full tool details when a tool item is expanded.
 * Dispatches to specialised previews (CommandPreview, WriteFilePreview)
 * or falls back to a generic input/output code view.
 */
declare const ExpandedToolDetail: React.MemoExoticComponent<({ part }: ExpandedToolDetailProps) => react_jsx_runtime.JSX.Element>;

declare function LiveDuration({ startTime }: {
    startTime: number;
}): react_jsx_runtime.JSX.Element;

export { ExpandedToolDetail, type ExpandedToolDetailProps, InlineThinkingItem, type InlineThinkingItemProps, InlineToolItem, type InlineToolItemProps, LiveDuration, RunGroup, type RunGroupProps, RunRowShell, type RunRowShellProps, type RunRowStatus, RunRowStatusDot };