import type { ToolCall } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
import type { SubAgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/subagent_pb";
/** Props for {@link ToolCallGroup}. */
export interface ToolCallGroupProps {
    /** Tool calls in this group, ordered by invocation time. */
    readonly toolCalls: readonly ToolCall[];
    /**
     * Sub-agent executions from the parent `AgentExecutionStatus`.
     * When provided, tool calls whose `id` matches a
     * `SubAgentExecution.id` are rendered with a nested sub-agent
     * thread instead of a standard detail panel.
     */
    readonly subAgentExecutions?: readonly SubAgentExecution[];
    /**
     * Custom label formatter for a folded run chip (e.g. a run of reads).
     * Receives the run's tool calls and returns the chip's collapsed label.
     *
     * NOTE: the unit of summary moved from the *turn* to the *run*. This used to
     * label the whole turn ("Ran 3 tools"); since the turn no longer collapses,
     * it now labels each {@link ToolRunGroup} chip. The signature is unchanged.
     */
    readonly formatSummary?: (toolCalls: readonly ToolCall[]) => string;
    /**
     * @deprecated No-op. The turn no longer collapses as a unit — rows persist
     * and only repetitive runs fold (see {@link ToolRunGroup}). Kept for
     * back-compat so existing call sites keep type-checking.
     */
    readonly defaultExpanded?: boolean;
    /** Additional CSS class names for the root container. */
    readonly className?: string;
}
/**
 * Shallow comparison for `ToolCallGroupProps`.
 *
 * The `toolCalls` array may be a newly allocated subset (e.g.
 * `buildThreadItems` filters out `task` calls). Structural sharing
 * (T04) keeps individual `ToolCall` objects stable, so we compare
 * array elements by reference rather than the array itself.
 *
 * @internal Exported for testing — not part of the public API.
 */
export declare function toolCallGroupPropsEqual(prev: Readonly<ToolCallGroupProps>, next: Readonly<ToolCallGroupProps>): boolean;
/**
 * Renders one AI turn's tool activity as a **persistent-row timeline** rather
 * than a collapsible "Ran N tools" box. Each call stays visible after it
 * settles, so completed work is never hidden behind a pill — the thread reads
 * like a virtual human at work.
 *
 * The turn is segmented by {@link segmentToolCalls}:
 * - high-signal calls (edits, shell, MCP, sub-agents, …) render as persistent
 *   {@link ToolCallItem} rows; a content-bearing call shows its body inline
 *   (no card chevron), bounded by a single in-place reveal;
 * - runs of consecutive low-signal same-category calls (read / list / search)
 *   fold into one collapsible {@link ToolRunGroup} chip — the *only* collapse,
 *   because that is the only genuine noise.
 *
 * The rows are clustered under a light left rail (the neutral counterpart to
 * {@link SubAgentSection}'s primary-tinted rail for delegated work), keeping a
 * turn's tools visually associated with their AI message without a tab that
 * hides things.
 *
 * Wrapped in `React.memo` with a custom comparator that checks `toolCalls`
 * elements by reference (structural sharing keeps individual `ToolCall` objects
 * stable for unchanged calls), so settled rows skip re-renders while siblings
 * stream (DD-009/010).
 *
 * @example
 * ```tsx
 * <ToolCallGroup toolCalls={message.toolCalls} />
 * ```
 */
export declare const ToolCallGroup: import("react").NamedExoticComponent<ToolCallGroupProps>;
//# sourceMappingURL=ToolCallGroup.d.ts.map