import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
/**
 * Transcript container that renders every block's current content each frame
 * and reports the native-scrollback exactness boundary
 * (`NativeScrollbackLiveRegion`): the frame row below which every rendered
 * row is final. The boundary covers the leading run of finalized blocks plus
 * the first still-live block's declared settled rows
 * ({@link FinalizableBlock.getTranscriptBlockSettledRows}). Rows below it
 * commit to native scrollback as exact, audited content; rows above it that
 * scroll off the window commit as frozen visual snapshots the engine never
 * re-anchors or recommits (the tape records what was on screen).
 *
 * The engine never rewrites committed history: rows that have entered the
 * tape keep whatever bytes they were committed with ("let the history be"),
 * while the visible window always repaints from each block's latest render —
 * a late tool result, a post-finalize error pin, or an expand toggle is
 * always reflected on screen while it remains in the window.
 *
 * Assembly is incremental: the returned array is persistent and mutated in
 * place. Each block's render is still called every frame, but a block whose
 * render returned the same array reference at an unchanged offset reuses its
 * previously assembled rows; the array is truncated and re-pushed only from
 * the first divergent block. The leading byte-identical row count is reported
 * through {@link RenderStablePrefix} so the engine can skip marker scanning,
 * line preparation, and the committed-prefix audit for those rows.
 */
export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider {
    #private;
    invalidate(): void;
    clear(): void;
    setNativeScrollbackCommittedRows(rows: number): void;
    getRenderStablePrefixRows(): number;
    getNativeScrollbackLiveRegionStart(): number | undefined;
    /**
     * Whether none of `component`'s rows (per the most recent render) have
     * entered native scrollback. Callers that retract ephemeral blocks (IRC
     * cards, displaceable todo/job snapshots) must check this: removing a
     * block whose rows are already on the tape is an interior deletion of
     * committed history the engine cannot express — the block must be sealed
     * in place as history instead. A component that has never rendered has no
     * committed rows and is safely removable.
     */
    isBlockUncommitted(component: Component): boolean;
    /**
     * Whether `component` is inside the live (repaintable) region exactly as
     * {@link render} computes it: at/after the first still-mutating block, or
     * the transcript tail when every block has finalized. Self-animating
     * finalized blocks (a detached task's shimmering progress rows) poll this
     * to stop animating — and settle on static bytes — the moment they sit
     * above the seam, where their rows become commit-eligible native-scrollback
     * history.
     */
    isBlockInLiveRegion(component: Component): boolean;
    /**
     * Render only the bottom `maxRows` rows of the transcript at `width`, walking
     * blocks from the last toward the first and stopping the instant enough rows
     * are collected — blocks above the fold are never rendered. The engine's
     * resize viewport fast path uses this so a drag (a SIGWINCH burst, each event
     * a fresh width that misses every per-width cache) re-lays-out only the
     * handful of visible blocks instead of the whole history every event.
     *
     * State-isolated by contract: touches none of the persistent full-compose
     * fields (#lines, #segments, the per-block diff snapshots, the commit/stable
     * bookkeeping), so the authoritative full render on settle reconciles exactly
     * as if this never ran. Calling each block's render() still warms its own
     * per-width cache, which that settle render then reuses for free.
     *
     * Consecutive visible blocks are joined by exactly one blank separator, the
     * same rule render() applies, so the result equals the bottom of a full
     * render except for an at-most-one-row separator on the topmost included
     * block — a transient discrepancy the settle paint overwrites.
     */
    renderViewportTail(width: number, maxRows: number): readonly string[];
    render(width: number): readonly string[];
}
/**
 * Groups a run of sibling rows (an IRC card's header + body, a file-mention
 * list, a bordered command/version panel) into a single transcript child so the
 * container spaces it as one block — one blank line above, none injected between
 * its rows. Without this wrapper the rows would be top-level children and the
 * container would put a blank line between each (and inside any border box).
 * It is a plain {@link Container}; the named subclass documents intent and makes
 * every manual block grouping greppable.
 */
export declare class TranscriptBlock extends Container {
}
