@oh-my-pi/pi-tui 18.2.4 → 18.2.5

package/dist/types/chrome/message-frame.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared rendering for extension/hook custom message frames.
+ *
+ * `CustomMessageComponent` and `HookMessageComponent` share one behavior-owning
+ * frame: it tries a user-supplied renderer first and falls back to a label plus
+ * markdown body when the renderer returns nothing or throws. Hook messages
+ * collapse to the first N lines when not expanded; extension messages render
+ * in full.
+ */
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import { type Component, Container } from "../tui.js";
+import { type Theme, type ThemeColor } from "../theme/index.js";
+/** Message shape consumed by the shared frame. */
+export interface FramedMessage {
+    customType: string;
+    content: string | (TextContent | {
+        type: string;
+    })[];
+}
+/**
+ * Callable signature shared by `MessageRenderer` (extensions) and
+ * `HookMessageRenderer` (hooks). Both narrow `message` to their own type;
+ * this signature is the structural intersection callers can hand off here.
+ */
+export type FramedRenderer<M extends FramedMessage> = (message: M, options: {
+    expanded: boolean;
+}, theme: Theme) => Component | undefined;
+/** Presentation and extension-renderer policy for a framed custom message. */
+export interface FramedMessageOptions<M extends FramedMessage> {
+    readonly message: M;
+    /** Theme-aware icon glyph shown before the custom type. */
+    readonly icon?: string | (() => string);
+    /** Hide the default type header while retaining the message body. */
+    readonly hideHeader?: boolean | (() => boolean);
+    /** Semantic color for the outline, defaulting to the muted border. */
+    readonly borderColor?: ThemeColor;
+    /** Collapse the markdown body to this many lines when `expanded` is false. Omit to never collapse. */
+    readonly collapseAfterLines?: number;
+    readonly customRenderer?: FramedRenderer<M>;
+}
+/**
+ * Behavior-owning custom message frame. It retries extension renderers whenever
+ * expansion or theme state changes and falls back to the shared card when a
+ * renderer returns nothing or throws.
+ */
+export declare class FramedMessageComponent<M extends FramedMessage> extends Container {
+    #private;
+    constructor(options: FramedMessageOptions<M>);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    dispose(): void;
+}

package/dist/types/chrome/message-notice.d.ts

@@ -0,0 +1,35 @@
+import { type Component, Container } from "../tui.js";
+import { type ThemeColor } from "../theme/index.js";
+/** Render-time state supplied to a notice presentation. */
+export interface MessageNoticeContext {
+    readonly expanded: boolean;
+}
+/** Header and optional detail rows rendered inside a notice box. */
+export interface MessageNoticePresentation {
+    readonly header: string;
+    readonly icon?: string;
+    readonly body?: Component | readonly Component[];
+}
+/** Presentation policy for a transcript notice. */
+export interface MessageNoticeOptions {
+    readonly presentation: (context: MessageNoticeContext) => MessageNoticePresentation;
+    readonly severity?: ThemeColor;
+    readonly background?: (text: string) => string;
+    readonly leadingSpace?: boolean;
+}
+/**
+ * Shared transcript notice shell with expansion and tool-activity visibility.
+ * Domain controllers own their state and call {@link refresh} after mutations.
+ */
+export declare class MessageNoticeComponent extends Container {
+    #private;
+    constructor(options: MessageNoticeOptions);
+    setExpanded(expanded: boolean): void;
+    isExpanded(): boolean;
+    setToolActivityVisible(visible: boolean): void;
+    /** Rebuild the presentation after controller-owned state changes. */
+    refresh(): void;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/chrome/overlay-box.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared box-drawing chrome for overlays — string helpers for fullscreen
+ * surfaces (the `/copy` picker, the plan-review overlay, …) and the
+ * {@link OverlayPanel} container for inline overlays hosted in the editor slot
+ * or an anchored container. Everything paints with `theme.boxRound` glyphs
+ * (rounded corners, sharp tee/cross junctions) and the `border`/`accent` theme
+ * colors so all outlined overlays read identically.
+ */
+import { type Component } from "../tui.js";
+import { type ThemeColor } from "../theme/index.js";
+/** Top border with an optional title inset into the rule. `color` recolors border and title (default border/accent). */
+export declare function topBorder(width: number, title: string, color?: ThemeColor): string;
+/** A horizontal rule with left/right tees, splitting overlay sections. */
+export declare function divider(width: number): string;
+export declare function bottomBorder(width: number, color?: ThemeColor): string;
+/** Wrap pre-styled content in vertical borders with single-column insets. */
+export declare function row(content: string, width: number, color?: ThemeColor): string;
+/** Body content width for a two-column overlay of total `width`. */
+export declare function splitBodyWidth(width: number, sidebarWidth: number): number;
+/** Top border carrying the title, split by a `┬` over the column divider. */
+export declare function topBorderSplit(width: number, title: string, sidebarWidth: number): string;
+/** Section rule that closes the sidebar column with a `┴` over the divider. */
+export declare function dividerSplit(width: number, sidebarWidth: number): string;
+/** A two-column content row: `│ sidebar │ body │`, each inset by one column. */
+export declare function splitRow(sidebar: string, body: string, width: number, sidebarWidth: number): string;
+/**
+ * Mutable row region for composing an {@link OverlayPanel}. Callers provide
+ * already-styled logical rows and may pin the region to an exact height; extra
+ * rows are clipped and missing rows are filled. This keeps dialog body budgets
+ * in the layout component instead of duplicating border and padding math in
+ * every overlay.
+ */
+export declare class PanelRows implements Component {
+    #private;
+    /** Replace the region rows. Byte-identical rows retain the previous render identity. */
+    setLines(lines: readonly string[]): void;
+    /** Pin the region to exactly `height` rows, or pass `undefined` for its natural height. */
+    setHeight(height: number | undefined): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}
+/** Sentinel child rendered by {@link OverlayPanel} as a `├───┤` section rule. */
+export declare class PanelDivider implements Component {
+    render(): readonly string[];
+}
+/**
+ * Rounded-box container for inline overlays (selectors, run panels). Children
+ * render inside `│ … │` rows between a titled top border and a bottom border,
+ * so inline overlays share the chrome of fullscreen overlays. The top border
+ * is exactly one row — `routeMouse` offsets written for a one-line top rule
+ * stay valid — and content is inset two columns on each side.
+ */
+export declare class OverlayPanel implements Component {
+    #private;
+    children: Component[];
+    constructor(title?: string);
+    get title(): string;
+    set title(value: string);
+    addChild(component: Component): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    invalidate(): void;
+    dispose(): void;
+    setIgnoreTight(ignore: boolean): this;
+    /**
+     * Body rows at the given content width, without border chrome —
+     * {@link render} draws exactly these (4 columns narrower) inside `│ … │`
+     * rows. Lets callers and tests assert on component-content coordinates
+     * instead of reverse-parsing box glyphs. `PanelDivider` children contribute
+     * no rows here (their rule is border chrome).
+     */
+    renderContent(width: number): string[];
+    render(width: number): readonly string[];
+}

package/dist/types/chrome/qrcode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Self-contained QR Code generator (byte mode, versions 1-40, EC levels
+ * L/M/Q/H) with a half-block ANSI terminal renderer.
+ *
+ * Pure TypeScript, zero dependencies: the collab `/collab qrcode` command uses
+ * it to print scannable browser-join codes without pulling a runtime QR
+ * package into the bundle. The algorithm follows ISO/IEC 18004; the two
+ * error-correction tables below are direct transcriptions of that spec.
+ */
+export type QrEcLevel = "L" | "M" | "Q" | "H";
+export interface QrEncodeOptions {
+    /** Lowest version to consider (default 1). */
+    minVersion?: number;
+    /** Highest version to consider (default 40). */
+    maxVersion?: number;
+    /** Force a mask 0-7; -1 (default) auto-selects the lowest-penalty mask. */
+    mask?: number;
+}
+/**
+ * A finished QR symbol: a square grid of dark/light modules plus the chosen
+ * version, EC level, and mask. `module(x, y)` is the only access path the
+ * renderers need.
+ */
+export declare class QrCode {
+    #private;
+    readonly version: number;
+    readonly ecLevel: QrEcLevel;
+    readonly size: number;
+    /** Selected mask pattern (0-7). */
+    readonly mask: number;
+    private constructor();
+    module(x: number, y: number): boolean;
+    /** Encode a string in byte mode (UTF-8). Throws if it exceeds version 40. */
+    static encodeText(text: string, ecLevel?: QrEcLevel, options?: QrEncodeOptions): QrCode;
+    /** Encode raw bytes in byte mode. Throws if they exceed version 40 at this EC level. */
+    static encodeBytes(data: Uint8Array, ecLevel?: QrEcLevel, options?: QrEncodeOptions): QrCode;
+}
+export interface QrRenderOptions {
+    /** Quiet-zone width in modules on every side (default 4, per spec). */
+    margin?: number;
+}
+/**
+ * Render a QR symbol as ANSI half-block rows: each text row packs two module
+ * rows via `▀`/`▄`/`█`, drawn black-on-white so a phone camera reads dark
+ * modules as data and the quiet zone as the light margin. The leading margin
+ * makes the symbol scannable regardless of the terminal's own background.
+ */
+export declare function renderQrHalfBlocks(qr: QrCode, options?: QrRenderOptions): string[];

package/dist/types/chrome/segment-track.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared renderer for a horizontal row of colored "segments" styled after the
+ * status line: each segment is colored by its track position from the theme's
+ * own palette, the active one is filled as a powerline chip (its color as the
+ * background, a luminance-matched label, flanked by triangle caps) and the
+ * rest are plain colored labels joined by a thin separator.
+ *
+ * Used by the plan-mode model-tier slider ({@link HookSelectorComponent}) and
+ * the ctrl+p role-cycle status so both surfaces read identically.
+ */
+import { type ThemeColor } from "../theme/index.js";
+export interface TrackSegment {
+    label: string;
+}
+/**
+ * Resolve up to `count` theme colors that render distinctly under the active
+ * theme, in candidate preference order. May return fewer than `count` when the
+ * theme has fewer distinct hues (e.g. monochrome themes) — callers wrap with
+ * modulo. Never returns an empty array: `accent` always resolves.
+ */
+export declare function resolveSegmentPalette(count: number): ThemeColor[];
+/**
+ * Render `segments` as a colored chip track with `activeIndex` filled. Returns
+ * a single line of styled text with no surrounding caption or arrows — callers
+ * frame it as they need.
+ */
+export declare function renderSegmentTrack(segments: TrackSegment[], activeIndex: number): string;

package/dist/types/chrome/select-list-mouse-routing.d.ts

@@ -0,0 +1,4 @@
+import type { SelectList } from "../components/select-list.js";
+import type { SgrMouseEvent } from "../mouse.js";
+/** Route overlay-local mouse input past a panel's top border into its SelectList child. */
+export declare function routeSelectListMouseWithTopBorder(selectList: SelectList, event: SgrMouseEvent, line: number, col: number): void;

package/dist/types/chrome/selector-helpers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Render `rows` through a {@link ScrollView} with the shared list theme (muted
+ * track / accent thumb) and an "auto" scrollbar, positioned at `scrollOffset`.
+ * Returns the rendered lines for the caller to append to its output.
+ */
+export declare function renderScrollableList(rows: readonly string[], options: {
+    width: number;
+    totalRows: number;
+    scrollOffset: number;
+}): readonly string[];
+/**
+ * Center a viewport window of `maxVisible` rows on `selectedIndex` within a
+ * list of `total` rows, clamped to valid bounds. Used by the selection-centered
+ * list panes (history search, tree selector).
+ */
+export declare function centeredWindow(selectedIndex: number, total: number, maxVisible: number): {
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * Width available for row content, reserving the rightmost column for the
+ * scrollbar when the list overflows its visible window.
+ */
+export declare function contentRowWidth(width: number, total: number, maxVisible: number): number;
+/**
+ * Clamp `selectedIndex` into `[0, total)` and nudge `scrollOffset` so the
+ * selection stays within the visible window of `maxVisible` rows. Returns the
+ * adjusted pair; on an empty list both reset to 0.
+ */
+export declare function clampSelection(selectedIndex: number, scrollOffset: number, total: number, maxVisible: number): {
+    selectedIndex: number;
+    scrollOffset: number;
+};
+/**
+ * Classify a key event for search-query text entry. Returns the single
+ * printable character to append to the query, or `null` when the key is not a
+ * searchable character: non-printable or multi-byte.
+ */
+export declare function searchableChar(data: string): string | null;
+/**
+ * Handle the shared tab-cycling keys: Tab/Right advance to the next tab,
+ * Shift+Tab/Left to the previous. Invokes `switchTab` with the direction and
+ * returns true when the key was consumed.
+ */
+export declare function handleTabSwitchKey(data: string, switchTab: (direction: 1 | -1) => void): boolean;
+/**
+ * Pad `lines` with blank rows up to `rows` so a full-screen overlay covers the
+ * viewport instead of letting the transcript peek through below it. Copies
+ * before padding — the source array may be component-owned and must not be
+ * mutated.
+ */
+export declare function padLinesToHeight(lines: readonly string[], rows: number): readonly string[];

package/dist/types/chrome/shared.d.ts

@@ -0,0 +1,5 @@
+import type { TabBarTheme } from "../components/tab-bar.js";
+/** Compact single-line display text for statuses; unlike titles, collapse padding and trim. */
+export declare function sanitizeStatusText(text: string): string;
+/** Shared tab bar theme used by fullscreen overlays (settings, agent hub). */
+export declare function getTabBarTheme(): TabBarTheme;

package/dist/types/chrome/streaming-panel.d.ts

@@ -0,0 +1,19 @@
+import { type Component, Container } from "../tui.js";
+/** One refresh of a streaming overlay's presentation. */
+export interface StreamingPanelPresentation {
+    /** Non-empty sections separated by one blank row. */
+    readonly sections: readonly (Component | readonly Component[] | undefined)[];
+    /** Use a provider when action availability may change without a controller transition. */
+    readonly footer: string | (() => string);
+}
+/**
+ * Shared body/footer shell for streaming overlays. The overlay controller keeps
+ * its own state machine and calls {@link refresh} after each transition.
+ */
+export declare class StreamingPanelContent extends Container {
+    #private;
+    constructor(presentation: () => StreamingPanelPresentation);
+    /** Rebuild sections and the footer from controller-owned state. */
+    refresh(): void;
+    invalidate(): void;
+}

package/dist/types/chrome/tool-activity.d.ts

@@ -0,0 +1,17 @@
+import { type Component, Container } from "../tui.js";
+export interface ToolActivityComponent {
+    setToolActivityVisible(visible: boolean): void;
+}
+export declare function isToolActivityComponent(component: Component): component is Component & ToolActivityComponent;
+export declare class ToolActivityContainer extends Container implements ToolActivityComponent {
+    #private;
+    constructor(component: Component | Component[]);
+    setToolActivityVisible(visible: boolean): void;
+    /**
+     * Forward Ctrl+O expansion to wrapped children. The transcript's expansion
+     * traversal only visits top-level children, so the wrapper must proxy or
+     * wrapped renderers would freeze at their insertion-time expansion state.
+     */
+    setExpanded(expanded: boolean): void;
+    render(width: number): readonly string[];
+}

package/dist/types/chrome/transcript-container.d.ts

@@ -0,0 +1,129 @@
+import { type Component, Container, type HistoryBatch } from "../tui.js";
+/** Shared animation time supplied by the constrained transcript root. */
+export interface AnimationFrame {
+    readonly tick: number;
+    readonly now: number;
+}
+/** Lets an active block adapt its presentation to its allocated viewport rows. */
+export interface TranscriptPresentationTarget {
+    setTranscriptAllocation?(rows: number, frame: AnimationFrame): void;
+}
+/** Presentation declaration captured permanently when a block is added. */
+export type TranscriptBlockMode = "mutable" | "appendOnly";
+/** Immutable width-independent identity for one stable semantic row. */
+export interface TranscriptStableRow {
+    readonly key: string;
+}
+/**
+ * Explicit semantic-row contract for a block whose stable head may enter native
+ * history before finalization. Every later array must extend the prior keys
+ * exactly; each row renderer is deterministic for its width.
+ * A publication that breaks these invariants (e.g. a mid-stream theme change
+ * re-coloring already-emitted bytes) freezes further stable-row emission for
+ * that block instead of failing the render — see {@link TranscriptContainer}.
+ */
+export interface AppendOnlyTranscriptBlock {
+    readonly transcriptBlockMode: "appendOnly";
+    getTranscriptStableRows(): readonly TranscriptStableRow[];
+    /**
+     * Render the first `count` semantic rows at the requested current width.
+     * Counts are monotonic identities, not physical row counts; this output must
+     * prefix the block's full render at the same width.
+     */
+    renderTranscriptStableRows(count: number, width: number): readonly string[];
+    /**
+     * Discard every published stable row so the block re-renders its head from
+     * scratch. Called only alongside a destructive display reset (e.g. a
+     * thinking-visibility toggle) that clears the native scrollback those rows
+     * occupied — the sole context in which the append-only "published bytes never
+     * change" contract may be retracted. Optional: blocks whose stable-row
+     * presentation never changes may omit it.
+     */
+    resetTranscriptStableRows?(): void;
+}
+/**
+ * Block lifecycle:
+ * - `active`: still mutating; renders live and counts against tool admission.
+ * - `settled`: finalized but retained in the mutable viewport until pressure.
+ * - `committed`: logically retired; replay never rewinds this state.
+ */
+type BlockState = "active" | "settled" | "committed";
+/** Whether `prefix` matches `rows` byte-for-byte from the top. */
+export declare function isRowPrefix(prefix: readonly string[], rows: readonly string[]): boolean;
+/** Strip leading/trailing all-blank rows; the viewport allocator measures blocks by this trimmed height. */
+export declare function trimBlankEdges(rows: readonly string[]): readonly string[];
+/** One live block's row span in the last `renderViewport` output (half-open `[start, end)`). */
+export interface TranscriptViewportSpan {
+    component: Component;
+    start: number;
+    end: number;
+}
+/** Owns transcript order, live capacity, and ordered immutable retirement. */
+export declare class TranscriptContainer extends Container {
+    #private;
+    addChild(component: Component): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    setToolActivityVisible(visible: boolean): void;
+    /**
+     * Forget the append-only emission ledger — emitted counts, published stable
+     * rows, per-width render cache, and freeze state — for every block, and ask
+     * each append-only block to drop its own published rows. The next replay then
+     * re-renders each block from its current {@link Component.render}, applying a
+     * changed presentation (e.g. a thinking-visibility toggle) to rows that were
+     * already emitted as stable heads while streaming (#10177).
+     *
+     * Callers MUST pair this with a scrollback-clearing {@link resetDisplay}: the
+     * emitted rows it forgets still sit in native history until that clear
+     * rewrites them, so unpaired use would duplicate them on the next retirement.
+     */
+    resetStableEmission(): void;
+    /** Whether a transient block may be discarded without leaving tape history. */
+    canRemoveBlock(component: Component): boolean;
+    /** Lifecycle state per block in transcript order (diagnostics and tests). */
+    blockStates(): readonly BlockState[];
+    /** Permanently captured presentation mode per block (diagnostics and tests). */
+    blockModes(): readonly TranscriptBlockMode[];
+    /** Emitted stable semantic-row counts in transcript order. */
+    emittedStableRows(): readonly number[];
+    /** Whether visible active capacity and live-block memory permit another admission. */
+    canAdmit(rows: number): boolean;
+    /** Prepares one atomic replay of the committed ledger and an emitted active-head prefix. */
+    beginReplay(): void;
+    /**
+     * Drop a not-yet-offered replay so a shutdown flush emits only un-retired
+     * rows. The terminal already holds the committed ledger; re-streaming it at
+     * quit is pure write volume. An already offered replay batch stays valid.
+     */
+    cancelReplay(): void;
+    /** Total rows the live, un-emitted tail occupies at `width`. */
+    liveRowCount(width: number): number;
+    /** Block spans of the last `renderViewport` output, in output coordinates. Empty when the tail is empty. */
+    getLastViewportSpans(): readonly TranscriptViewportSpan[];
+    /** Render the live tail, constrained to the supplied transcript height. */
+    renderViewport(width: number, rows: number, frame: AnimationFrame): readonly string[];
+    /** Offers stable-head emission or the shortest finalized prefix needed under pressure. */
+    peekFinalizedBatch(width: number, capacity: number): HistoryBatch | undefined;
+    /** Returns only a prepared complete replay, never a normal retirement offer. */
+    peekReplayBatch(width: number): HistoryBatch | undefined;
+    /** Offers the complete currently eligible prefix for graceful shutdown. */
+    peekFlushBatch(width: number): HistoryBatch | undefined;
+    /** Recompose the unacknowledged batch so a discarded TUI frame can be rendered again. */
+    rerenderOfferedBatch(width: number): HistoryBatch | undefined;
+    /** Acknowledges exactly the most recently offered append, commit, or replay transaction. */
+    acknowledgeFinalizedBatch(id: number): void;
+    /**
+     * Render only the trailing `maxRows` semantic rows, walking blocks bottom-up.
+     * Used by the transient resize-buffer repaint, which needs one viewport of
+     * tail rows per resize event — never the full committed ledger.
+     */
+    renderTail(width: number, maxRows: number): readonly string[];
+    /** Full semantic render used by exports and non-terminal commands. */
+    render(width: number): readonly string[];
+    /** Rendered row where a child's block begins in the last full render() (transcript deep-links). */
+    getChildStartRow(child: Component): number | undefined;
+}
+/** Groups sibling rows into one conservative mutable semantic transcript block. */
+export declare class TranscriptBlock extends Container {
+}
+export {};

package/dist/types/chrome/transcript-status.d.ts

@@ -0,0 +1,12 @@
+import { TranscriptBlock } from "./transcript-container.js";
+/** One compact transcript status row assembled from already-styled parts. */
+export interface TranscriptStatusRow {
+    readonly parts: readonly (string | undefined)[];
+    readonly indent?: number;
+}
+/** Shared compact status-pill block used by notices and background activity. */
+export declare class TranscriptStatusBlock extends TranscriptBlock {
+    constructor(rows: readonly TranscriptStatusRow[]);
+    /** Append a supplemental line such as an artifact warning. */
+    addLine(text: string, indent?: number): void;
+}

package/dist/types/chrome/visual-truncate.d.ts

@@ -0,0 +1,19 @@
+export interface VisualTruncateResult {
+    /** The visual lines to display */
+    visualLines: readonly string[];
+    /** Number of visual lines that were skipped (hidden) */
+    skippedCount: number;
+}
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export declare function truncateToVisualLines(text: string, maxVisualLines: number, width: number, paddingX?: number): VisualTruncateResult;

package/dist/types/components/disclosure.d.ts

@@ -0,0 +1,42 @@
+import type { Component } from "../tui.js";
+/** A component slot; factory slots are constructed only when their branch is first rendered. */
+export type DisclosureSlot = Component | (() => Component);
+/** Options for a controlled, compositional disclosure. */
+export interface DisclosureOptions {
+    /** Content rendered in both collapsed and expanded states. */
+    summary?: DisclosureSlot;
+    /** Optional collapsed-only preview. */
+    collapsedBody?: DisclosureSlot;
+    /** Expanded-only content. A factory keeps expensive children lazy. */
+    body: () => Component;
+    /** Initial controlled state. Subsequent changes go through {@link Disclosure.setExpanded}. */
+    expanded?: boolean;
+    /** Horizontal padding applied outside every rendered slot. */
+    paddingX?: number;
+    /** Maximum physical rows retained from the collapsed-only preview, including its hint row. */
+    maxCollapsedRows?: number;
+    /** Build the final row when {@link DisclosureOptions.maxCollapsedRows} hides preview rows. */
+    collapsedHint?: (hiddenRows: number, width: number) => string;
+}
+/**
+ * Controlled summary/detail composition for transcript and overlay surfaces.
+ *
+ * The expanded body is constructed on its first expanded render, not when the
+ * disclosure is created or toggled. Materialized children are retained across
+ * collapse/re-expand cycles, invalidated and disposed with the disclosure, and
+ * their immutable render arrays are copied rather than mutated.
+ */
+export declare class Disclosure implements Component {
+    #private;
+    constructor(options: DisclosureOptions);
+    /** Current controlled expansion state. */
+    get expanded(): boolean;
+    /** Show or hide the lazily constructed detail body. */
+    setExpanded(expanded: boolean): void;
+    setIgnoreTight(ignore: boolean): this;
+    invalidate(): void;
+    dispose(): void;
+    debugState(): Record<string, unknown>;
+    get debugChildren(): readonly Component[];
+    render(width: number): readonly string[];
+}