import type { Element } from "../../tui/elements.js";
import type { KeyEvent } from "../../tui/input/types.js";
import type { TreeNode } from "../types.js";
import type { ViewAction, Viewport } from "../views/view.js";
import type { Screen } from "./screen.js";
export declare class TranscriptScreen implements Screen {
    private roots;
    private traceId;
    readonly screenName: "transcript";
    private blocks;
    /** The trace's story rows, for finding the row a block stands for. */
    private story;
    /** The blocks not hidden by a folded thread group. */
    private visible;
    /** Folded thread groups, by block id. A sub-agent's group folds on
     *  first sight when complete, by the trace's rule; a top-level thread is
     *  the conversation itself and never folds by itself. */
    private folded;
    private foldDefaultsApplied;
    /** Whether the trace has thread rows; without them the outline starts
     *  at the left. */
    private hasGroups;
    private cursor;
    private expanded;
    private scrollTop;
    private query;
    private matches;
    private message;
    private following;
    private lineNumbers;
    private page;
    private width;
    private painted;
    private needsReveal;
    private revealMatch;
    private showApprovals;
    /** The run's wall time split into work and waits for the person. */
    private times;
    /** Painted blocks by id, expansion, approvals and width; cleared when
     *  the blocks are rebuilt. */
    private paintCache;
    constructor(roots: TreeNode[], traceId: string);
    private bindings;
    handleKey(event: KeyEvent, viewport: Viewport): ViewAction;
    helpLines(): string[];
    notify(message: string): void;
    setFollowIndicator(on: boolean): void;
    private trace;
    private selected;
    private derive;
    /** Fold each complete sub-agent group the first time it is seen, unless
     *  the cursor is inside it; unfold one that runs again. */
    private applyFoldDefaults;
    private refreshVisible;
    /** The folded group that hides a block: one on its path other than its
     *  own row. */
    private hiddenBy;
    /** Open every fold on the way to a block, so it can be selected. */
    private unfoldTo;
    setData(roots: TreeNode[]): void;
    setTrace(traceId: string): void;
    focusId(): string | undefined;
    /** The block as a row of the trace, by the one mapping `blockRowId`
     *  that `agency logs search` uses too. A turn header or a thread divider
     *  is no row. */
    selectedRowId(): string | undefined;
    setFocus(id: string): void;
    private select;
    private move;
    /** Scroll by lines and move the cursor to the block at the top of the
     *  pane. A page that cannot scroll, at the end or when everything fits,
     *  leaves the cursor where it is. */
    private pageBy;
    private toggle;
    private toggleSystem;
    private updateMatches;
    applySearch(query: string): void;
    private showMatch;
    /** Whether a tool matches the query only in an approved interrupt's
     *  message, which `p` hides by default and the match must reveal. */
    private matchOnlyInApprovals;
    private nextMatch;
    escape(): boolean;
    private prepare;
    /** Scroll only as far as it takes to bring the block into the pane, so
     *  the active box stays where the eye left it. A block whose top is
     *  already in the pane leaves the scroll alone, so a box that Enter
     *  opens grows downward in place; one above scrolls up to its top; one
     *  below scrolls down to its bottom, or to its top when it is taller
     *  than the pane. */
    private keepVisible;
    /** `▸` or `▾` on a block Enter opens or closes; the same width of
     *  nothing on the rest, so labels line up. */
    private spineMarker;
    private paintBlockCached;
    /** The context row above the pane: the thread path of the block on the
     *  pane's first row, `Thread · main · 2 LLM calls › researchAgent ›
     *  Thread · main · 13 LLM calls`, so what the top of the pane is inside
     *  is always stated and never covers a row of it. Blank for a trace with
     *  no thread rows. */
    private breadcrumb;
    /** `Elapsed 26m37s · 7m25s working · 19m12s waiting for the user · block 12 of 87`;
     *  the split appears only when the trace has turns to split by. */
    private headerText;
    render(viewport: Viewport, sharedHints?: string): Element;
}