@termuijs/widgets 0.1.5 → 0.1.6

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as _termuijs_core from '@termuijs/core';
 import { Style, Rect, EventEmitter, KeyEvent, MouseEvent, LayoutNode, Screen, Color } from '@termuijs/core';
+import { SpringConfig, SpringPresetName } from '@termuijs/motion';
 
 /**
  * Event map for widgets.
@@ -12,9 +13,25 @@ interface WidgetEvents {
     mount: void;
     unmount: void;
 }
+/** Reset the widget ID counter (for testing only). */
+declare function _resetWidgetIdCounter(): void;
 /**
  * Base class for all TermUI widgets.
  *
+ * CONSTRUCTOR SIGNATURE CONVENTION:
+ * - Simple display widgets: (content?, style?: Partial<Style>, opts?: SpecificOptions)
+ * - Data widgets:           (data, style?: Partial<Style>, opts?: SpecificOptions)
+ * - Compound UI widgets:    (options: SpecificOptions, style?: Partial<Style>)
+ *
+ * FOCUSABLE PATTERN:
+ * Set `focusable = true` as a class field initializer, OR in the constructor
+ * body after calling `super()`. Do NOT set it inside `_renderSelf()`.
+ *
+ * STYLE MERGE PATTERN:
+ * All widgets should call `super(mergeStyles(defaultStyle(), { ...defaults }, style))`
+ * to produce consistent base styles. For widgets that accept `style` as the
+ * second parameter, pass it directly through to `super()`.
+ *
  * Provides:
  * - Unique ID generation
  * - Style management and merging
@@ -37,6 +54,8 @@ declare abstract class Widget {
     protected _rect: Rect;
     /** Reference to the layout node (set during getLayoutNode) */
     private _layoutNode;
+    /** Error from last render call, null if no error */
+    protected _renderError: Error | null;
     /** Whether this widget can receive focus */
     focusable: boolean;
     /** Tab index for focus ordering */
@@ -50,7 +69,13 @@ declare abstract class Widget {
      * Newly created widgets start dirty.
      */
     protected _dirty: boolean;
+    /** Enable animated layout transitions for size/position changes */
+    layoutTransition: Partial<SpringConfig> | SpringPresetName | boolean;
+    private _layoutCancel;
+    private _targetRect;
     constructor(style?: Partial<Style>);
+    /** Check if this widget is currently active (focused) */
+    isActive(): boolean;
     /** Get the current style */
     get style(): Style;
     /** Update the style (merge with existing) */
@@ -63,6 +88,12 @@ declare abstract class Widget {
     removeChild(child: Widget): void;
     /** Remove all children */
     clearChildren(): void;
+    /**
+     * Destroy this widget and all its descendants.
+     * Cleans up event handlers, removes parent references, and clears children.
+     * Fiber-level cleanup is handled by the reconciler's _pruneInstancesForWidget.
+     */
+    destroy(): void;
     /** Get all children */
     get children(): ReadonlyArray<Widget>;
     /**
@@ -90,6 +121,7 @@ declare abstract class Widget {
      * Update the computed rect from layout results.
      */
     updateRect(rect: Rect): void;
+    private _applyRect;
     /**
      * Mark this widget as needing re-render.
      * Propagates up to parent so the render loop can detect changes.
@@ -97,10 +129,13 @@ declare abstract class Widget {
     markDirty(): void;
     /**
      * Clear the dirty flag after rendering.
+     * Widgets with a render error stay dirty so they are retried on the next frame.
      */
     clearDirty(): void;
     /** Check if this widget (or any child) needs re-rendering */
     get isDirty(): boolean;
+    /** Get the last render error, if any */
+    get renderError(): Error | null;
     /**
      * Render the border around this widget, including focus ring if focused.
      */
@@ -130,6 +165,8 @@ declare abstract class Widget {
  */
 declare class Box extends Widget {
     constructor(style?: Partial<Style>);
+    /** Check if this Box has no children */
+    isEmpty(): boolean;
     protected _renderSelf(screen: Screen): void;
 }
 
@@ -156,6 +193,7 @@ declare class Text extends Widget {
     setContent(content: string): void;
     /** Get current text content */
     getContent(): string;
+    toString(): string;
     /** Set vertical scroll offset (lines to skip). */
     setScrollY(offset: number): void;
     /** Set horizontal scroll offset (columns to skip). */
@@ -170,6 +208,8 @@ interface LogViewOptions {
     highlight?: Record<string, Color>;
     /** Auto-scroll to bottom */
     autoScroll?: boolean;
+    /** Maximum lines to retain (0 = unlimited) */
+    maxLines?: number;
 }
 /**
  * LogView — scrollable, highlighted log output.
@@ -181,6 +221,7 @@ declare class LogView extends Widget {
     private _scrollOffset;
     private _highlight;
     private _autoScroll;
+    private _maxLines;
     constructor(style?: Partial<Style>, opts?: LogViewOptions);
     setLines(lines: string[]): void;
     appendLine(line: string): void;
@@ -191,19 +232,31 @@ declare class LogView extends Widget {
     private _getLineColor;
 }
 
-interface TreeNode {
+type ProgressBarStyle = 'blocks' | 'line' | 'dots';
+interface ProgressStringProps {
+    value: number;
+    width?: number;
+    style?: ProgressBarStyle;
+    color?: string;
+    showPercent?: boolean;
+}
+declare const ProgressString: {
+    render({ value, width, style, color, showPercent }: ProgressStringProps): string;
+};
+
+interface TreeNode$1 {
     label: string;
-    children?: TreeNode[];
+    children?: TreeNode$1[];
     expanded?: boolean;
     data?: unknown;
 }
 interface TreeOptions {
-    nodes: TreeNode[];
-    onSelect?: (node: TreeNode, path: number[]) => void;
+    nodes: TreeNode$1[];
+    onSelect?: (node: TreeNode$1, path: number[]) => void;
     indent?: number;
 }
-interface VisibleEntry {
-    node: TreeNode;
+interface VisibleEntry$1 {
+    node: TreeNode$1;
     depth: number;
     path: number[];
 }
@@ -212,7 +265,7 @@ interface VisibleEntry {
  *
  * Supports:
  * - Expand/collapse of parent nodes
- * - Keyboard navigation (ArrowUp/Down/Left/Right, j/k/h/l, Home/End)
+ * - Keyboard navigation (up/down/left/right, j/k/h/l, home/end)
  * - Enter/Space to toggle or select
  * - onSelect callback for leaf nodes
  * - Unicode and ASCII fallback symbols
@@ -224,11 +277,11 @@ declare class Tree extends Widget {
     protected _indent: number;
     protected _selectedIndex: number;
     protected _scrollOffset: number;
-    protected _visibleNodes: VisibleEntry[];
+    protected _visibleNodes: VisibleEntry$1[];
     constructor(options: TreeOptions, style?: Partial<Style>);
     get selectedIndex(): number;
-    get selectedNode(): TreeNode | undefined;
-    setNodes(nodes: TreeNode[]): void;
+    get selectedNode(): TreeNode$1 | undefined;
+    setNodes(nodes: TreeNode$1[]): void;
     /** Move cursor up one visible row */
     movePrev(): void;
     /** Move cursor down one visible row */
@@ -267,7 +320,7 @@ interface JSONViewOptions {
     /** The JSON value to display */
     data: unknown;
     /** Callback when a leaf node is selected */
-    onSelect?: (node: TreeNode, path: number[]) => void;
+    onSelect?: (node: TreeNode$1, path: number[]) => void;
     /** Spaces per indent level (default: 2) */
     indent?: number;
 }
@@ -275,7 +328,7 @@ interface JSONViewOptions {
  * Convert any JSON-compatible value to a TreeNode, optionally prefixed
  * by `key` (the property name or array index in the parent container).
  */
-declare function jsonToTree(value: unknown, key?: string): TreeNode;
+declare function jsonToTree(value: unknown, key?: string): TreeNode$1;
 /**
  * JSONView — a syntax-colored, collapsible JSON viewer.
  *
@@ -456,6 +509,86 @@ declare class ToolApproval extends ToolCall {
     handleKey(key: string): void;
 }
 
+/**
+ * A raw Canvas widget providing a HTML5-like 2D drawing context for custom rendering.
+ * Mapped to Braille characters for 2x4 sub-cell pixel resolution.
+ */
+declare class Canvas extends Widget {
+    private _pixels;
+    private _canvasWidth;
+    private _canvasHeight;
+    private _color;
+    constructor(style?: Partial<Style>);
+    /**
+     * Sets the active drawing color. If not set, the foreground color from style is used.
+     */
+    setColor(color: Color): void;
+    /**
+     * Clears the entire canvas.
+     */
+    clear(): void;
+    /**
+     * Sets a single sub-cell pixel.
+     */
+    setPixel(x: number, y: number, value?: boolean): void;
+    /**
+     * Fills a rectangle with the current drawing state.
+     */
+    fillRect(x: number, y: number, w: number, h: number): void;
+    /**
+     * Draws an unfilled circle.
+     */
+    drawCircle(cx: number, cy: number, r: number): void;
+    /**
+     * Draws a line from (x0, y0) to (x1, y1).
+     */
+    lineTo(x0: number, y0: number, x1: number, y1: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface RatingOptions {
+    value?: number;
+    max?: number;
+    showLabel?: boolean;
+}
+/**
+ * Rating - displays a star rating with optional textual feedback.
+ */
+declare class Rating extends Widget {
+    private _value;
+    private _max;
+    private _showLabel;
+    constructor(style?: Partial<Style>, opts?: RatingOptions);
+    getValue(): number;
+    getMax(): number;
+    setValue(value: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface PtyOptions {
+    /** The command to spawn */
+    command?: string;
+    /** Arguments to the command */
+    args?: string[];
+}
+/**
+ * Pty — Terminal Multiplexer widget.
+ * Spawns a child process and renders its output inside the TermUI screen.
+ */
+declare class Pty extends Widget {
+    private _process;
+    private _lines;
+    private _autoScroll;
+    constructor(style?: Partial<Style>, opts?: PtyOptions);
+    private _handleOutput;
+    handleKey(event: KeyEvent): boolean;
+    protected _renderSelf(screen: Screen): void;
+    /**
+     * Terminate the spawned process
+     */
+    destroy(): void;
+}
+
 interface ScrollRange {
     start: number;
     end: number;
@@ -478,11 +611,46 @@ declare function computeRange(scrollOffset: number, viewportItems: number, itemC
  */
 declare function computeVariableRange(scrollPx: number, viewportPx: number, sizes: number[], overscan?: number): ScrollRange;
 
-interface ListItem {
+/**
+ * External state object for List widget.
+ * It owns the items, selected index and scroll offset.
+ * The hook returns the same mutable object that can be passed to <List state={s} />.
+ */
+interface ListState {
+    /** The items displayed by the list */
+    items: ListItem$1[];
+    /** Index of the currently selected item */
+    selectedIndex: number;
+    /** Scroll offset (first visible item index) */
+    scrollOffset: number;
+    /** Update items */
+    setItems(items: ListItem$1[]): void;
+    /** Move selection up */
+    selectPrev(): void;
+    /** Move selection down */
+    selectNext(): void;
+    /** Confirm current selection (optional hook) */
+    confirm(): void;
+}
+/** Hook that creates a fresh ListState. */
+declare function useListState(initial: {
+    items: ListItem$1[];
+}): ListState;
+
+interface ListItem$1 {
     label: string;
     value: string;
     disabled?: boolean;
 }
+interface ListProps {
+    items?: ListItem$1[];
+    style?: Partial<Style>;
+    onSelect?: (item: ListItem$1, index: number) => void;
+    /** External state object – if provided, List reads/writes selection through it */
+    state?: ListState;
+    /** Called whenever selection or scroll changes */
+    onStateChange?: (state: ListState) => void;
+}
 /**
  * List — a scrollable, selectable list of items.
  *
@@ -491,74 +659,30 @@ interface ListItem {
  * - Scrolling when items exceed visible height
  * - Custom item styling
  * - Disabled items
+ * - External state via `state` prop and `useListState` hook
  */
 declare class List extends Widget {
     private _items;
     private _selectedIndex;
     private _scrollOffset;
     private _onSelect?;
-    constructor(items: ListItem[], style?: Partial<Style>, onSelect?: (item: ListItem, index: number) => void);
+    private _state?;
+    private _onStateChange?;
+    constructor(itemsOrProps: ListItem$1[] | ListProps, style?: Partial<Style>, onSelect?: (item: ListItem$1, index: number) => void);
     get selectedIndex(): number;
-    get selectedItem(): ListItem | undefined;
-    setItems(items: ListItem[]): void;
+    get selectedItem(): ListItem$1 | undefined;
+    setItems(items: ListItem$1[]): void;
     /** Move selection up */
     selectPrev(): void;
     /** Move selection down */
     selectNext(): void;
     /** Confirm the current selection */
     confirm(): void;
+    private _pushState;
     protected _renderSelf(screen: Screen): void;
     private _clampScroll;
 }
 
-/**
- * TextInput — a single-line text input field.
- *
- * Supports:
- * - Cursor movement (left/right/Home/End)
- * - Character insertion and deletion
- * - Placeholder text
- * - Password masking
- * - Max length constraint
- */
-declare class TextInput extends Widget {
-    private _value;
-    private _cursorPos;
-    private _placeholder;
-    private _mask;
-    private _maxLength;
-    private _onChange?;
-    private _onSubmit?;
-    constructor(style?: Partial<Style>, options?: {
-        placeholder?: string;
-        mask?: string;
-        maxLength?: number;
-        onChange?: (value: string) => void;
-        onSubmit?: (value: string) => void;
-    });
-    get value(): string;
-    set value(v: string);
-    /**
-     * Handle a typed character.
-     */
-    insertChar(char: string): void;
-    /**
-     * Delete the character before the cursor.
-     */
-    deleteBack(): void;
-    /**
-     * Delete the character after the cursor.
-     */
-    deleteForward(): void;
-    moveCursorLeft(): void;
-    moveCursorRight(): void;
-    moveCursorHome(): void;
-    moveCursorEnd(): void;
-    submit(): void;
-    clear(): void;
-    protected _renderSelf(screen: Screen): void;
-}
-
 interface VirtualListOptions {
     /** Total number of items (the full dataset size) */
     totalItems: number;
@@ -668,6 +792,8 @@ declare class CommandPalette extends Widget {
     open(): void;
     /** Current query string. */
     getQuery(): string;
+    /** Compute a fuzzy-match score for a single text against a query. */
+    private _fuzzyScore;
     /** Filter commands based on current query (case-insensitive substring). */
     private _filter;
     private _executeSelected;
@@ -677,747 +803,2753 @@ declare class CommandPalette extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
-interface TableColumn {
-    /** Column header label */
-    header: string;
-    /** Key to pull data from row objects */
-    key: string;
-    /** Fixed width (chars). If omitted, auto-distributes. */
-    width?: number;
-    /** Text alignment within the column */
-    align?: 'left' | 'center' | 'right';
-}
-type TableRow = Record<string, string | number>;
-interface TableOptions {
-    /** Whether to show the header row */
-    showHeader?: boolean;
-    /** Color for the header row */
-    headerColor?: Color;
-    /** Whether rows are zebra-striped */
-    stripe?: boolean;
-    /** Stripe color */
-    stripeColor?: Color;
-    /** Column separator character */
-    separator?: string;
+type ButtonVariant = 'default' | 'primary' | 'danger' | 'ghost';
+interface ButtonOptions {
+    variant?: ButtonVariant;
+    disabled?: boolean;
+    onPress?: () => void;
+    color?: Color;
 }
 /**
- * Table — renders tabular data with columns, headers, and optional zebra-striping.
+ * Button — a pressable button with a label and visual variants.
  *
- * Supports:
- * - Auto-width column distribution
- * - Fixed and percentage widths
- * - Header styling
- * - Zebra striping
- * - Text alignment per column
- * - Truncation for overflow
+ * Renders a button with different visual styles based on variant.
+ * Handles key events for activation when not disabled.
  */
-declare class Table extends Widget {
-    private _columns;
-    private _rows;
-    private _showHeader;
-    private _headerColor;
-    private _stripe;
-    private _stripeColor;
-    private _separator;
-    constructor(columns: TableColumn[], rows: TableRow[], style?: Partial<Style>, options?: TableOptions);
-    setRows(rows: TableRow[]): void;
+declare class Button extends Widget {
+    private _label;
+    private _variant;
+    private _disabled;
+    private _onPress?;
+    private _color?;
+    constructor(label: string, style?: Partial<Style>, opts?: ButtonOptions);
+    setLabel(label: string): void;
+    setDisabled(disabled: boolean): void;
+    handleKey(event: KeyEvent): void;
     protected _renderSelf(screen: Screen): void;
-    private _computeColumnWidths;
-    private _alignText;
 }
 
-interface GaugeOptions {
-    /** Color of the filled portion */
+interface SliderOptions {
+    min?: number;
+    max?: number;
+    step?: number;
     color?: Color;
-    /** Show percentage label */
-    showLabel?: boolean;
+    showValue?: boolean;
 }
-/**
- * Gauge — a self-contained metric display with label, bar, and value.
- *
- * Example:
- *   CPU ████████░░░░ 65%
- */
-declare class Gauge extends Widget {
+declare class Slider extends Widget {
     private _label;
     private _value;
+    private _min;
+    private _max;
+    private _step;
     private _color;
-    private _showLabel;
-    constructor(label: string, style?: Partial<Style>, opts?: GaugeOptions);
-    setValue(value: number): void;
+    private _showValue;
+    constructor(label: string, style?: Partial<Style>, opts?: SliderOptions);
     getValue(): number;
+    setValue(value: number): void;
     setLabel(label: string): void;
+    handleKey(event: KeyEvent): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface SparklineOptions {
-    /** Color of the sparkline */
+interface RangeInputOptions {
+    min?: number;
+    max?: number;
+    step?: number;
     color?: Color;
-    /** Show min/max labels */
-    showRange?: boolean;
+    showValue?: boolean;
+    onChange?: (low: number, high: number) => void;
 }
-/**
- * Sparkline — a compact inline chart showing a data trend.
- *
- * Example:
- *   Latency ▂▃▅▇▅▃▂▁▃▅█▅▃
- */
-declare class Sparkline extends Widget {
+declare class RangeInput extends Widget {
     private _label;
-    private _data;
+    private _min;
+    private _max;
+    private _step;
     private _color;
-    private _showRange;
-    constructor(label: string, style?: Partial<Style>, opts?: SparklineOptions);
-    setData(data: number[]): void;
-    pushValue(value: number): void;
+    private _showValue;
+    private _activeHandle;
+    private _low;
+    private _high;
+    private _onChange?;
+    constructor(label: string, style?: Partial<Style>, opts?: RangeInputOptions);
+    getLow(): number;
+    getHigh(): number;
+    setLow(value: number): void;
+    setHigh(value: number): void;
+    setRange(low: number, high: number): void;
+    handleKey(event: KeyEvent): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface StatusIndicatorOptions {
-    /** Color when up/active */
-    upColor?: Color;
-    /** Color when down/inactive */
-    downColor?: Color;
-}
 /**
- * StatusIndicator — simple up/down indicator with label.
+ * TextInput — a single-line text input field.
  *
- * Example:
- *   ● API Server — Online
- *   ○ Worker — Offline
+ * Supports:
+ * - Cursor movement (left/right/Home/End)
+ * - Character insertion and deletion
+ * - Placeholder text
+ * - Password masking
+ * - Max length constraint
  */
-declare class StatusIndicator extends Widget {
-    private _label;
-    private _isUp;
-    private _upColor;
-    private _downColor;
-    constructor(label: string, isUp: boolean, style?: Partial<Style>, opts?: StatusIndicatorOptions);
-    setStatus(isUp: boolean): void;
-    getStatus(): boolean;
-    setLabel(label: string): void;
-    protected _renderSelf(screen: Screen): void;
-}
-
-interface Bar {
-    value: number;
-    label?: string;
-    color?: Color;
-}
-interface BarGroup {
-    label?: string;
-    bars: Bar[];
-}
-type BarChartDirection = 'vertical' | 'horizontal';
-interface BarChartOptions {
-    /** Direction bars grow. Default: 'vertical'. */
-    direction?: BarChartDirection;
-    /** Width of each bar in cells. Default: 1. */
-    barWidth?: number;
-    /** Gap between bars in a group. Default: 1. */
-    barGap?: number;
-    /** Gap between groups. Default: 2. */
-    groupGap?: number;
-    /** Max value for scaling. Auto-detected if not set. */
-    max?: number;
-    /** Color for bars without a per-bar color. */
-    barColor?: Color;
-    /** Color for value labels. */
-    valueColor?: Color;
-    /** Color for text labels. */
-    labelColor?: Color;
-}
-declare class BarChart extends Widget {
-    private _data;
+declare class TextInput extends Widget {
+    private _value;
+    private _cursorPos;
+    private _placeholder;
+    private _mask;
+    private _maxLength;
+    private _onChange?;
+    private _onSubmit?;
+    constructor(style?: Partial<Style>, options?: {
+        placeholder?: string;
+        mask?: string;
+        maxLength?: number;
+        onChange?: (value: string) => void;
+        onSubmit?: (value: string) => void;
+    });
+    get value(): string;
+    set value(v: string);
+    /**
+     * Handle keyboard events when the widget is focused.
+     */
+    handleKey(event: KeyEvent): void;
+    /**
+     * Handle a typed character.
+     */
+    insertChar(char: string): void;
+    /**
+     * Delete the character before the cursor.
+     */
+    deleteBack(): void;
+    /**
+     * Delete the character after the cursor.
+     */
+    deleteForward(): void;
+    moveCursorLeft(): void;
+    moveCursorRight(): void;
+    moveCursorHome(): void;
+    moveCursorEnd(): void;
+    submit(): void;
+    clear(): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface KnobOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    color?: Color;
+    showValue?: boolean;
+    onChange?: (value: number) => void;
+}
+declare class Knob extends Widget {
+    private _label;
+    private _value;
+    private _min;
+    private _max;
+    private _step;
+    private _color;
+    private _showValue;
+    private _onChange?;
+    constructor(label?: string, style?: Partial<Style>, opts?: KnobOptions);
+    get value(): number;
+    setValue(value: number): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface PinInputOptions {
+    length?: number;
+    masked?: boolean;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+}
+declare class PinInput extends Widget {
+    private _length;
+    private _masked;
+    private _value;
+    private _cursorPos;
+    private _onChange?;
+    private _onComplete?;
+    /**
+     * Creates a new PinInput widget.
+     *
+     * @param style Partial style properties for the widget.
+     * @param opts Configuration options for the PinInput.
+     */
+    constructor(style?: Partial<Style>, opts?: PinInputOptions);
+    get value(): string;
+    private get _isFull();
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ContextMenuItem {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+/**
+ * ContextMenu — a floating menu widget positioned at absolute coordinates.
+ *
+ * Supports:
+ * - Keyboard navigation (up/down arrows)
+ * - Selection confirmation (Enter)
+ * - Menu dismissal (Escape)
+ * - Callback on item selection
+ * - Disabled items
+ * - Safe ASCII fallback for unicode icons
+ */
+declare class ContextMenu extends Widget {
+    private _items;
+    private _selectedIndex;
+    private _x;
+    private _y;
+    private _onItemSelect?;
+    private _onClose?;
+    constructor(items: ContextMenuItem[], x: number, y: number, style?: Partial<Style>, callbacks?: {
+        onItemSelect?: (item: ContextMenuItem, index: number) => void;
+        onClose?: () => void;
+    });
+    /**
+     * Update the internal rect based on position and items count.
+     * ContextMenu is typically 1-2 characters wider than the longest item label,
+     * and height matches the number of items.
+     */
+    private _updateRect;
+    get selectedIndex(): number;
+    get selectedItem(): ContextMenuItem | undefined;
+    /**
+     * Move selection up
+     */
+    selectPrev(): void;
+    /**
+     * Move selection down
+     */
+    selectNext(): void;
+    /**
+     * Confirm the current selection
+     */
+    confirm(): void;
+    /**
+     * Close the context menu
+     */
+    close(): void;
+    /**
+     * Move the context menu to a new position
+     */
+    moveTo(x: number, y: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+/** External state object for Table widget. */
+interface TableState {
+    /** Rows displayed by the table */
+    rows: TableRow[];
+    /** Scroll offset (first visible row index) */
+    scrollOffset: number;
+    /** Update rows */
+    setRows(rows: TableRow[]): void;
+    /** Scroll up */
+    scrollPrev(): void;
+    /** Scroll down */
+    scrollNext(): void;
+}
+/** Hook that creates a fresh TableState. */
+declare function useTableState(initial: {
+    rows: TableRow[];
+}): TableState;
+
+interface TableColumn {
+    /** Column header label */
+    header: string;
+    /** Key to pull data from row objects */
+    key: string;
+    /** Fixed width (chars). If omitted, auto-distributes. */
+    width?: number;
+    /** Text alignment within the column */
+    align?: 'left' | 'center' | 'right';
+}
+type TableRow = Record<string, string | number>;
+interface TableOptions {
+    /** Whether to show the header row */
+    showHeader?: boolean;
+    /** Color for the header row */
+    headerColor?: Color;
+    /** Whether rows are zebra-striped */
+    stripe?: boolean;
+    /** Stripe color */
+    stripeColor?: Color;
+    /** Column separator character */
+    separator?: string;
+}
+interface TableProps {
+    columns: TableColumn[];
+    rows?: TableRow[];
+    style?: Partial<Style>;
+    options?: TableOptions;
+    /** External state object – if provided, Table syncs rows through it */
+    state?: TableState;
+    /** Called whenever rows change via setRows */
+    onStateChange?: (state: TableState) => void;
+}
+/**
+ * Table — renders tabular data with columns, headers, and optional zebra-striping.
+ *
+ * Supports:
+ * - Auto-width column distribution
+ * - Fixed and percentage widths
+ * - Header styling
+ * - Zebra striping
+ * - Text alignment per column
+ * - Truncation for overflow
+ * - External state via `state` prop and `useTableState` hook
+ */
+declare class Table extends Widget {
+    protected _columns: TableColumn[];
+    protected _rows: TableRow[];
+    protected _showHeader: boolean;
+    protected _headerColor: Color;
+    protected _stripe: boolean;
+    protected _stripeColor: Color;
+    protected _separator: string;
+    private _state?;
+    private _onStateChange?;
+    private _selectedRow;
+    private _sortColumn;
+    constructor(columnsOrProps: TableColumn[] | TableProps, rows?: TableRow[], style?: Partial<Style>, options?: TableOptions);
+    setRows(rows: TableRow[]): void;
+    sortByColumn(columnKey: string): void;
+    private _pushState;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+    protected _computeColumnWidths(totalWidth: number): number[];
+    protected _alignText(text: string, width: number, align: 'left' | 'center' | 'right'): string;
+}
+
+interface TreeTableColumn {
+    /** Column header label */
+    header: string;
+    /** Key to pull data from row objects */
+    key: string;
+    /** Fixed width (chars). If omitted, auto-distributes. */
+    width?: number;
+    /** Text alignment within the column */
+    align?: 'left' | 'center' | 'right';
+}
+interface TreeTableRow {
+    children?: TreeTableRow[];
+    expanded?: boolean;
+    [key: string]: unknown;
+}
+interface TreeTableOptions {
+    /** Whether to show the header row */
+    showHeader?: boolean;
+    /** Color for the header row */
+    headerColor?: Color;
+    /** Whether rows are zebra-striped */
+    stripe?: boolean;
+    /** Stripe color */
+    stripeColor?: Color;
+    /** Column separator character */
+    separator?: string;
+    /** Indentation per depth (default 2) */
+    indent?: number;
+    /** Callback when a row is selected */
+    onSelect?: (row: TreeTableRow) => void;
+}
+interface VisibleEntry {
+    row: TreeTableRow;
+    depth: number;
+}
+/**
+ * TreeTable — combines Tree expand/collapse with Table columns.
+ *
+ * Supports:
+ * - Nested rows with column alignment
+ * - Expand/collapse with arrows or Enter
+ * - Keyboard navigation
+ * - Unicode and ASCII symbols
+ * - Zebra striping
+ * - Header styling
+ */
+declare class TreeTable extends Widget {
+    private _columns;
+    private _rows;
+    private _showHeader;
+    private _headerColor;
+    private _stripe;
+    private _stripeColor;
+    private _separator;
+    private _indent;
+    private _onSelect?;
+    protected _selectedIndex: number;
+    protected _scrollOffset: number;
+    protected _visibleRows: VisibleEntry[];
+    constructor(columns: TreeTableColumn[], rows: TreeTableRow[], style?: Partial<Style>, options?: TreeTableOptions);
+    get selectedIndex(): number;
+    get selectedRow(): TreeTableRow | undefined;
+    setRows(rows: TreeTableRow[]): void;
+    /** Move cursor up one visible row */
+    movePrev(): void;
+    /** Move cursor down one visible row */
+    moveNext(): void;
+    /** Go to first visible row */
+    moveFirst(): void;
+    /** Go to last visible row */
+    moveLast(): void;
+    /** Expand the selected row (if it has children and is collapsed) */
+    expand(): void;
+    /** Collapse the selected row, or move to parent if already collapsed/leaf */
+    collapse(): void;
+    /** Toggle expand/collapse */
+    toggle(): void;
+    /**
+     * Handle a key event. Call this from your app's key-routing logic
+     * when this widget is focused.
+     */
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+    private _computeColumnWidths;
+    private _alignText;
+    private _buildVisibleRows;
+    private _clampScroll;
+}
+
+interface GaugeOptions {
+    /** Color of the filled portion */
+    color?: Color;
+    /** Show percentage label */
+    showLabel?: boolean;
+}
+/**
+ * Gauge — a self-contained metric display with label, bar, and value.
+ *
+ * Example:
+ *   CPU ████████░░░░ 65%
+ */
+declare class Gauge extends Widget {
+    private _label;
+    private _value;
+    private _color;
+    private _showLabel;
+    constructor(label: string, style?: Partial<Style>, opts?: GaugeOptions);
+    setValue(value: number): void;
+    getValue(): number;
+    setLabel(label: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface LineGaugeOptions {
+    /** Filled portion character. Default: '━' with ASCII fallback '=' */
+    filledChar?: string;
+    /** Empty portion character. Default: '─' with ASCII fallback '-' */
+    emptyChar?: string;
+    /** Show percentage label at right. Default: true */
+    showLabel?: boolean;
+    fillColor?: Color;
+    emptyColor?: Color;
+}
+declare class LineGauge extends Widget {
+    private _value;
+    private _filledChar;
+    private _emptyChar;
+    private _showLabel;
+    private _fillColor?;
+    private _emptyColor?;
+    constructor(style?: Partial<Style>, opts?: LineGaugeOptions);
+    setValue(value: number): void;
+    getValue(): number;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface CalendarOptions {
+    date?: Date;
+    selectedColor?: Color;
+    todayColor?: Color;
+    onSelect?: (date: Date) => void;
+}
+declare class Calendar extends Widget {
+    private _selectedDate;
+    private _currentMonth;
+    private _selectedColor;
+    private _todayColor;
+    private _onSelect?;
+    focusable: boolean;
+    constructor(style?: Partial<Style>, opts?: CalendarOptions);
+    setMonth(year: number, month: number): void;
+    getSelectedDate(): Date;
+    handleKey(event: KeyEvent): void;
+    private _moveSelection;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SparklineOptions {
+    /** Color of the sparkline */
+    color?: Color;
+    /** Show min/max labels */
+    showRange?: boolean;
+    /** Rendering style */
+    marker?: 'block' | 'braille';
+}
+/**
+ * Sparkline — a compact inline chart showing a data trend.
+ *
+ * Example:
+ *   Latency ▂▃▅▇▅▃▂▁▃▅█▅▃
+ */
+declare class Sparkline extends Widget {
+    private _label;
+    private _data;
+    private _color;
+    private _showRange;
+    private _marker;
+    constructor(label: string, style?: Partial<Style>, opts?: SparklineOptions);
+    setData(data: number[]): void;
+    pushValue(value: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface StatusIndicatorOptions {
+    /** Color when up/active */
+    upColor?: Color;
+    /** Color when down/inactive */
+    downColor?: Color;
+}
+/**
+ * StatusIndicator — simple up/down indicator with label.
+ *
+ * Example:
+ *   ● API Server — Online
+ *   ○ Worker — Offline
+ */
+declare class StatusIndicator extends Widget {
+    private _label;
+    private _isUp;
+    private _upColor;
+    private _downColor;
+    constructor(label: string, isUp: boolean, style?: Partial<Style>, opts?: StatusIndicatorOptions);
+    setStatus(isUp: boolean): void;
+    getStatus(): boolean;
+    setLabel(label: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface Bar {
+    value: number;
+    label?: string;
+    color?: Color;
+}
+interface BarGroup {
+    label?: string;
+    bars: Bar[];
+}
+type BarChartDirection = 'vertical' | 'horizontal';
+interface BarChartOptions {
+    /** Direction bars grow. Default: 'vertical'. */
+    direction?: BarChartDirection;
+    /** Width of each bar in cells. Default: 1. */
+    barWidth?: number;
+    /** Gap between bars in a group. Default: 1. */
+    barGap?: number;
+    /** Gap between groups. Default: 2. */
+    groupGap?: number;
+    /** Max value for scaling. Auto-detected if not set. */
+    max?: number;
+    /** Color for bars without a per-bar color. */
+    barColor?: Color;
+    /** Color for value labels. */
+    valueColor?: Color;
+    /** Color for text labels. */
+    labelColor?: Color;
+}
+declare class BarChart extends Widget {
+    private _data;
     private _direction;
     private _barWidth;
     private _barGap;
     private _groupGap;
     private _max?;
-    private _barColor;
+    private _barColor;
+    private _valueColor;
+    private _labelColor;
+    constructor(data: BarGroup[], style?: Partial<Style>, opts?: BarChartOptions);
+    setData(data: BarGroup[]): void;
+    setMax(max: number | undefined): void;
+    protected _renderSelf(screen: Screen): void;
+    private _computeMax;
+    private _renderVertical;
+    private _renderHorizontal;
+}
+
+interface HistogramOptions {
+    bins?: number;
+    barColor?: Color;
+    xLabel?: string;
+}
+declare class Histogram extends Widget {
+    private _values;
+    private _bins;
+    private _barColor;
+    private _xLabel?;
+    constructor(style?: Partial<Style>, opts?: HistogramOptions);
+    setData(values: number[]): void;
+    protected _renderSelf(screen: Screen): void;
+    private _computeBins;
+}
+
+interface StackedSeries {
+    label: string;
+    data: number[];
+    color?: Color;
+}
+interface StackedBarChartOptions {
+    categories?: string[];
+    barWidth?: number;
+}
+declare class StackedBarChart extends Widget {
+    private _series;
+    private _categories;
+    private _barWidth;
+    constructor(style?: Partial<Style>, opts?: StackedBarChartOptions);
+    setSeries(series: StackedSeries[]): void;
+    protected _renderSelf(screen: Screen): void;
+    private _categoryCount;
+    private _totals;
+    private _renderBraille;
+    private _renderAscii;
+    private _renderLabels;
+}
+
+interface GanttTask {
+    label?: string;
+    start: number;
+    duration: number;
+    color?: Color;
+}
+interface GanttChartOptions {
+    taskHeight?: number;
+    taskGap?: number;
+    minTime?: number;
+    maxTime?: number;
+    barColor?: Color;
+    labelColor?: Color;
+}
+declare class GanttChart extends Widget {
+    private _tasks;
+    private _taskHeight;
+    private _taskGap;
+    private _minTime?;
+    private _maxTime?;
+    private _barColor;
+    private _labelColor;
+    constructor(tasks: GanttTask[], style?: Partial<Style>, opts?: GanttChartOptions);
+    setTasks(tasks: GanttTask[]): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface GridOptions {
+    /** Number of equal-width columns */
+    columns: number;
+    /** Gap between items in both directions (default: 1) */
+    gap?: number;
+    /** Row gap override (overrides gap for rows) */
+    rowGap?: number;
+    /** Column gap override (overrides gap for columns) */
+    colGap?: number;
+}
+/**
+ * Grid — a CSS-Grid-like layout widget.
+ *
+ * Items fill left-to-right, wrapping to a new row every `columns` items.
+ * Internally creates a column-flex Box per row, each with equal-flex-grow items.
+ *
+ * The `addChild()` override means the reconciler's generic child-adding
+ * loop works without any special casing.
+ */
+declare class Grid extends Widget {
+    private _columns;
+    private _colGap;
+    private _rowGap;
+    private _rows;
+    private _itemCount;
+    constructor(style: Partial<Style>, options: GridOptions);
+    protected _renderSelf(_screen: Screen): void;
+    /**
+     * Add a widget to the grid. Items fill left-to-right,
+     * wrapping to a new row automatically every `columns` items.
+     * Overrides Widget.addChild so the reconciler generic loop works unchanged.
+     */
+    addChild(widget: Widget): void;
+    /** Add an item explicitly (alias for addChild) */
+    addItem(widget: Widget): void;
+    /** Remove all items and reset the grid */
+    clearItems(): void;
+}
+
+interface ScrollViewOptions {
+    /** Total height of content in rows */
+    contentHeight?: number;
+    /** Show scrollbar indicator on right edge */
+    showScrollbar?: boolean;
+    /** Whether to use scroll acceleration */
+    scrollAccel?: boolean;
+}
+/**
+ * ScrollView — a height-bounded scrollable container.
+ *
+ * Children are rendered with a vertical offset applied (scrolling).
+ * Responds to up/down arrow keys and Page Up/Page Down.
+ */
+declare class ScrollView extends Widget {
+    private _scrollOffset;
+    private _contentHeight;
+    private _showScrollbar;
+    private _scrollAccel;
+    private _acceleration;
+    constructor(style?: Partial<Style>, opts?: ScrollViewOptions);
+    /** Set the total content height (in rows) */
+    setContentHeight(h: number): void;
+    /** Get current scroll offset */
+    get scrollOffset(): number;
+    /** Scroll by delta rows */
+    scrollBy(delta: number): void;
+    /** Scroll to absolute offset */
+    scrollTo(offset: number): void;
+    private _clampOffset;
+    private getScrollDelta;
+    /** Handle keyboard navigation */
+    handleKey(event: KeyEvent): void;
+    render(screen: Screen): void;
+    private _renderScrollbar;
+    protected _renderSelf(_screen: Screen): void;
+}
+
+interface CenterOptions {
+    /** Center horizontally (default: true) */
+    horizontal?: boolean;
+    /** Center vertically (default: true) */
+    vertical?: boolean;
+}
+/**
+ * Center — centers a single child widget horizontally and/or vertically.
+ *
+ * Computes centering offsets at render time from the child's measured size.
+ */
+declare class Center extends Widget {
+    private _horizontal;
+    private _vertical;
+    constructor(style?: Partial<Style>, opts?: CenterOptions);
+    protected _renderSelf(_screen: Screen): void;
+    render(screen: Screen): void;
+}
+
+interface CardOptions {
+    /** Optional title shown in the top border */
+    title?: string;
+    /** Color for the border and title */
+    borderColor?: Color;
+}
+/**
+ * Card — a bordered container with an optional title in the top border.
+ *
+ * Like a Box with border + padding, but supports embedding a title string
+ * directly in the top border line.
+ */
+declare class Card extends Widget {
+    private _title;
+    private _borderColor?;
+    constructor(style?: Partial<Style>, opts?: CardOptions);
+    setTitle(title: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface MasonryOptions {
+    /** Number of columns. Default: 2 */
+    columns?: number;
+    /** Vertical gap between items. Default: 0 */
+    gap?: number;
+}
+declare class Masonry extends Widget {
+    private _columns;
+    private _gap;
+    constructor(children: Widget[], style?: Partial<Style>, opts?: MasonryOptions);
+    setChildren(children: Widget[]): void;
+    syncLayout(): void;
+    protected _renderSelf(_screen: Screen): void;
+    private _layout;
+}
+
+interface ColumnsOptions {
+    /** Gap between columns in cells (default: 1) */
+    gap?: number;
+}
+/**
+ * Columns — splits available width evenly across child widgets.
+ *
+ * Children are laid out side-by-side with equal flex-grow.
+ * Internally uses a flex-row Box; the addChild override applies
+ * flexGrow:1 to each child so the reconciler's generic loop works.
+ */
+declare class Columns extends Widget {
+    private _inner;
+    constructor(style?: Partial<Style>, opts?: ColumnsOptions);
+    addChild(widget: Widget): void;
+    removeChild(widget: Widget): void;
+    clearChildren(): void;
+    protected _renderSelf(_screen: Screen): void;
+}
+
+type DockEdge = 'top' | 'right' | 'bottom' | 'left' | 'fill';
+interface DockItem {
+    widget: Widget;
+    edge: DockEdge;
+    size?: number;
+}
+interface DockOptions {
+    style?: Partial<Style>;
+}
+declare class Dock extends Widget {
+    private _items;
+    constructor(items: DockItem[], style?: Partial<Style>);
+    setItems(items: DockItem[]): void;
+    updateRect(rect: Rect): void;
+    protected _renderSelf(_screen: Screen): void;
+    render(screen: Screen): void;
+}
+
+type DividerOrientation = 'horizontal' | 'vertical';
+interface DividerOptions {
+    /** Direction of the divider line */
+    orientation?: DividerOrientation;
+    /** Optional centered label inside the line */
+    label?: string;
+    /** Character used to draw the line (overrides default) */
+    char?: string;
+    /** Color of the line */
+    color?: Color;
+}
+/**
+ * Divider — a horizontal or vertical separator line with optional label.
+ *
+ * Examples:
+ *   ──────────────── Stats ────────────────   (horizontal with label)
+ *   ────────────────────────────────────────  (horizontal)
+ *   │  (vertical, repeating down the height)
+ */
+declare class Divider extends Widget {
+    private _orientation;
+    private _label;
+    private _char;
+    private _color;
+    constructor(style?: Partial<Style>, opts?: DividerOptions);
+    setLabel(label: string): void;
+    setOrientation(orientation: DividerOrientation): void;
+    setChar(char: string): void;
+    setColor(color: Color): void;
+    protected _renderSelf(screen: Screen): void;
+    private _renderHorizontal;
+    private _renderVertical;
+}
+
+interface AspectRatioOptions {
+    /** Width:height ratio */
+    ratio?: number;
+    /** contain = fit inside, cover = fill */
+    fit?: 'contain' | 'cover';
+}
+declare class AspectRatio extends Widget {
+    private _ratio;
+    private _fit;
+    constructor(child: Widget, style?: Partial<Style>, opts?: AspectRatioOptions);
+    setChild(child: Widget): void;
+    protected _renderSelf(_screen: Screen): void;
+    render(screen: Screen): void;
+}
+
+interface FillOptions {
+    char?: string;
+    color?: Color;
+}
+declare class Fill extends Widget {
+    private _char;
+    private _color?;
+    constructor(style?: Partial<Style>, opts?: FillOptions);
+    setChar(char: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SplitPaneOptions {
+    /** Horizontal split ratio for the left pane (0–1, default: 0.5) */
+    ratio?: number;
+    /** Minimum width in cells for each pane (default: 1) */
+    minSize?: number;
+}
+/**
+ * SplitPane — two-pane horizontal layout with a draggable divider.
+ *
+ * The left pane occupies columns [0, leftWidth − 1], the divider sits at
+ * leftWidth, and the right pane occupies [leftWidth + 1, totalWidth − 1].
+ * Use shift+left / shift+right to resize when focused.
+ */
+declare class SplitPane extends Widget {
+    private _ratio;
+    private readonly _minSize;
+    constructor(left: Widget, right: Widget, style?: Partial<Style>, opts?: SplitPaneOptions);
+    getRatio(): number;
+    setRatio(ratio: number): void;
+    handleKey(event: KeyEvent): void;
+    syncLayout(): void;
+    protected _renderSelf(screen: Screen): void;
+    private _clampRatio;
+    private _positionChildren;
+}
+
+interface ProgressBarOptions {
+    /** Current value (0–1) */
+    value?: number;
+    /** Character for the filled portion */
+    fillChar?: string;
+    /** Character for the empty portion */
+    emptyChar?: string;
+    /** Color of the filled portion */
+    fillColor?: Color;
+    /** Show percentage label */
+    showLabel?: boolean;
+    /** Label format: 'percent' | 'fraction' | 'custom' */
+    labelFormat?: 'percent' | 'fraction';
+    /** Total for fraction display */
+    total?: number;
+}
+/**
+ * ProgressBar — horizontal progress indicator.
+ *
+ * Supports:
+ * - Configurable fill/empty characters
+ * - Custom fill color
+ * - Percentage or fraction label
+ * - Smooth animation-ready value changes
+ */
+declare class ProgressBar extends Widget {
+    private _value;
+    private _fillChar;
+    private _emptyChar;
+    private _fillColor;
+    private _showLabel;
+    private _labelFormat;
+    private _total;
+    constructor(style?: Partial<Style>, options?: ProgressBarOptions);
+    /** Set progress value (0–1) */
+    setValue(value: number): void;
+    get value(): number;
+    protected _renderSelf(screen: Screen): void;
+}
+
+/**
+ * A single progress item in MultiProgress
+ */
+interface ProgressItem {
+    label: string;
+    value: number;
+    color?: Color;
+}
+/**
+ * Options for MultiProgress widget
+ */
+interface MultiProgressOptions {
+    items: ProgressItem[];
+    labelWidth?: number;
+    showValues?: boolean;
+}
+/**
+ * MultiProgress — stacks multiple labeled progress bars in a vertical list.
+ *
+ * Each item renders on its own row with a label, bar, and optional percentage.
+ *
+ * Supports:
+ * - Multiple items with individual colors
+ * - Custom label column width
+ * - Optional percentage display
+ * - Smooth animation-ready value changes
+ */
+declare class MultiProgress extends Widget {
+    private _items;
+    private _labelWidth;
+    private _showValues;
+    constructor(options: MultiProgressOptions, style?: Partial<Style>);
+    /**
+     * Replace all items and mark dirty
+     */
+    setItems(items: ProgressItem[]): void;
+    /**
+     * Update a single item's value
+     */
+    updateItem(index: number, value: number): void;
+    /**
+     * Test-only getter for items array
+     * @internal
+     */
+    getItemsForTest(): ProgressItem[];
+    /**
+     * Test-only getter for labelWidth
+     * @internal
+     */
+    getLabelWidthForTest(): number;
+    /**
+     * Test-only getter for showValues
+     * @internal
+     */
+    getShowValuesForTest(): boolean;
+    /**
+     * Test-only getter for style height
+     * @internal
+     */
+    getHeightForTest(): number;
+    /**
+     * Test-only setter for dirty state
+     * @internal
+     */
+    setDirtyForTest(value: boolean): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+/**
+ * Built-in spinner frame sets.
+ */
+declare const SPINNER_FRAMES: Record<string, {
+    frames: string[];
+    asciiFrames: string[];
+    interval: number;
+}>;
+interface SpinnerOptions {
+    /** Spinner preset name or custom frames */
+    spinner?: string | {
+        frames: string[];
+        interval: number;
+    };
+    /** Spinner preset name (preferred option) */
+    preset?: string;
+    /** Text label displayed after the spinner */
+    label?: string;
+    /** Color for the spinner frames */
+    color?: Color;
+    /** Whether the spinner is active/animating (default: true) */
+    active?: boolean;
+    /** Text to display when active is false (e.g., '✓ Done') */
+    doneText?: string;
+    /** Custom frame interval in milliseconds */
+    interval?: number;
+}
+/**
+ * Spinner — animated loading indicator.
+ *
+ * Supports:
+ * - 10 built-in spinner presets
+ * - Custom frame sequences
+ * - Configurable color and label
+ * - Active state control and custom done state text
+ * - Automatic frame advancement with system-clock smoothness
+ * - ASCII fallbacks and no-motion environment support
+ */
+declare class Spinner extends Widget {
+    private _frames;
+    private _interval;
+    private _frameIndex;
+    private _label;
+    private _color;
+    private _elapsed;
+    private _timerUnsub?;
+    private _active;
+    private _doneText?;
+    private _startTime?;
+    constructor(style?: Partial<Style>, options?: SpinnerOptions);
+    /** Update the active state */
+    setActive(active: boolean): void;
+    /** Update the spinner label */
+    setLabel(label: string): void;
+    /** Update doneText */
+    setDoneText(doneText: string): void;
+    /**
+     * Advance the spinner frame based on elapsed time.
+     * Call this with a delta (ms) from the render loop.
+     */
+    tick(deltaMs: number): void;
+    /** Lifecycle: start the frame-advance timer (only when motion is enabled). */
+    mount(): void;
+    /** Lifecycle: stop the frame-advance timer. */
+    unmount(): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface LoadingDotsOptions {
+    /** Label shown before the dots. */
+    label?: string;
+    /** Maximum number of dots in the cycle. Default: 3 */
+    maxDots?: number;
+    /** Dot color. Default: cyan */
+    color?: Color;
+}
+declare class LoadingDots extends Widget {
+    private _label;
+    private _maxDots;
+    private _color;
+    private _dotCount;
+    constructor(style?: Partial<Style>, opts?: LoadingDotsOptions);
+    tick(): void;
+    setLabel(label: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type TaskStatus = 'pending' | 'running' | 'done' | 'error';
+interface TaskItem {
+    id: string | number;
+    label: string;
+    status: TaskStatus;
+}
+interface TaskListOptions {
+    pendingText?: string;
+    runningText?: string;
+    doneText?: string;
+    errorText?: string;
+    /** When true, the running indicator animates with a spinner. */
+    wheelspin?: boolean;
+}
+/**
+ * TaskList — a vertical list of tasks with status indicators.
+ *
+ * Each task renders on its own row:
+ *   Build      ⠋        ← running + wheelspin + unicode
+ *   Lint       ...      ← pending (default pendingText)
+ *   Tests      ✓        ← done (custom doneText)
+ *   Deploy     ✗        ← error (custom errorText)
+ */
+declare class TaskList extends Widget {
+    private _tasks;
+    private _pendingText;
+    private _runningText;
+    private _doneText;
+    private _errorText;
+    private _wheelspin;
+    private _frameIndex;
+    private _elapsed;
+    constructor(style?: Partial<Style>, options?: TaskListOptions, tasks?: TaskItem[]);
+    /** Replace the task list and schedule a re-render. */
+    setTasks(tasks: TaskItem[]): void;
+    /**
+     * Advance the spinner animation by `dt` milliseconds.
+     * Only has an effect when `wheelspin` is enabled and there is at least
+     * one running task. Call this from the app's render/tick loop.
+     */
+    tick(dt: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type ScrollbarOrientation = 'verticalRight' | 'verticalLeft' | 'horizontalBottom' | 'horizontalTop';
+interface ScrollbarOptions {
+    /** Total number of content items. */
+    contentLength: number;
+    /** Number of items visible in the viewport. */
+    viewportLength: number;
+    /** Current scroll position (0-based). */
+    position?: number;
+    /** Scrollbar orientation. Default: 'verticalRight'. */
+    orientation?: ScrollbarOrientation;
+    /** Color of the thumb. */
+    thumbColor?: Color;
+    /** Color of the track. */
+    trackColor?: Color;
+    /** Show begin/end arrow symbols. Default: true. */
+    showArrows?: boolean;
+}
+declare class Scrollbar extends Widget {
+    private _contentLength;
+    private _viewportLength;
+    private _position;
+    private _orientation;
+    private _thumbColor;
+    private _trackColor;
+    private _showArrows;
+    constructor(style: Partial<Style> | undefined, opts: ScrollbarOptions);
+    setPosition(position: number): void;
+    setContentLength(length: number): void;
+    setViewportLength(length: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SkeletonOptions {
+    variant?: 'pulse' | 'shimmer';
+    intervalMs?: number;
+    chars?: [string, string];
+    color?: Color;
+}
+declare class Skeleton extends Widget {
+    private _frame;
+    private _shimmerPos;
+    private _variant;
+    private _chars;
+    private _intervalMs;
+    private _unsubscribe?;
+    constructor(style?: Partial<Style>, opts?: SkeletonOptions);
+    unmount(): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type StatusVariant = 'success' | 'error' | 'warning' | 'info';
+interface StatusMessageOptions {
+    /** Variant determines icon and color */
+    variant?: StatusVariant;
+    /** Override the icon character */
+    icon?: string;
+}
+/**
+ * StatusMessage — a single-line status indicator.
+ *
+ * Renders an icon (✓/✗/⚠/ℹ) followed by a message, colored by variant.
+ */
+declare class StatusMessage extends Widget {
+    private _message;
+    private _variant;
+    private _icon?;
+    constructor(message: string, style?: Partial<Style>, opts?: StatusMessageOptions);
+    setMessage(message: string): void;
+    setVariant(variant: StatusVariant): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface BannerOptions {
+    /** Variant determines border color */
+    variant?: StatusVariant;
+    /** Title displayed on first line in bold */
+    title?: string;
+    /** Body text */
+    body?: string;
+}
+/**
+ * Banner — full-width alert with title and body text.
+ *
+ * Shows a bordered box with a bold title line and body text,
+ * colored according to variant. The border is drawn manually
+ * to use the variant color.
+ */
+declare class Banner extends Widget {
+    private _variant;
+    private _title;
+    private _body;
+    constructor(style?: Partial<Style>, opts?: BannerOptions);
+    setTitle(title: string): void;
+    setBody(body: string): void;
+    setVariant(variant: StatusVariant): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface AlertOptions {
+    /** Variant determines icon and border color */
+    variant?: StatusVariant;
+    /** The message to display */
+    message: string;
+}
+/**
+ * Alert — full-width status message box with a colored border and an icon prefix.
+ *
+ * Renders a bordered box containing an icon and a message on a single line,
+ * colored according to the variant. Uses `caps.unicode` to choose between
+ * Unicode box-drawing/icons and ASCII fallback borders/icons.
+ */
+declare class Alert extends Widget {
+    private _variant;
+    private _message;
+    constructor(opts: AlertOptions, style?: Partial<Style>);
+    /** Set the alert message */
+    setMessage(message: string): void;
+    /** Get the alert message */
+    getMessage(): string;
+    /** Set the alert variant */
+    setVariant(variant: StatusVariant): void;
+    /** Get the alert variant */
+    getVariant(): StatusVariant;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface EmptyStateOptions {
+    icon?: string;
+    description?: string;
+    hint?: string;
+}
+declare class EmptyState extends Widget {
+    private _title;
+    private _icon;
+    private _description;
+    private _hint;
+    constructor(title: string, style?: Partial<Style>, opts?: EmptyStateOptions);
+    setTitle(title: string): void;
+    setDescription(description: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type CalloutVariant = 'info' | 'warn' | 'success' | 'danger';
+interface CalloutOptions {
+    variant?: CalloutVariant;
+    title?: string;
+}
+declare class Callout extends Widget {
+    private _message;
+    private _variant;
+    private _title;
+    constructor(message: string, style?: Partial<Style>, opts?: CalloutOptions);
+    setMessage(message: string): void;
+    setVariant(variant: CalloutVariant): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface KeyValuePair {
+    key: string;
+    value: any;
+}
+interface KeyValueOptions {
+    /** Separator between key and value (default: ': ') */
+    separator?: string;
+    /** Color for keys */
+    keyColor?: _termuijs_core.Color;
+    /** Color for values */
+    valueColor?: _termuijs_core.Color;
+}
+/**
+ * KeyValue — aligned key: value pairs.
+ *
+ * Keys are right-aligned to the width of the longest key.
+ * Values follow after the separator.
+ */
+declare class KeyValue extends Widget {
+    private _pairs;
+    private _separator;
+    private _keyColor?;
+    private _valueColor?;
+    private _expandedPaths;
+    private _selectedIndex;
+    constructor(pairs: Array<KeyValuePair> | Record<string, any>, style?: Partial<Style>, opts?: KeyValueOptions);
+    setPairs(pairs: Array<KeyValuePair> | Record<string, any>): void;
+    private _updateFocusable;
+    private _getVisibleRows;
+    moveUp(): void;
+    moveDown(): void;
+    toggleSelected(): void;
+    handleKey(key: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SidebarItem {
+    label: string;
+    badge?: string;
+    active?: boolean;
+}
+interface SidebarOptions {
+    /** Whether the sidebar is collapsed */
+    collapsed?: boolean;
+    /** Collapsed width in cells (default: 3) */
+    collapsedWidth?: number;
+    /** Active item highlight color */
+    activeColor?: _termuijs_core.Color;
+    /** Badge color */
+    badgeColor?: _termuijs_core.Color;
+}
+/**
+ * Sidebar — a vertical list of navigation items with optional badges.
+ *
+ * Supports active item highlighting and collapsible mode.
+ */
+declare class Sidebar extends Widget {
+    private _items;
+    private _collapsed;
+    private _collapsedWidth;
+    private _activeColor;
+    private _badgeColor;
+    constructor(items: SidebarItem[], style?: Partial<Style>, opts?: SidebarOptions);
+    setItems(items: SidebarItem[]): void;
+    setCollapsed(collapsed: boolean): void;
+    toggle(): void;
+    get isCollapsed(): boolean;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface LineChartOptions {
+    /** Color of the plotted points/lines */
+    color?: Color;
+    /** Show Y-axis labels */
+    showYAxis?: boolean;
+    /** Show X-axis labels */
+    showXAxis?: boolean;
+    /** Label for the Y axis */
+    yLabel?: string;
+    /** Maximum Y value (auto if not set) */
+    max?: number;
+    /** Minimum Y value (auto if not set) */
+    min?: number;
+}
+/**
+ * LineChart — ASCII/Unicode line plot for a series of numbers.
+ *
+ * Normalizes data to the available height, samples to fit width.
+ * Plots points with simple vertical bar connectors between adjacent points.
+ */
+declare class LineChart extends Widget {
+    private _data;
+    private _color;
+    private _showYAxis;
+    private _showXAxis;
+    private _yLabel;
+    private _max?;
+    private _min?;
+    constructor(data: number[], style?: Partial<Style>, opts?: LineChartOptions);
+    setData(data: number[]): void;
+    pushValue(value: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface AreaChartOptions {
+    xLabel?: string;
+    yLabel?: string;
+    lineColor?: Color;
+    fillColor?: Color;
+    showLine?: boolean;
+}
+declare class AreaChart extends Widget {
+    private _data;
+    private _xLabel;
+    private _yLabel;
+    private _lineColor;
+    private _fillColor;
+    private _showLine;
+    constructor(style?: Partial<Style>, opts?: AreaChartOptions);
+    setData(values: number[]): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface HeatMapOptions {
+    /** Color for maximum value cells */
+    highColor?: Color;
+    /** Color for minimum value cells */
+    lowColor?: Color;
+    /** Row labels (left side) */
+    rowLabels?: string[];
+    /** Column labels (top) */
+    colLabels?: string[];
+}
+/**
+ * HeatMap — 2D matrix displayed with character-density shading.
+ *
+ * Values are normalized 0–1 and mapped to 4 shading levels.
+ */
+declare class HeatMap extends Widget {
+    private _matrix;
+    private _highColor;
+    private _lowColor;
+    private _rowLabels;
+    private _colLabels;
+    constructor(matrix: number[][], style?: Partial<Style>, opts?: HeatMapOptions);
+    setMatrix(matrix: number[][]): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface DefinitionPair {
+    term: string;
+    definition: string;
+}
+interface DefinitionOptions {
+    /** Indentation for definition lines (default: 2) */
+    indent?: number;
+    /** Blank line between pairs (default: true) */
+    spacing?: boolean;
+    /** Color for term labels */
+    termColor?: _termuijs_core.Color;
+    /** Color for definition text */
+    definitionColor?: _termuijs_core.Color;
+}
+/**
+ * Definition — term + definition pairs, stacked vertically.
+ *
+ * Each pair renders as:
+ *   Term
+ *     definition text (indented)
+ *
+ * Similar to KeyValue but stacked rather than inline.
+ */
+declare class Definition extends Widget {
+    private _pairs;
+    private _indent;
+    private _spacing;
+    private _termColor?;
+    private _definitionColor?;
+    constructor(pairs: DefinitionPair[] | Record<string, string>, style?: Partial<Style>, opts?: DefinitionOptions);
+    setPairs(pairs: DefinitionPair[] | Record<string, string>): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface HexdumpOptions {
+    /** Bytes per row. Default: 16 */
+    bytesPerRow?: number;
+    /** Character shown for non-printable bytes in ASCII column. Default: '.' */
+    placeholder?: string;
+}
+declare class Hexdump extends Widget {
+    private data;
+    private opts;
+    constructor(data: Uint8Array, style?: Partial<Style>, opts?: HexdumpOptions);
+    setData(data: Uint8Array): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface BulletRange {
+    to: number;
+    color?: Color;
+}
+interface BulletChartOptions {
+    max?: number;
+    ranges?: BulletRange[];
+    valueColor?: Color;
+    targetColor?: Color;
+    label?: string;
+}
+/**
+ * BulletChart — a metric display with target marker and qualitative range bands.
+ */
+declare class BulletChart extends Widget {
+    private _value;
+    private _target;
+    private _max;
+    private _ranges;
     private _valueColor;
-    private _labelColor;
-    constructor(data: BarGroup[], style?: Partial<Style>, opts?: BarChartOptions);
-    setData(data: BarGroup[]): void;
-    setMax(max: number | undefined): void;
+    private _targetColor;
+    private _label;
+    constructor(style?: Partial<Style>, opts?: BulletChartOptions);
+    setValue(value: number): void;
+    setTarget(target: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface BreadcrumbsOptions {
+    /** Separator drawn between segments. Default: caps.unicode ? '❯' : '>' */
+    separator?: string;
+    /** Color of the last (current) segment. Default: cyan */
+    activeColor?: Color;
+}
+/**
+ * Breadcrumbs — renders a non-interactive path trail of segments with separators and truncation.
+ *
+ * Example output:
+ *   Home ❯ Docs ❯ API
+ */
+declare class Breadcrumbs extends Widget {
+    private _segments;
+    private _separator?;
+    private _activeColor?;
+    constructor(segments: string[], style?: Partial<Style>, opts?: BreadcrumbsOptions);
+    /** Update the trail of segments. */
+    setSegments(segments: string[]): void;
     protected _renderSelf(screen: Screen): void;
-    private _computeMax;
-    private _renderVertical;
-    private _renderHorizontal;
 }
 
-interface GridOptions {
-    /** Number of equal-width columns */
-    columns: number;
-    /** Gap between items in both directions (default: 1) */
-    gap?: number;
-    /** Row gap override (overrides gap for rows) */
-    rowGap?: number;
-    /** Column gap override (overrides gap for columns) */
-    colGap?: number;
+interface AvatarOptions {
+    /** Override the dynamically generated color */
+    color?: Color;
+    /** Shape of the avatar */
+    shape?: 'square' | 'circle';
 }
 /**
- * Grid — a CSS-Grid-like layout widget.
+ * Avatar — a widget that displays user initials with a generated color.
+ */
+declare class Avatar extends Widget {
+    private _name;
+    private _color?;
+    private _shape;
+    private _initials;
+    private _fallbackColor;
+    constructor(name: string, style?: Partial<Style>, opts?: AvatarOptions);
+    setName(name: string): void;
+    getName(): string;
+    setColor(color: Color): void;
+    getColor(): Color | undefined;
+    setShape(shape: 'square' | 'circle'): void;
+    getShape(): 'square' | 'circle';
+    private _extractInitials;
+    private _generateColor;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface BigTextOptions {
+    /** Color for the rendered characters */
+    color?: Color;
+}
+/**
+ * BigText — renders text as large 5×3 ASCII art banner characters.
  *
- * Items fill left-to-right, wrapping to a new row every `columns` items.
- * Internally creates a column-flex Box per row, each with equal-flex-grow items.
+ * Supports A–Z (uppercase), 0–9, and common punctuation.
+ * Unrecognized characters fall back to a narrow glyph.
+ */
+declare class BigText extends Widget {
+    private _text;
+    private _color;
+    constructor(text: string, style?: Partial<Style>, opts?: BigTextOptions);
+    setText(text: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface GradientOptions {
+    /** Start color (hex string like '#ff0000' or named color string) */
+    startColor?: string;
+    /** End color (hex string like '#0000ff' or named color string) */
+    endColor?: string;
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right';
+}
+/**
+ * Gradient — text rendered with a smooth color gradient.
  *
- * The `addChild()` override means the reconciler's generic child-adding
- * loop works without any special casing.
+ * Each character is colored by linearly interpolating between startColor and endColor.
+ * Falls back to a single foreground color if true-color is unavailable.
  */
-declare class Grid extends Widget {
-    private _columns;
-    private _colGap;
-    private _rowGap;
-    private _rows;
-    private _itemCount;
-    constructor(style: Partial<Style>, options: GridOptions);
-    protected _renderSelf(_screen: Screen): void;
-    /**
-     * Add a widget to the grid. Items fill left-to-right,
-     * wrapping to a new row automatically every `columns` items.
-     * Overrides Widget.addChild so the reconciler generic loop works unchanged.
-     */
-    addChild(widget: Widget): void;
-    /** Add an item explicitly (alias for addChild) */
-    addItem(widget: Widget): void;
-    /** Remove all items and reset the grid */
-    clearItems(): void;
+declare class Gradient extends Widget {
+    private _text;
+    private _startColor;
+    private _endColor;
+    private _align;
+    constructor(text: string, style?: Partial<Style>, opts?: GradientOptions);
+    setText(text: string): void;
+    setColors(start: string, end: string): void;
+    protected _renderSelf(screen: Screen): void;
 }
 
-interface ScrollViewOptions {
-    /** Total height of content in rows */
-    contentHeight?: number;
-    /** Show scrollbar indicator on right edge */
-    showScrollbar?: boolean;
+interface MarkdownOptions {
+    content: string;
+}
+declare class Markdown extends Widget {
+    private _content;
+    private writeText;
+    private renderInline;
+    private renderCodeBlock;
+    constructor(options: MarkdownOptions, style?: Partial<Style>);
+    /** Update markdown content and mark dirty. */
+    setContent(content: string): void;
+    getContent(): string;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface CodeOptions {
+    language?: string;
+    showLineNumbers?: boolean;
+}
+declare class Code extends Widget {
+    private _code;
+    private _language;
+    private _showLineNumbers;
+    constructor(code: string, style?: Partial<Style>, opts?: CodeOptions);
+    setCode(code: string): void;
+    setLanguage(language: string): void;
+    protected _renderSelf(screen: Screen): void;
+    protected _renderBorder(screen: Screen): void;
+}
+
+type BadgeVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+interface BadgeOptions {
+    /** Variant determines background color. Default: 'neutral'. */
+    variant?: BadgeVariant;
 }
 /**
- * ScrollView — a height-bounded scrollable container.
+ * Badge — a short inline label with a colored background.
  *
- * Children are rendered with a vertical offset applied (scrolling).
- * Responds to up/down arrow keys and Page Up/Page Down.
+ * Used for status indicators such as "online", "error", "beta".
+ * Renders a bordered box with the text on a colored background.
+ * Uses `caps.unicode` to choose between Unicode box-drawing and ASCII fallback.
+ *
+ * CONSTRUCTOR: (text, style?, opts?)
  */
-declare class ScrollView extends Widget {
-    private _scrollOffset;
-    private _contentHeight;
-    private _showScrollbar;
-    constructor(style?: Partial<Style>, opts?: ScrollViewOptions);
-    /** Set the total content height (in rows) */
-    setContentHeight(h: number): void;
-    /** Get current scroll offset */
-    get scrollOffset(): number;
-    /** Scroll by delta rows */
-    scrollBy(delta: number): void;
-    /** Scroll to absolute offset */
-    scrollTo(offset: number): void;
-    private _clampOffset;
-    /** Handle keyboard navigation */
-    onKey(event: KeyEvent): void;
-    render(screen: Screen): void;
-    private _renderScrollbar;
-    protected _renderSelf(_screen: Screen): void;
+declare class Badge extends Widget {
+    private _text;
+    private _variant;
+    constructor(text: string, style?: Partial<Style>, opts?: BadgeOptions);
+    /** Update the badge text. */
+    setText(text: string): void;
+    /** Get the current badge text. */
+    getText(): string;
+    /** Update the badge variant. */
+    setVariant(variant: BadgeVariant): void;
+    /** Get the current badge variant. */
+    getVariant(): BadgeVariant;
+    protected _renderSelf(screen: Screen): void;
 }
 
-interface CenterOptions {
-    /** Center horizontally (default: true) */
-    horizontal?: boolean;
-    /** Center vertically (default: true) */
-    vertical?: boolean;
+interface KbdOptions {
+    color?: Color;
 }
 /**
- * Center — centers a single child widget horizontally and/or vertically.
+ * Kbd — an inline label representing a keyboard input.
  *
- * Computes centering offsets at render time from the child's measured size.
+ * Used for displaying hotkeys or shortcuts (e.g., "Ctrl+C").
+ * Renders an inline block with a distinct background to simulate a key press.
  */
-declare class Center extends Widget {
-    private _horizontal;
-    private _vertical;
-    constructor(style?: Partial<Style>, opts?: CenterOptions);
-    protected _renderSelf(_screen: Screen): void;
-    render(screen: Screen): void;
+declare class Kbd extends Widget {
+    private _keys;
+    private _opts;
+    constructor(keys: string, style?: Partial<Style>, opts?: KbdOptions);
+    /** Update the kbd keys. */
+    setKeys(keys: string): void;
+    /** Get the current kbd keys. */
+    getKeys(): string;
+    protected _renderSelf(screen: Screen): void;
 }
 
-interface CardOptions {
-    /** Optional title shown in the top border */
-    title?: string;
-    /** Color for the border and title */
+type TagVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+interface TagOptions {
+    /** Variant determines border and text color. Default: 'neutral'. */
+    variant?: TagVariant;
+}
+/**
+ * Tag — a short inline label with a colored border and no background fill.
+ *
+ * Used for categorical labels such as "typescript", "react", "v2.0".
+ * Renders a bordered box with the text colored by variant but no background.
+ * Uses `caps.unicode` to choose between Unicode box-drawing and ASCII fallback.
+ *
+ * CONSTRUCTOR: (text, style?, opts?)
+ */
+declare class Tag extends Widget {
+    private _text;
+    private _variant;
+    constructor(text: string, style?: Partial<Style>, opts?: TagOptions);
+    /** Update the tag text. */
+    setText(text: string): void;
+    /** Get the current tag text. */
+    getText(): string;
+    /** Update the tag variant. */
+    setVariant(variant: TagVariant): void;
+    /** Get the current tag variant. */
+    getVariant(): TagVariant;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface PlaceholderOptions {
+    /** Fill character. Default: '░' with ASCII fallback '.' */
+    fillChar?: string;
+    borderColor?: Color;
+    labelColor?: Color;
+}
+/**
+ * Placeholder - a labeled stand-in box for prototyping terminal layouts.
+ */
+declare class Placeholder extends Widget {
+    private _label;
+    private _fillChar?;
+    private _borderColor?;
+    private _labelColor?;
+    constructor(label: string, style?: Partial<Style>, opts?: PlaceholderOptions);
+    setLabel(label: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface WatermarkOptions {
+    /** Color of the repeated text. Default: brightBlack */
+    color?: Color;
+    /** Diagonal tilt angle in characters. 0 = horizontal rows. Default: 0 */
+    angle?: 0 | 45;
+}
+/**
+ * Watermark - fills its area with faint repeating text.
+ */
+declare class Watermark extends Widget {
+    private _text;
+    private _color;
+    private _angle;
+    constructor(text: string, style?: Partial<Style>, opts?: WatermarkOptions);
+    setText(text: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type BadgePosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+interface NotificationBadgeOptions {
+    /** Notification count to display. Default: 0. */
+    count?: number;
+    /** Corner position for the badge. Default: 'top-right'. */
+    position?: BadgePosition;
+}
+/**
+ * NotificationBadge - a small count label rendered at a corner position.
+ *
+ * Used for unread counts, alert indicators, and notification overlays.
+ * Renders the count as a compact colored label at one of four corner positions.
+ * Shows "99+" when the count exceeds 99. Renders nothing when count is 0.
+ */
+declare class NotificationBadge extends Widget {
+    private _count;
+    private _position;
+    constructor(opts?: NotificationBadgeOptions, style?: Partial<Style>);
+    /** Update the notification count. */
+    setCount(count: number): void;
+    /** Get the current notification count. */
+    getCount(): number;
+    /** Update the badge position. */
+    setPosition(position: BadgePosition): void;
+    /** Get the current badge position. */
+    getPosition(): BadgePosition;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface CarouselOptions {
+    loop?: boolean;
+    showDots?: boolean;
+    showArrows?: boolean;
+}
+declare class Carousel extends Widget {
+    private _items;
+    private _index;
+    private _opts;
+    constructor(items: string[], style?: Partial<Style>, opts?: CarouselOptions);
+    getIndex(): number;
+    setIndex(index: number): void;
+    next(): void;
+    prev(): void;
+    setItems(items: string[]): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface TooltipOptions {
+    text: string;
+    visible: boolean;
+}
+/**
+ * Tooltip — displays contextual help text.
+ *
+ * The widget renders within its own assigned rect.
+ * The parent is responsible for positioning it via updateRect().
+ */
+declare class Tooltip extends Widget {
+    private _text;
+    private _visible;
+    constructor(options: TooltipOptions, style?: Partial<Style>);
+    protected _renderSelf(screen: Screen): void;
+    setText(text: string): void;
+    getText(): string;
+    setVisible(visible: boolean): void;
+    getVisible(): boolean;
+}
+
+interface PanelOptions {
+    /** Required title shown in the top border */
+    title: string;
+    /** Optional color for the border and title */
     borderColor?: Color;
 }
 /**
- * Card — a bordered container with an optional title in the top border.
+ * Panel — a labeled container widget.
+ *
+ * A Box with a required title rendered inside the top border line.
+ * Use it as a labeled container for grouping related content.
+ *
+ * Unicode: ╭─ My Panel ──────╮
+ * ASCII:   +-- My Panel -----+
+ */
+declare class Panel extends Widget {
+    private _title;
+    private _borderColor?;
+    constructor(style: Partial<Style> | undefined, opts: PanelOptions);
+    setTitle(title: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ClockOptions {
+    showSeconds?: boolean;
+    use24Hour?: boolean;
+    digitColor?: Color;
+}
+declare class Clock extends Widget {
+    private _showSeconds;
+    private _use24Hour;
+    private _digits;
+    private _digitColor;
+    private _ampm;
+    private _digitPartLength;
+    constructor(style?: Partial<Style>, opts?: ClockOptions);
+    setTime(time: Date): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface LinkOptions {
+    /** The target URL for the OSC 8 hyperlink anchor. */
+    url: string;
+    /** Underline and anchor fallback color object. Default: blue */
+    color?: Color;
+    /** Whether to append the URL visually when terminal capabilities lack unicode/OSC 8 support. Default: true */
+    showUrlFallback?: boolean;
+}
+declare class Link extends Widget {
+    private _text;
+    private _url;
+    private _color;
+    private _showUrlFallback;
+    constructor(text: string, style: Partial<Style> | undefined, opts: LinkOptions);
+    setText(text: string): void;
+    setUrl(url: string): void;
+    /**
+     * Helper to safely slice text based on its visible terminal cell width grid blocks
+     */
+    private _sliceByWidth;
+    protected _renderSelf(screen: Screen): void;
+}
+
+/**
+ * Represents an individual shortcut item in the shortcut bar.
+ */
+interface ShortcutItem {
+    /** Keyboard key character/name (e.g. 'F1', 'q', 'ctrl+c') */
+    key: string;
+    /** Labeled explanation (e.g. 'Help', 'Quit') */
+    label: string;
+    /** Optional callback triggered on matching key press */
+    action?: () => void;
+}
+/**
+ * Options to configure styling and behavior of the ShortcutBar.
+ */
+interface ShortcutBarOptions {
+    /** Custom styles for the key (e.g., fg/bg colors). Default: cyan, bold */
+    keyStyle?: Partial<Style>;
+    /** Custom styles for the label text. Default: white */
+    labelStyle?: Partial<Style>;
+    /** Horizontal separator string. Default: '   ' (three spaces) */
+    separator?: string;
+}
+/**
+ * ShortcutBar — a horizontal footer bar that displays quick key bindings.
+ * Matches design aesthetics of classic terminal tools (like nano, htop).
+ */
+declare class ShortcutBar extends Widget {
+    private _items;
+    private _keyStyle;
+    private _labelStyle;
+    private _separator;
+    /**
+     * Creates an instance of ShortcutBar.
+     * @param items Initial list of shortcut items.
+     * @param style Partial widget style object.
+     * @param opts Custom options for key styling, label styling, and separator.
+     */
+    constructor(items?: ShortcutItem[], style?: Partial<Style>, opts?: ShortcutBarOptions);
+    /**
+     * Sets or replaces the current list of shortcut items.
+     * @param items The new list of shortcut items.
+     */
+    setItems(items: ShortcutItem[]): void;
+    /**
+     * Retrieves the current list of shortcut items.
+     * @returns The list of shortcut items.
+     */
+    getItems(): ShortcutItem[];
+    /**
+     * Updates the horizontal separator string printed between shortcut segments.
+     * @param separator The new separator string.
+     */
+    setSeparator(separator: string): void;
+    /**
+     * Retrieves the current horizontal separator string.
+     * @returns The separator string.
+     */
+    getSeparator(): string;
+    /**
+     * Updates the custom styles applied to keys and label segments.
+     * @param keyStyle Partial styling to apply to keys.
+     * @param labelStyle Partial styling to apply to labels.
+     */
+    setStyles(keyStyle?: Partial<Style>, labelStyle?: Partial<Style>): void;
+    /**
+     * Handles keyboard keypress events. Triggers the action callback of the
+     * shortcut item matching the pressed key (case-insensitively).
+     * @param event The key event triggered by the user.
+     */
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface AccordionSection {
+    /** Section header title */
+    title: string;
+    /** Section body content (may contain newlines) */
+    content: string;
+}
+interface AccordionOptions {
+    /** Allow multiple sections open at once. Default: false */
+    multiple?: boolean;
+    /** Index of the initially open section. Default: 0 */
+    openIndex?: number;
+    /** Expand indicator char. Default: '▶' (or '>' in ASCII) */
+    expandChar?: string;
+    /** Collapse indicator char. Default: '▼' (or 'v' in ASCII) */
+    collapseChar?: string;
+    /** Callback fired when a section is toggled */
+    onToggle?: (index: number, open: boolean) => void;
+}
+/**
+ * Accordion — a group of collapsible sections.
  *
- * Like a Box with border + padding, but supports embedding a title string
- * directly in the top border line.
+ * Renders each section as:
+ *   Row 0: [indicator] [title]
+ *   Rows 1+: content lines indented by 2 spaces (if section is open)
+ *
+ * Press Enter or Space to toggle the focused section.
+ * Press up/down arrow keys to move between sections.
+ *
+ * @example
+ * const accordion = new Accordion([
+ *   { title: 'System Info', content: 'CPU: 45%\nRAM: 2.1 GB' },
+ *   { title: 'Network',     content: 'eth0: 192.168.1.1' },
+ * ]);
  */
-declare class Card extends Widget {
-    private _title;
-    private _borderColor?;
-    constructor(style?: Partial<Style>, opts?: CardOptions);
-    setTitle(title: string): void;
+declare class Accordion extends Widget {
+    private _sections;
+    private _openSet;
+    private _multiple;
+    private _expandChar;
+    private _collapseChar;
+    private _onToggle?;
+    private _focusedIndex;
+    constructor(sections: AccordionSection[], style?: Partial<Style>, opts?: AccordionOptions);
+    /** Open a section by index. No-op if already open or index out of bounds. */
+    open(index: number): void;
+    /** Close a section by index. No-op if already closed. */
+    close(index: number): void;
+    /** Toggle a section open or closed by index. */
+    toggle(index: number): void;
+    /** Returns true if the section at the given index is open. */
+    isOpen(index: number): boolean;
+    /** Returns the index of the currently keyboard-focused section. */
+    getFocusedIndex(): number;
+    /** Replace all sections and reset open/focus state. */
+    setSections(sections: AccordionSection[]): void;
+    /**
+     * Handle a key event. Call this from your app's key-routing logic
+     * when this widget is focused.
+     */
+    handleKey(event: KeyEvent): void;
+    /** Render all sections with their open/closed state. */
     protected _renderSelf(screen: Screen): void;
+    /** Recalculate total height based on open sections. */
+    private _updateHeight;
 }
 
-interface ColumnsOptions {
-    /** Gap between columns in cells (default: 1) */
-    gap?: number;
+type StepStatus = 'completed' | 'active' | 'pending';
+type StepperOrientation = 'horizontal' | 'vertical';
+interface StepperStep {
+    /** Step label */
+    label: string;
+    /** Step status. Default: 'pending' */
+    status?: StepStatus;
+}
+interface StepperOptions {
+    /** Layout direction. Default: 'horizontal' */
+    orientation?: StepperOrientation;
+    /** Color for active step. Default: cyan */
+    activeColor?: Color;
+    /** Color for completed step. Default: green */
+    completedColor?: Color;
+    /** Color for pending step. Default: white */
+    pendingColor?: Color;
 }
 /**
- * Columns — splits available width evenly across child widgets.
+ * Stepper — renders a sequence of steps with status indicators.
  *
- * Children are laid out side-by-side with equal flex-grow.
- * Internally uses a flex-row Box; the addChild override applies
- * flexGrow:1 to each child so the reconciler's generic loop works.
+ * Horizontal example:
+ *   ✓ Setup ──── ● Config ──── ○ Review ──── ○ Done
+ *
+ * Vertical example:
+ *   ✓ Setup
+ *   │
+ *   ● Config
+ *   │
+ *   ○ Review
+ *
+ * Icons: ✓/+ (completed), ●/* (active), ○/- (pending)
+ * Unicode fallback via caps.unicode.
  */
-declare class Columns extends Widget {
-    private _inner;
-    constructor(style?: Partial<Style>, opts?: ColumnsOptions);
-    addChild(widget: Widget): void;
-    removeChild(widget: Widget): void;
-    clearChildren(): void;
-    protected _renderSelf(_screen: Screen): void;
+declare class Stepper extends Widget {
+    private _steps;
+    private _orientation;
+    private _activeColor;
+    private _completedColor;
+    private _pendingColor;
+    constructor(steps: StepperStep[], style?: Partial<Style>, opts?: StepperOptions);
+    /** Replace all steps. Clones input to prevent external mutation. */
+    setSteps(steps: StepperStep[]): void;
+    /** Get current steps. Returns copies to prevent external mutation. */
+    getSteps(): StepperStep[];
+    /** Update the status of a single step by index. */
+    setStepStatus(index: number, status: StepStatus): void;
+    /** Advance the active step to the next one. */
+    nextStep(): void;
+    /** Move the active step to the previous one. */
+    prevStep(): void;
+    /** Render all steps with connectors and status icons. */
+    protected _renderSelf(screen: Screen): void;
+    /** Render steps left-to-right on a single row. */
+    private _renderHorizontal;
+    /** Render steps top-to-bottom with vertical connectors. */
+    private _renderVertical;
+    /** Returns the icon, color, and text attributes for a given status. */
+    private _stepStyle;
 }
 
-interface ProgressBarOptions {
-    /** Current value (0–1) */
-    value?: number;
-    /** Character for the filled portion */
-    fillChar?: string;
-    /** Character for the empty portion */
-    emptyChar?: string;
-    /** Color of the filled portion */
-    fillColor?: Color;
-    /** Show percentage label */
-    showLabel?: boolean;
-    /** Label format: 'percent' | 'fraction' | 'custom' */
-    labelFormat?: 'percent' | 'fraction';
-    /** Total for fraction display */
-    total?: number;
+interface QRCodePatternOptions {
+    darkChar?: string;
+    lightChar?: string;
+    showText?: boolean;
+}
+interface QRCodeOptions extends QRCodePatternOptions {
+    errorCorrectionLevel?: 'L' | 'M' | 'Q' | 'H';
+}
+declare class QRCodePattern extends Widget {
+    private data;
+    private opts;
+    constructor(data: string, style?: Partial<Style>, opts?: QRCodePatternOptions);
+    setData(data: string): void;
+    private isFinder;
+    private renderFinder;
+    protected _renderSelf(screen: Screen): void;
+}
+declare const QRCode: typeof QRCodePattern;
+
+interface StackOptions {
+    /** Which child is on top (receives key events). Default: last child */
+    activeIndex?: number;
 }
 /**
- * ProgressBar — horizontal progress indicator.
+ * Stack — a widget that layers children on top of each other.
  *
- * Supports:
- * - Configurable fill/empty characters
- * - Custom fill color
- * - Percentage or fraction label
- * - Smooth animation-ready value changes
+ * All children share the same rect (the Stack's bounds).
+ * Children render in array order: index 0 is bottom, last index is top.
  */
-declare class ProgressBar extends Widget {
-    private _value;
-    private _fillChar;
-    private _emptyChar;
-    private _fillColor;
-    private _showLabel;
-    private _labelFormat;
-    private _total;
-    constructor(style?: Partial<Style>, options?: ProgressBarOptions);
-    /** Set progress value (0–1) */
-    setValue(value: number): void;
-    get value(): number;
+declare class Stack extends Widget {
+    private _activeIndex;
+    constructor(children: Widget[], style?: Partial<Style>, opts?: StackOptions);
+    /**
+     * Replace all children with a new array.
+     */
+    setChildren(children: Widget[]): void;
+    /**
+     * Set which child is active (on top).
+     */
+    setActiveIndex(index: number): void;
+    /**
+     * Get the currently active child index.
+     */
+    getActiveIndex(): number;
+    /**
+     * Required abstract method implementation.
+     * Stack is a pure layout container — no self-rendering needed.
+     */
+    protected _renderSelf(_screen: Screen): void;
+}
+
+interface ScatterPoint {
+    x: number;
+    y: number;
+    color?: Color;
+}
+interface ScatterPlotOptions {
+    /** X axis label */
+    xLabel?: string;
+    /** Y axis label */
+    yLabel?: string;
+    /** Point marker. Default: '•' with ASCII fallback '.' */
+    marker?: string;
+    pointColor?: Color;
+}
+declare class ScatterPlot extends Widget {
+    private points;
+    private options;
+    constructor(style?: Partial<Style>, opts?: ScatterPlotOptions);
+    setData(points: ScatterPoint[]): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-/**
- * A single progress item in MultiProgress
- */
-interface ProgressItem {
+interface RadarSeries {
     label: string;
-    value: number;
+    /** One value per axis, range [0, 1] */
+    values: number[];
     color?: Color;
 }
+interface RadarChartOptions {
+    /** Axis names, one per spoke */
+    axes?: string[];
+    lineColor?: Color;
+}
+declare class RadarChart extends Widget {
+    private series;
+    private options;
+    constructor(style?: Partial<Style>, opts?: RadarChartOptions);
+    setSeries(series: RadarSeries[]): void;
+    protected _renderSelf(screen: Screen): void;
+    private drawLine;
+    private renderLabels;
+}
+
+interface StatOptions {
+    delta?: number;
+    valueColor?: Color;
+}
+declare class Stat extends Widget {
+    private _label;
+    private _value;
+    private _delta;
+    private _valueColor;
+    constructor(label: string, value: string, style?: Partial<Style>, opts?: StatOptions);
+    setValue(value: string): void;
+    setDelta(delta: number | undefined): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface Candle {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}
+interface CandlestickChartOptions {
+    /** Color for bullish (close > open) candles */
+    upColor?: Color;
+    /** Color for bearish (close < open) candles */
+    downColor?: Color;
+    /** Color for the wick (high/low lines) */
+    wickColor?: Color;
+}
 /**
- * Options for MultiProgress widget
+ * CandlestickChart — renders OHLC candle data as a terminal chart.
+ *
+ * Each candle occupies one column. The body shows open/close range,
+ * wicks extend to high/low. Bullish candles use upColor, bearish use downColor.
  */
-interface MultiProgressOptions {
-    items: ProgressItem[];
-    labelWidth?: number;
-    showValues?: boolean;
+declare class CandlestickChart extends Widget {
+    private _candles;
+    private _upColor;
+    private _downColor;
+    private _wickColor;
+    constructor(style?: Partial<Style>, opts?: CandlestickChartOptions);
+    setData(candles: Candle[]): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface TimerOptions {
+    /** Duration to count down from in milliseconds. */
+    duration: number;
+    /** Tick interval in milliseconds. Default: 1000. */
+    interval?: number;
 }
 /**
- * MultiProgress — stacks multiple labeled progress bars in a vertical list.
+ * Timer — counts down from a duration to zero.
  *
- * Each item renders on its own row with a label, bar, and optional percentage.
- *
- * Supports:
- * - Multiple items with individual colors
- * - Custom label column width
- * - Optional percentage display
- * - Smooth animation-ready value changes
+ * - Accepts `duration` in milliseconds.
+ * - Exposes `start()`, `stop()`, and `reset()` methods.
+ * - Fires `onComplete()` callback when it reaches zero.
+ * - Renders as `MM:SS` for durations < 1 hour, `HH:MM:SS` for longer.
+ * - Calls `this.markDirty()` on every tick so the render loop re-paints.
+ * - Clears the interval on `stop()` and in `destroy()` to prevent leaks.
  */
-declare class MultiProgress extends Widget {
-    private _items;
-    private _labelWidth;
-    private _showValues;
-    constructor(options: MultiProgressOptions, style?: Partial<Style>);
+declare class Timer extends Widget {
+    /** Duration to count down from (ms). */
+    private _duration;
+    /** Tick interval in ms (default 1000). */
+    private _interval;
+    /** Remaining time in ms. */
+    private _remaining;
+    /** Whether the timer is currently running. */
+    private _running;
+    /** Internal setInterval handle. */
+    private _intervalId;
     /**
-     * Replace all items and mark dirty
+     * Called when the countdown reaches zero.
+     * Assign a function to this property to receive the event.
+     *
+     * @example
+     * timer.onComplete = () => {};
      */
-    setItems(items: ProgressItem[]): void;
+    onComplete: (() => void) | undefined;
+    constructor(options: TimerOptions, style?: Partial<Style>);
+    /** Start (or resume) the countdown. No-op if already running. */
+    start(): void;
+    /** Pause the countdown. No-op if already stopped. */
+    stop(): void;
     /**
-     * Update a single item's value
+     * Reset the remaining time back to the original duration and stop any
+     * running countdown.
      */
-    updateItem(index: number, value: number): void;
+    reset(): void;
+    /** Returns `true` when the countdown has reached zero. */
+    isComplete(): boolean;
+    /** Returns the remaining time in milliseconds. */
+    getRemaining(): number;
+    /**
+     * Release all resources held by this widget.
+     * Call this when the widget is no longer needed to avoid timer leaks.
+     */
+    destroy(): void;
+    /** Stop the interval when the widget is unmounted. */
+    unmount(): void;
+    /** Called on each interval tick. */
+    private _tick;
+    /** Safely clear the internal interval. */
+    private _clearInterval;
+    /**
+     * Format milliseconds as `MM:SS` or `HH:MM:SS`.
+     *
+     * Chooses `HH:MM:SS` when the original duration is >= 1 hour (3600000 ms).
+     */
+    private _format;
     protected _renderSelf(screen: Screen): void;
 }
 
-/**
- * Built-in spinner frame sets.
- */
-declare const SPINNER_FRAMES: Record<string, {
-    frames: string[];
-    interval: number;
-}>;
-interface SpinnerOptions {
-    /** Spinner preset name or custom frames */
-    spinner?: string | {
-        frames: string[];
-        interval: number;
-    };
-    /** Text label displayed after the spinner */
-    label?: string;
-    /** Color for the spinner frames */
-    color?: Color;
+interface StopwatchOptions {
+    /** Tick interval in milliseconds. Default: 10 (for centisecond precision). */
+    interval?: number;
 }
 /**
- * Spinner — animated loading indicator.
+ * Stopwatch — counts up from zero, displaying elapsed time.
  *
- * Supports:
- * - 8 built-in spinner presets
- * - Custom frame sequences
- * - Configurable color and label
- * - Automatic frame advancement via tick()
+ * - Exposes `start()`, `stop()`, and `reset()` methods.
+ * - Renders elapsed time as `MM:SS.ms` (e.g. `01:23.45`).
+ * - Calls `this.markDirty()` on every tick so the render loop re-paints.
+ * - Clears the interval on `stop()` and in `destroy()` to prevent leaks.
  */
-declare class Spinner extends Widget {
-    private _frames;
-    private _interval;
-    private _frameIndex;
-    private _label;
-    private _color;
-    private _lastTick;
+declare class Stopwatch extends Widget {
+    /** Accumulated elapsed time in ms (from prior start/stop cycles). */
     private _elapsed;
-    private _timerUnsub?;
-    constructor(style?: Partial<Style>, options?: SpinnerOptions);
-    /** Update the spinner label */
-    setLabel(label: string): void;
+    /** Timestamp (Date.now()) when the current run started, or undefined if stopped. */
+    private _startTime;
+    /** Tick interval in ms (default 10). */
+    private _interval;
+    /** Whether the stopwatch is currently running. */
+    private _running;
+    /** Internal setInterval handle. */
+    private _intervalId;
+    constructor(options?: StopwatchOptions, style?: Partial<Style>);
+    /** Start (or resume) the stopwatch. No-op if already running. */
+    start(): void;
+    /** Pause the stopwatch. No-op if already stopped. */
+    stop(): void;
+    /** Reset elapsed time to zero and stop the stopwatch. */
+    reset(): void;
+    /** Returns the total elapsed milliseconds (including current run). */
+    getElapsed(): number;
+    /** Returns `true` when the stopwatch is currently running. */
+    isRunning(): boolean;
     /**
-     * Advance the spinner frame based on elapsed time.
-     * Call this with a delta (ms) from the render loop.
+     * Release all resources held by this widget.
+     * Call this when the widget is no longer needed to avoid timer leaks.
      */
-    tick(deltaMs: number): void;
-    /** Lifecycle: start the frame-advance timer (only when motion is enabled). */
-    mount(): void;
-    /** Lifecycle: stop the frame-advance timer. */
+    destroy(): void;
+    /** Stop the interval when the widget is unmounted. */
     unmount(): void;
+    /** Called on each interval tick. */
+    private _tick;
+    /** Safely clear the internal interval. */
+    private _clearInterval;
+    /**
+     * Format milliseconds as `MM:SS.ms`.
+     *
+     * The `.ms` portion shows centiseconds (hundredths of a second).
+     * Example: 75423 ms → `01:15.42`
+     */
+    private _format;
     protected _renderSelf(screen: Screen): void;
+    setInterval(interval: number): void;
+    getInterval(): number;
 }
 
-type ScrollbarOrientation = 'verticalRight' | 'verticalLeft' | 'horizontalBottom' | 'horizontalTop';
-interface ScrollbarOptions {
-    /** Total number of content items. */
-    contentLength: number;
-    /** Number of items visible in the viewport. */
-    viewportLength: number;
-    /** Current scroll position (0-based). */
-    position?: number;
-    /** Scrollbar orientation. Default: 'verticalRight'. */
-    orientation?: ScrollbarOrientation;
-    /** Color of the thumb. */
-    thumbColor?: Color;
-    /** Color of the track. */
-    trackColor?: Color;
-    /** Show begin/end arrow symbols. Default: true. */
-    showArrows?: boolean;
+interface OrderedListItem {
+    text: string;
+    /** Nested items */
+    children?: OrderedListItem[];
 }
-declare class Scrollbar extends Widget {
-    private _contentLength;
-    private _viewportLength;
-    private _position;
-    private _orientation;
-    private _thumbColor;
-    private _trackColor;
-    private _showArrows;
-    constructor(style: Partial<Style> | undefined, opts: ScrollbarOptions);
-    setPosition(position: number): void;
-    setContentLength(length: number): void;
-    setViewportLength(length: number): void;
+interface OrderedListOptions {
+    /** Indent width per level. Default: 3 */
+    indent?: number;
+    /** Numbering style: '1.' for arabic, 'a.' for lowercase alpha, 'i.' for lowercase roman. Default: '1.' */
+    style?: '1.' | 'a.' | 'i.';
+}
+/**
+ * OrderedList — renders a numbered list with optional nesting.
+ */
+declare class OrderedList extends Widget {
+    private _items;
+    private _opts;
+    constructor(items: OrderedListItem[], style?: Partial<Style>, opts?: OrderedListOptions);
+    setItems(items: OrderedListItem[]): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface TypewriterOptions {
+    /** Characters revealed per tick. Must be a positive integer. Default: 1 */
+    speed?: number;
+    /** Cursor glyph drawn at the reveal head. Default: caps-aware block. */
+    cursor?: string;
+}
+/**
+ * Reveals static text character by character.
+ *
+ * The host is responsible for calling `tick()` at whatever cadence it likes
+ * (timer, animation loop, etc.). No internal timer is used.
+ *
+ * @example
+ * ```ts
+ * const tw = new Typewriter('hello world');
+ * const interval = setInterval(() => {
+ *   tw.tick();
+ *   screen.render();
+ * }, 80);
+ * ```
+ */
+declare class Typewriter extends Widget {
+    private _text;
+    private _revealed;
+    private _speed;
+    private _cursor;
+    constructor(text: string, style?: Partial<Style>, opts?: TypewriterOptions);
+    /** Advance the reveal head by `speed` characters. No-op once fully revealed. */
+    tick(): void;
+    /** Return the reveal counter to zero. */
+    reset(): void;
+    /** Replace the text and reset the reveal counter. */
+    setText(text: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type TimelineStatus = 'done' | 'active' | 'pending';
+interface TimelineItem {
+    title: string;
+    time?: string;
+    status?: TimelineStatus;
+}
+/**
+ * Timeline — renders a vertical list of timeline items.
+ *
+ * Each item gets a connector (├─ / └─) and a status icon:
+ *   ● active (cyan/bold), ✓ done (green), ○ pending (dim).
+ */
+declare class Timeline extends Widget {
+    private _items;
+    constructor(items: TimelineItem[], style?: Partial<Style>);
+    setItems(items: TimelineItem[]): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type MarqueeDirection = 'left' | 'right';
+interface MarqueeOptions {
+    direction?: MarqueeDirection;
+    speed?: number;
+    gap?: number;
+}
+declare class Marquee extends Widget {
+    private _text;
+    private _direction;
+    private _speed;
+    private _gap;
+    private _offset;
+    constructor(text: string, style?: Partial<Style>, opts?: MarqueeOptions);
+    tick(): void;
+    setText(text: string): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type SortDirection = 'asc' | 'desc' | 'none';
+interface DataGridColumn extends TableColumn {
+    /** Whether the column can be sorted. Default: true. */
+    sortable?: boolean;
+}
+type DataGridRow = TableRow;
+interface DataGridOptions extends TableOptions {
+    /** Callback fired when sort changes. */
+    onSort?: (key: string, direction: SortDirection) => void;
+    /** Callback fired when the filter changes. */
+    onFilter?: (filter: string) => void;
+}
+declare class DataGrid extends Table {
+    private _onSort?;
+    private _onFilter?;
+    private _sortKey;
+    private _sortDir;
+    private _filter;
+    private _filterOpen;
+    private _selectedCol;
+    focusable: boolean;
+    constructor(columns: DataGridColumn[], rows: DataGridRow[], style?: Partial<Style>, options?: DataGridOptions);
+    get sortKey(): string | null;
+    get sortDirection(): SortDirection;
+    get filter(): string;
+    get filterOpen(): boolean;
+    get selectedColumn(): number;
+    setSelectedColumn(col: number): void;
+    setFilter(filter: string): void;
+    clearFilter(): void;
+    cycleSort(): void;
+    handleKey(event: KeyEvent): void;
     protected _renderSelf(screen: Screen): void;
+    private _getVisibleRows;
 }
 
-interface SkeletonOptions {
-    /** Animation style: 'pulse' alternates two chars; 'shimmer' scrolls a highlight band */
-    variant?: 'pulse' | 'shimmer';
-    /** Animation interval in ms (default: 600) */
-    intervalMs?: number;
-    /** Characters for pulse: [dim, bright]. Default: ['░', '▒'] (ASCII fallback: ['-', '#']) */
-    chars?: [string, string];
-    /** Color for the bright state (optional) */
-    color?: Color;
+declare class ScrollAcceleration {
+    private lastScrollTime;
+    getMultiplier(now: number): number;
+    reset(): void;
 }
-/**
- * Skeleton — animated loading placeholder.
- *
- * Supports:
- * - 'pulse' variant: alternates between dim and bright fill characters
- * - 'shimmer' variant: scrolls a bright band (~20% width) across the widget
- * - Automatic ASCII fallback when unicode is unavailable
- * - No animation when caps.motion is false (static frame 0)
- */
-declare class Skeleton extends Widget {
-    private _frame;
-    private _shimmerPos;
-    private _unsub?;
-    private _chars;
-    private _variant;
-    private _intervalMs;
-    constructor(style?: Partial<Style>, options?: SkeletonOptions);
-    unmount(): void;
+
+interface PieSlice {
+    label: string;
+    value: number;
+    color: string | Color;
+}
+interface PieChartOptions {
+    slices?: PieSlice[];
+    style?: Partial<Style>;
+    showLegend?: boolean;
+}
+declare class PieChart extends Widget {
+    private _slices;
+    private _showLegend;
+    constructor(options?: PieChartOptions);
+    get slices(): ReadonlyArray<PieSlice>;
+    setSlices(slices: PieSlice[]): void;
     protected _renderSelf(screen: Screen): void;
+    private _renderPie;
+    private _findSliceAt;
+    private _renderBars;
+    private _renderLegend;
+    private _total;
+    private _colorOf;
 }
 
-type StatusVariant = 'success' | 'error' | 'warning' | 'info';
-interface StatusMessageOptions {
-    /** Variant determines icon and color */
-    variant?: StatusVariant;
-    /** Override the icon character */
-    icon?: string;
+interface BrailleCanvasOptions {
+    width: number;
+    height: number;
+    color?: Color;
 }
-/**
- * StatusMessage — a single-line status indicator.
- *
- * Renders an icon (✓/✗/⚠/ℹ) followed by a message, colored by variant.
- */
-declare class StatusMessage extends Widget {
-    private _message;
-    private _variant;
-    private _icon?;
-    constructor(message: string, style?: Partial<Style>, opts?: StatusMessageOptions);
-    setMessage(message: string): void;
-    setVariant(variant: StatusVariant): void;
+declare class BrailleCanvas extends Widget {
+    private _canvasWidth;
+    private _canvasHeight;
+    private _pixels;
+    private _color?;
+    constructor(opts: BrailleCanvasOptions, style?: Partial<Style>);
+    drawPixel(x: number, y: number): void;
+    drawLine(x0: number, y0: number, x1: number, y1: number): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface BannerOptions {
-    /** Variant determines border color */
-    variant?: StatusVariant;
-    /** Title displayed on first line in bold */
-    title?: string;
-    /** Body text */
-    body?: string;
+interface ProgressColumnProps {
+    maxRefresh?: number;
+}
+interface TextColumnProps extends ProgressColumnProps {
+    template?: string;
+}
+type ProgressColumnRenderer = (task: Record<string, unknown>) => string;
+interface ProgressColumnDefinition {
+    kind: 'bar' | 'text' | 'time' | 'speed' | 'percentage';
+    maxRefresh?: number;
+    template?: string;
+    render?: ProgressColumnRenderer;
+}
+declare function BarColumn(props?: ProgressColumnProps): ProgressColumnDefinition;
+declare function TextColumn(props?: TextColumnProps): ProgressColumnDefinition;
+declare function TimeColumn(props?: ProgressColumnProps): ProgressColumnDefinition;
+declare function SpeedColumn(props?: ProgressColumnProps): ProgressColumnDefinition;
+declare function PercentageColumn(props?: ProgressColumnProps): ProgressColumnDefinition;
+
+interface ProgressTask {
+    label?: string;
+    value?: number;
+    status?: string;
+    [key: string]: unknown;
 }
-/**
- * Banner — full-width alert with title and body text.
- *
- * Shows a bordered box with a bold title line and body text,
- * colored according to variant. The border is drawn manually
- * to use the variant color.
- */
-declare class Banner extends Widget {
-    private _variant;
-    private _title;
-    private _body;
-    constructor(style?: Partial<Style>, opts?: BannerOptions);
-    setTitle(title: string): void;
-    setBody(body: string): void;
-    setVariant(variant: StatusVariant): void;
+interface ProgressProps {
+    tasks?: ProgressTask[];
+    columns?: ProgressColumnDefinition[];
+    children?: unknown;
+}
+declare class Progress extends Widget {
+    private _tasks;
+    private _columns;
+    private _lastRefreshTimes;
+    private _columnCache;
+    private _resolveColumns;
+    constructor(props?: ProgressProps, style?: Partial<Style>);
+    get tasks(): ProgressTask[];
+    get columns(): ProgressColumnDefinition[];
+    setTasks(tasks: ProgressTask[]): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface KeyValuePair {
-    key: string;
-    value: string;
+declare class Highlight extends Box {
+    constructor(text: string, query: string | RegExp, style?: Partial<Style>);
+    private _buildSegments;
+    update(text: string, query: string | RegExp, style?: Partial<Style>): void;
 }
-interface KeyValueOptions {
-    /** Separator between key and value (default: ': ') */
-    separator?: string;
-    /** Color for keys */
-    keyColor?: _termuijs_core.Color;
-    /** Color for values */
-    valueColor?: _termuijs_core.Color;
+
+interface ThinkingBlockOptions {
+    width?: number;
+    thinking?: string;
 }
-/**
- * KeyValue — aligned key: value pairs.
- *
- * Keys are right-aligned to the width of the longest key.
- * Values follow after the separator.
- */
-declare class KeyValue extends Widget {
-    private _pairs;
-    private _separator;
-    private _keyColor?;
-    private _valueColor?;
-    constructor(pairs: Array<KeyValuePair> | Record<string, string>, style?: Partial<Style>, opts?: KeyValueOptions);
-    setPairs(pairs: Array<KeyValuePair> | Record<string, string>): void;
+declare class ThinkingBlock extends Widget {
+    private _text;
+    private _expanded;
+    private _streaming;
+    private _dots;
+    private _timerUnsub?;
+    constructor(options?: ThinkingBlockOptions, style?: Partial<Style>);
+    appendText(chunk: string): void;
+    setStreaming(streaming: boolean): void;
+    toggle(): void;
+    handleKey(event: KeyEvent): void;
+    mount(): void;
+    unmount(): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface SidebarItem {
-    label: string;
-    badge?: string;
-    active?: boolean;
-}
-interface SidebarOptions {
-    /** Whether the sidebar is collapsed */
-    collapsed?: boolean;
-    /** Collapsed width in cells (default: 3) */
-    collapsedWidth?: number;
-    /** Active item highlight color */
-    activeColor?: _termuijs_core.Color;
-    /** Badge color */
-    badgeColor?: _termuijs_core.Color;
+interface CollapsibleOptions {
+    /** Start open. Default: false */
+    open?: boolean;
+    /** Expand indicator char. Default: '▶' (or '>' in ASCII) */
+    expandChar?: string;
+    /** Collapse indicator char. Default: '▼' (or 'v' in ASCII) */
+    collapseChar?: string;
+    /** Callback when toggled */
+    onToggle?: (open: boolean) => void;
 }
 /**
- * Sidebar — a vertical list of navigation items with optional badges.
+ * Collapsible — a toggleable section with title and body.
  *
- * Supports active item highlighting and collapsible mode.
+ * Renders:
+ * - Row 0: [indicator] [title]
+ * - Rows 1+: body lines (if open)
+ *
+ * Press Enter or Space to toggle open/closed state.
  */
-declare class Sidebar extends Widget {
-    private _items;
-    private _collapsed;
-    private _collapsedWidth;
-    private _activeColor;
-    private _badgeColor;
-    constructor(items: SidebarItem[], style?: Partial<Style>, opts?: SidebarOptions);
-    setItems(items: SidebarItem[]): void;
-    setCollapsed(collapsed: boolean): void;
+declare class Collapsible extends Widget {
+    private _title;
+    private _body;
+    private _open;
+    private _expandChar;
+    private _collapseChar;
+    private _onToggle?;
+    focusable: boolean;
+    constructor(title: string, body: string, style?: Partial<Style>, opts?: CollapsibleOptions);
+    /** Update the title and re-render. */
+    setTitle(title: string): void;
+    /** Update the body and re-render. */
+    setBody(body: string): void;
+    /** Toggle between open and closed. Fires onToggle callback. */
     toggle(): void;
-    get isCollapsed(): boolean;
+    /** Check if currently open. */
+    isOpen(): boolean;
+    /**
+     * Handle key events.
+     */
+    handleKey(event: KeyEvent): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface LineChartOptions {
-    /** Color of the plotted points/lines */
+interface DigitsOptions {
     color?: Color;
-    /** Show Y-axis labels */
-    showYAxis?: boolean;
-    /** Show X-axis labels */
-    showXAxis?: boolean;
-    /** Label for the Y axis */
-    yLabel?: string;
-    /** Maximum Y value (auto if not set) */
-    max?: number;
-    /** Minimum Y value (auto if not set) */
-    min?: number;
 }
 /**
- * LineChart — ASCII/Unicode line plot for a series of numbers.
+ * Digits — renders a numeric string as large 3-row ASCII art.
+ * Similar to a 7-segment display.
  *
- * Normalizes data to the available height, samples to fit width.
- * Plots points with simple vertical bar connectors between adjacent points.
+ * Example:
+ *   new Digits({ value: '42', color: 'cyan', width: 20, height: 3 })
  */
-declare class LineChart extends Widget {
-    private _data;
+declare class Digits extends Widget {
+    private _value;
     private _color;
-    private _showYAxis;
-    private _showXAxis;
-    private _yLabel;
-    private _max?;
-    private _min?;
-    constructor(data: number[], style?: Partial<Style>, opts?: LineChartOptions);
-    setData(data: number[]): void;
-    pushValue(value: number): void;
+    constructor(style?: Partial<Style>, opts?: DigitsOptions);
+    setValue(value: string): void;
+    getValue(): string;
+    setColor(color: Color): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface HeatMapOptions {
-    /** Color for maximum value cells */
-    highColor?: Color;
-    /** Color for minimum value cells */
-    lowColor?: Color;
-    /** Row labels (left side) */
-    rowLabels?: string[];
-    /** Column labels (top) */
-    colLabels?: string[];
-}
-/**
- * HeatMap — 2D matrix displayed with character-density shading.
- *
- * Values are normalized 0–1 and mapped to 4 shading levels.
- */
-declare class HeatMap extends Widget {
-    private _matrix;
-    private _highColor;
-    private _lowColor;
-    private _rowLabels;
-    private _colLabels;
-    constructor(matrix: number[][], style?: Partial<Style>, opts?: HeatMapOptions);
-    setMatrix(matrix: number[][]): void;
+type TreeNode = {
+    name: string;
+    type: 'file' | 'dir';
+    children?: TreeNode[];
+};
+interface DirectoryTreeOptions {
+    tree?: TreeNode[];
+    path?: string;
+    onSelect?: (node: TreeNode, path: string) => void;
+}
+declare class DirectoryTree extends Widget {
+    private _tree;
+    private _visible;
+    private _selectedIndex;
+    private _expanded;
+    onSelect?: (node: TreeNode, path: string) => void;
+    constructor(options: DirectoryTreeOptions, style?: Partial<Style>);
+    private _rebuild;
+    private _walk;
+    private _toggle;
+    private _select;
+    handleKey(event: KeyEvent): boolean;
     protected _renderSelf(screen: Screen): void;
 }
 
-interface DefinitionPair {
-    term: string;
-    definition: string;
+interface ListItem {
+    text: string;
+    children?: ListItem[];
 }
-interface DefinitionOptions {
-    /** Indentation for definition lines (default: 2) */
+interface UnorderedListOptions {
+    /** Bullet characters per nesting level. Default uses Unicode with ASCII fallback. */
+    markers?: string[];
+    /** Indent width per level. Default: 2 */
     indent?: number;
-    /** Blank line between pairs (default: true) */
-    spacing?: boolean;
-    /** Color for term labels */
-    termColor?: _termuijs_core.Color;
-    /** Color for definition text */
-    definitionColor?: _termuijs_core.Color;
 }
 /**
- * Definition — term + definition pairs, stacked vertically.
- *
- * Each pair renders as:
- *   Term
- *     definition text (indented)
- *
- * Similar to KeyValue but stacked rather than inline.
+ * UnorderedList - renders a bulleted list with optional nested children.
  */
-declare class Definition extends Widget {
-    private _pairs;
+declare class UnorderedList extends Widget {
+    private _items;
+    private _markers?;
     private _indent;
-    private _spacing;
-    private _termColor?;
-    private _definitionColor?;
-    constructor(pairs: DefinitionPair[] | Record<string, string>, style?: Partial<Style>, opts?: DefinitionOptions);
-    setPairs(pairs: DefinitionPair[] | Record<string, string>): void;
+    constructor(items: ListItem[], style?: Partial<Style>, opts?: UnorderedListOptions);
+    setItems(items: ListItem[]): void;
     protected _renderSelf(screen: Screen): void;
+    private _markerForDepth;
 }
 
-interface BigTextOptions {
-    /** Color for the rendered characters */
+type RuleOrientation = 'horizontal' | 'vertical';
+interface RuleOptions {
+    /** Line direction. Default: 'horizontal'. */
+    orientation?: RuleOrientation;
+    /** Title centered in the line (horizontal only). */
+    title?: string;
+    /** Line color. Default: brightBlack */
     color?: Color;
 }
 /**
- * BigText — renders text as large 5×3 ASCII art banner characters.
+ * Rule — a horizontal or vertical divider line with an optional centered title.
  *
- * Supports A–Z (uppercase), 0–9, and common punctuation.
- * Unrecognized characters fall back to a narrow glyph.
- */
-declare class BigText extends Widget {
-    private _text;
-    private _color;
-    constructor(text: string, style?: Partial<Style>, opts?: BigTextOptions);
-    setText(text: string): void;
-    protected _renderSelf(screen: Screen): void;
-}
-
-interface GradientOptions {
-    /** Start color (hex string like '#ff0000' or named color string) */
-    startColor?: string;
-    /** End color (hex string like '#0000ff' or named color string) */
-    endColor?: string;
-    /** Text alignment */
-    align?: 'left' | 'center' | 'right';
-}
-/**
- * Gradient — text rendered with a smooth color gradient.
+ * Horizontal example (no title):
+ *   ────────────────────
  *
- * Each character is colored by linearly interpolating between startColor and endColor.
- * Falls back to a single foreground color if true-color is unavailable.
+ * Horizontal example (with title):
+ *   ────── Logs ──────
+ *
+ * Vertical example:
+ *   │
+ *   │
+ *   │
+ *
+ * Uses `caps.unicode` to choose between Unicode box-drawing and ASCII fallback.
  */
-declare class Gradient extends Widget {
-    private _text;
-    private _startColor;
-    private _endColor;
-    private _align;
-    constructor(text: string, style?: Partial<Style>, opts?: GradientOptions);
-    setText(text: string): void;
-    setColors(start: string, end: string): void;
+declare class Rule extends Widget {
+    private _orientation;
+    private _title;
+    private _color;
+    constructor(style?: Partial<Style>, opts?: RuleOptions);
+    /** Update the title text. Calls markDirty(). */
+    setTitle(title: string): void;
     protected _renderSelf(screen: Screen): void;
 }
 
-export { Banner, type BannerOptions, type Bar, BarChart, type BarChartDirection, type BarChartOptions, type BarGroup, BigText, type BigTextOptions, Box, Card, type CardOptions, Center, type CenterOptions, ChatMessage, type ChatMessageOptions, Columns, type ColumnsOptions, type Command, CommandPalette, type CommandPaletteOptions, Definition, type DefinitionOptions, type DefinitionPair, type DiffLine, DiffView, type DiffViewOptions, Gauge, type GaugeOptions, Gradient, type GradientOptions, Grid, type GridOptions, HeatMap, type HeatMapOptions, type JSONNodeData, type JSONNodeType, JSONView, type JSONViewOptions, KeyValue, type KeyValueOptions, type KeyValuePair, LineChart, type LineChartOptions, List, type ListItem, LogView, type LogViewOptions, type MessageRole, MultiProgress, type MultiProgressOptions, ProgressBar, type ProgressBarOptions, type ProgressItem, SPINNER_FRAMES, type ScrollRange, ScrollView, type ScrollViewOptions, Scrollbar, type ScrollbarOptions, type ScrollbarOrientation, Sidebar, type SidebarItem, type SidebarOptions, Skeleton, type SkeletonOptions, Sparkline, type SparklineOptions, Spinner, type SpinnerOptions, StatusIndicator, type StatusIndicatorOptions, StatusMessage, type StatusMessageOptions, type StatusVariant, StreamingText, type StreamingTextOptions, Table, type TableColumn, type TableOptions, type TableRow, Text, TextInput, type TextProps, ToolApproval, type ToolApprovalOptions, ToolCall, type ToolCallOptions, type ToolCallStatus, Tree, type TreeNode, type TreeOptions, VirtualList, type VirtualListOptions, Widget, type WidgetEvents, computeRange, computeVariableRange, jsonToTree };
+export { Accordion, type AccordionOptions, type AccordionSection, Alert, type AlertOptions, AreaChart, type AreaChartOptions, AspectRatio, type AspectRatioOptions, Avatar, type AvatarOptions, Badge, type BadgeOptions, type BadgePosition, type BadgeVariant, Banner, type BannerOptions, type Bar, BarChart, type BarChartDirection, type BarChartOptions, BarColumn, type BarGroup, BigText, type BigTextOptions, Box, BrailleCanvas, type BrailleCanvasOptions, Breadcrumbs, type BreadcrumbsOptions, BulletChart, type BulletChartOptions, type BulletRange, Button, type ButtonOptions, type ButtonVariant, Calendar, type CalendarOptions, Callout, type CalloutOptions, type CalloutVariant, type Candle, CandlestickChart, type CandlestickChartOptions, Canvas, Card, type CardOptions, Carousel, type CarouselOptions, Center, type CenterOptions, ChatMessage, type ChatMessageOptions, Clock, type ClockOptions, Code, type CodeOptions, Collapsible, type CollapsibleOptions, Columns, type ColumnsOptions, type Command, CommandPalette, type CommandPaletteOptions, ContextMenu, type ContextMenuItem, DataGrid, type DataGridColumn, type DataGridOptions, type DataGridRow, DataGrid as DataGridView, Definition, type DefinitionOptions, type DefinitionPair, type DiffLine, DiffView, type DiffViewOptions, Digits, type DigitsOptions, DirectoryTree, type DirectoryTreeOptions, Divider, type DividerOptions, type DividerOrientation, Dock, type DockEdge, type DockItem, type DockOptions, EmptyState, type EmptyStateOptions, Fill, type FillOptions, GanttChart, type GanttChartOptions, type GanttTask, Gauge, type GaugeOptions, Gradient, type GradientOptions, Grid, type GridOptions, HeatMap, type HeatMapOptions, Hexdump, type HexdumpOptions, Highlight, Histogram, type HistogramOptions, type JSONNodeData, type JSONNodeType, JSONView, type JSONViewOptions, Kbd, type KbdOptions, KeyValue, type KeyValueOptions, type KeyValuePair, Knob, type KnobOptions, LineChart, type LineChartOptions, LineGauge, type LineGaugeOptions, Link, type LinkOptions, List, type ListItem$1 as ListItem, type ListProps, type ListState, LoadingDots, type LoadingDotsOptions, LogView, type LogViewOptions, Markdown, type MarkdownOptions, Marquee, type MarqueeDirection, type MarqueeOptions, Masonry, type MasonryOptions, type MessageRole, MultiProgress, type MultiProgressOptions, NotificationBadge, type NotificationBadgeOptions, OrderedList, type OrderedListItem, type OrderedListOptions, Panel, PercentageColumn, PieChart, type PieChartOptions, type PieSlice, PinInput, type PinInputOptions, Placeholder, type PlaceholderOptions, Progress, ProgressBar, type ProgressBarOptions, type ProgressBarStyle, type ProgressColumnDefinition, type ProgressColumnProps, type ProgressItem, type ProgressProps, ProgressString, type ProgressStringProps, type ProgressTask, Pty, type PtyOptions, QRCode, type QRCodeOptions, QRCodePattern, type QRCodePatternOptions, RadarChart, type RadarChartOptions, type RadarSeries, RangeInput, type RangeInputOptions, Rating, type RatingOptions, Rule, type RuleOptions, type RuleOrientation, SPINNER_FRAMES, ScatterPlot, type ScatterPlotOptions, type ScatterPoint, ScrollAcceleration, type ScrollRange, ScrollView, type ScrollViewOptions, Scrollbar, type ScrollbarOptions, type ScrollbarOrientation, ShortcutBar, type ShortcutBarOptions, type ShortcutItem, Sidebar, type SidebarItem, type SidebarOptions, Skeleton, type SkeletonOptions, Slider, type SliderOptions, type SortDirection, Sparkline, type SparklineOptions, SpeedColumn, Spinner, type SpinnerOptions, SplitPane, type SplitPaneOptions, Stack, type StackOptions, StackedBarChart, type StackedBarChartOptions, type StackedSeries, Stat, type StatOptions, StatusIndicator, type StatusIndicatorOptions, StatusMessage, type StatusMessageOptions, type StatusVariant, type StepStatus, Stepper, type StepperOptions, type StepperOrientation, type StepperStep, Stopwatch, type StopwatchOptions, StreamingText, type StreamingTextOptions, Table, type TableColumn, type TableOptions, type TableProps, type TableRow, type TableState, Tag, type TagOptions, type TagVariant, type TaskItem, TaskList, type TaskListOptions, type TaskStatus, Text, TextColumn, TextInput, type TextProps, ThinkingBlock, type ThinkingBlockOptions, TimeColumn, Timeline, type TimelineItem, type TimelineStatus, Timer, type TimerOptions, ToolApproval, type ToolApprovalOptions, ToolCall, type ToolCallOptions, type ToolCallStatus, Tooltip, type TooltipOptions, Tree, type TreeNode$1 as TreeNode, type TreeOptions, TreeTable, type TreeTableColumn, type TreeTableOptions, type TreeTableRow, Typewriter, type TypewriterOptions, UnorderedList, type UnorderedListOptions, VirtualList, type VirtualListOptions, Watermark, type WatermarkOptions, Widget, type WidgetEvents, _resetWidgetIdCounter, computeRange, computeVariableRange, jsonToTree, useListState, useTableState };