interface TuiTraceNode {
    id: string;
    name: string;
    type?: string;
    status?: string;
    durationMs?: number;
    depth: number;
    parentId?: string;
    error?: string;
    metadata?: Record<string, unknown>;
    children: TuiTraceNode[];
}
interface TuiTraceModel {
    runId: string;
    name?: string;
    status?: string;
    durationMs?: number;
    nodes: TuiTraceNode[];
    flatNodes: TuiTraceNode[];
}

/**
 * Discriminator for what kind of work a {@link Step} represents.
 * `"decision"` captures agent branching/choices; other values cover runs, LLM calls, tools, and user-defined steps.
 */
type StepType = "run" | "llm" | "tool" | "decision" | "logic" | "state" | "custom";
/** Structured error attached to a run or step when status is `"error"`. */
interface ErrorInfo {
    message: string;
    stack?: string;
}
/**
 * Optional token counts for a step (e.g. LLM usage).
 * Reserved for future roadmap; MVP does not compute or persist token usage.
 */
interface TokenMetadata {
    input?: number;
    output?: number;
    total?: number;
    /** Cache-read tokens (informational; never added to total). */
    cached?: number;
    /** Cache-write / cache-creation tokens (informational). */
    cacheWrite?: number;
    /** Reasoning / thinking tokens when reported separately. */
    reasoning?: number;
}
/** Arbitrary structured fields for a step; safe extensions use string keys. */
interface StepMetadata {
    model?: string;
    toolName?: string;
    tokens?: TokenMetadata;
    retryCount?: number;
    [key: string]: unknown;
}
/** Version of the JSONL trace line schema consumed by AgentInspect tooling. */
type TraceSchemaVersion = "0.1";
/** Fields shared by every persisted trace event line. */
interface TraceEventBase {
    schemaVersion: TraceSchemaVersion;
    event: string;
    timestamp: number;
}
/** Emitted when a run begins. */
interface RunStartedEvent extends TraceEventBase {
    event: "run_started";
    runId: string;
    name: string;
    startTime: number;
    metadata?: Record<string, unknown>;
}
/** Emitted when a run finishes successfully or with an error. */
interface RunCompletedEvent extends TraceEventBase {
    event: "run_completed";
    runId: string;
    status: "success" | "error";
    endTime: number;
    durationMs: number;
    error?: ErrorInfo;
}
/** Emitted when a step begins (including nested steps under `parentId`). */
interface StepStartedEvent extends TraceEventBase {
    event: "step_started";
    runId: string;
    stepId: string;
    parentId?: string;
    name: string;
    type: StepType;
    startTime: number;
    metadata?: StepMetadata;
}
/**
 * Emitted when a step finishes (success or failure).
 * Failures use `status: "error"` and optional {@link ErrorInfo}; there is no separate `step_failed` event in MVP.
 */
interface StepCompletedEvent extends TraceEventBase {
    event: "step_completed";
    runId: string;
    stepId: string;
    status: "success" | "error";
    endTime: number;
    durationMs: number;
    error?: ErrorInfo;
}
/** Emitted when an external-world outcome is observed (v4.4+). */
interface OutcomeObservedEvent extends TraceEventBase {
    event: "outcome_observed";
    runId: string;
    outcomeId: string;
    parentId?: string;
    name: string;
    expectation: string;
    status: "passed" | "failed" | "unknown" | "skipped";
    method?: "dom" | "accessibility" | "snapshot" | "network" | "storage" | "filesystem" | "database" | "queue" | "custom";
    actual?: unknown;
    evidence?: unknown;
    observedAt: number;
}
/** Discriminated union of all MVP trace events written as JSONL lines. */
type TraceEvent = RunStartedEvent | RunCompletedEvent | StepStartedEvent | StepCompletedEvent | OutcomeObservedEvent;

/**
 * Build a navigable tree model from v0.1 JSONL trace events.
 * Does not mutate the input array or event objects.
 */
declare function buildTuiTraceModel(events: TraceEvent[]): TuiTraceModel;
/** Total step count in tree (for default expand policy). Exported for tests. */
declare function countTreeSteps(roots: TuiTraceNode[]): number;

interface LoadTraceForTuiOptions {
    runId: string;
    dir?: string;
}
/**
 * Load JSONL trace events and build a TUI model. Does not write or mutate trace files.
 */
declare function loadTraceForTui(options: LoadTraceForTuiOptions): Promise<TuiTraceModel>;

type TuiAction = "up" | "down" | "expand" | "collapse" | "toggle" | "details" | "help" | "quit" | "unknown";
/** Map Ink `useInput` args to a semantic action. Pure helper for tests. */
declare function mapInputToAction(input: string, key?: Partial<{
    name: string;
    ctrl: boolean;
    meta: boolean;
    shift: boolean;
    return: boolean;
    escape: boolean;
    upArrow: boolean;
    downArrow: boolean;
    leftArrow: boolean;
    rightArrow: boolean;
}>): TuiAction;

interface TraceViewerAppProps {
    model: TuiTraceModel;
    onExit?: () => void;
}

/** Small traces: expand all branches. Larger traces: only root rows expanded (show first nesting level). */
declare function initialExpandedSet(model: TuiTraceModel): Set<string>;

interface RunTraceViewerOptions {
    runId: string;
    dir?: string;
}
declare function runTraceViewer(options: RunTraceViewerOptions): Promise<void>;

export { type LoadTraceForTuiOptions, type RunTraceViewerOptions, type TraceViewerAppProps, type TuiAction, type TuiTraceModel, type TuiTraceNode, buildTuiTraceModel, countTreeSteps, initialExpandedSet, loadTraceForTui, mapInputToAction, runTraceViewer };