@termuijs/ui 0.1.4 → 0.1.6

package/dist/index.d.cts

@@ -1,6 +1,55 @@
 import { Widget } from '@termuijs/widgets';
 export { Box, Gauge, List, LogView, ProgressBar, Sparkline, Spinner, StatusIndicator, Table, Text, TextInput, Widget } from '@termuijs/widgets';
-import { Style, Screen, KeyEvent } from '@termuijs/core';
+import { Style, Screen, KeyEvent, Color, LayoutNode, Rect } from '@termuijs/core';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { VNode } from '@termuijs/jsx';
+export * from '@termuijs/tss';
+
+interface SliderOptions {
+    min: number;
+    max: number;
+    step?: number;
+    value?: number;
+    onChange?: (value: number) => void;
+}
+interface RangeInputOptions {
+    min: number;
+    max: number;
+    step?: number;
+    low?: number;
+    high?: number;
+    onChange?: (low: number, high: number) => void;
+}
+declare class Slider extends Widget {
+    private _value;
+    private _min;
+    private _max;
+    private _step;
+    onChange?: (value: number) => void;
+    focusable: boolean;
+    constructor(style: Partial<Style> | undefined, opts: SliderOptions);
+    private _clamp;
+    getValue(): number;
+    setValue(value: number): void;
+    increment(): void;
+    decrement(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+declare class RangeInput extends Widget {
+    private _low;
+    private _high;
+    private _min;
+    private _max;
+    private _step;
+    onChange?: (low: number, high: number) => void;
+    focusable: boolean;
+    constructor(style: Partial<Style> | undefined, opts: RangeInputOptions);
+    getLow(): number;
+    getHigh(): number;
+    setRange(low: number, high: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
 
 interface DividerOptions {
     char?: string;
@@ -44,6 +93,93 @@ declare class Tabs extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
+interface MenuItem$1 {
+    label: string;
+    action?: () => void;
+    disabled?: boolean;
+}
+interface MenuBarItem {
+    label: string;
+    items: MenuItem$1[];
+}
+interface MenuBarOptions {
+    activeColor?: Color;
+}
+declare class MenuBar extends Widget {
+    private _menus;
+    private _activeMenu;
+    private _isOpen;
+    private _activeItem;
+    private _activeColor;
+    focusable: boolean;
+    constructor(menus: MenuBarItem[], style?: Partial<Style>, opts?: MenuBarOptions);
+    get activeMenu(): number;
+    get isOpen(): boolean;
+    get activeItem(): number;
+    get menus(): MenuBarItem[];
+    setMenus(menus: MenuBarItem[]): void;
+    private _initActiveItem;
+    private _selectNextItem;
+    private _selectPrevItem;
+    private _openMenu;
+    private _closeMenu;
+    selectNextMenu(): void;
+    selectPrevMenu(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface MenuItem {
+    label: string;
+    shortcut?: string;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface MenuOptions {
+    items: MenuItem[];
+    onClose?: () => void;
+    style?: Partial<Style>;
+}
+/**
+ * Menu — a vertical list of interactive items supporting keyboard navigation,
+ * shortcuts, and disabled states.
+ */
+declare class Menu extends Widget {
+    private _items;
+    private _selectedIndex;
+    private _onClose?;
+    constructor(options: MenuOptions);
+    private _initSelection;
+    private _selectNext;
+    private _selectPrev;
+    private _confirm;
+    handleKey(event: KeyEvent): boolean;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface CarouselOptions {
+    showDots?: boolean;
+    onChange?: (index: number) => void;
+}
+declare class Carousel extends Widget {
+    private _slides;
+    private _activeIndex;
+    private _showDots;
+    private _onChange?;
+    focusable: boolean;
+    constructor(slides: string[], options?: CarouselOptions);
+    get activeIndex(): number;
+    get currentSlide(): string;
+    get slides(): string[];
+    get showDots(): boolean;
+    setIndex(index: number): void;
+    next(): void;
+    prev(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+    private _normalizeIndex;
+}
+
 interface ModalOptions {
     title?: string;
     width?: number;
@@ -59,7 +195,7 @@ declare class Modal extends Widget {
     private _backdropChar;
     private _visible;
     private _content;
-    constructor(options?: ModalOptions);
+    constructor(options?: ModalOptions, style?: Partial<Style>);
     get visible(): boolean;
     show(): void;
     hide(): void;
@@ -68,6 +204,100 @@ declare class Modal extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
+/** The edge from which the drawer slides into view. */
+type DrawerPosition = 'left' | 'right' | 'top' | 'bottom';
+interface DrawerOptions {
+    /** Edge the drawer appears from. */
+    position: DrawerPosition;
+    /**
+     * Panel width in columns.
+     * Applies to 'left' and 'right' positions only.
+     * Defaults to 30.
+     */
+    width?: number;
+    /**
+     * Panel height in rows.
+     * Applies to 'top' and 'bottom' positions only.
+     * Defaults to 10.
+     */
+    height?: number;
+    /** Optional title shown in the drawer's top border. */
+    title?: string;
+    /** Called when the user presses Escape or explicitly closes the drawer. */
+    onClose: () => void;
+    /** Character used for the dimmed backdrop. Defaults to '░' (unicode) or ' '. */
+    backdropChar?: string;
+    /** Border colour. Defaults to cyan. */
+    borderColor?: Style['fg'];
+}
+/**
+ * Drawer — a side panel that slides in from any edge.
+ *
+ * Usage:
+ * ```ts
+ * const drawer = new Drawer({
+ *   position: 'right',
+ *   width: 30,
+ *   title: 'Settings',
+ *   onClose: () => closeDrawer(),
+ * });
+ * drawer.addChild(new Form({ fields: settingsFields }));
+ * drawer.open();
+ * ```
+ *
+ * Wire keyboard events via `handleKey(event)`.
+ */
+declare class Drawer extends Widget {
+    private _position;
+    private _panelWidth;
+    private _panelHeight;
+    private _title;
+    private _onClose;
+    private _backdropChar;
+    private _borderColor;
+    private _open;
+    /**
+     * Index into the flat list of focusable children that currently
+     * holds the "focused" slot inside the focus trap.
+     * Starts at -1 so the first Tab press naturally lands on index 0.
+     */
+    private _focusIndex;
+    focusable: boolean;
+    constructor(options: DrawerOptions);
+    /** Whether the drawer is currently open. */
+    get isOpen(): boolean;
+    /** Open the drawer and mark dirty. */
+    open(): void;
+    /** Close the drawer and mark dirty. */
+    close(): void;
+    /** Toggle open/close state. */
+    toggle(): void;
+    /**
+     * Handle keyboard input.
+     *
+     * | Key          | Action                          |
+     * |--------------|---------------------------------|
+     * | `Escape`     | Fire `onClose`                  |
+     * | `Tab`        | Move focus to next child        |
+     * | `Shift+Tab`  | Move focus to previous child    |
+     */
+    handleKey(event: KeyEvent): void;
+    /**
+     * Return a flat list of all focusable descendants in tree order.
+     * Used to implement the focus trap.
+     */
+    private _focusableChildren;
+    private _focusNext;
+    private _focusPrev;
+    private _applyFocus;
+    /**
+     * Compute the panel rect (position + dimensions) relative to the
+     * full widget rect.
+     */
+    private _panelRect;
+    protected _renderSelf(screen: Screen): void;
+}
+
 interface SelectOption {
     label: string;
     value: string;
@@ -86,7 +316,7 @@ declare class Select extends Widget {
     private _activeColor;
     private _onSelect?;
     focusable: boolean;
-    constructor(options: SelectOption[], config?: SelectOptions);
+    constructor(options: SelectOption[], config?: SelectOptions, style?: Partial<Style>);
     get selectedOption(): SelectOption | undefined;
     get selectedIndex(): number;
     get isOpen(): boolean;
@@ -99,6 +329,111 @@ declare class Select extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
+interface ComboboxOption {
+    label: string;
+    value: string;
+}
+interface ComboboxOptions {
+    placeholder?: string;
+    activeColor?: Style['fg'];
+    onSelect?: (value: string) => void;
+}
+declare class Combobox extends Widget {
+    private _options;
+    private _placeholder;
+    private _activeColor;
+    private _onSelect?;
+    private _inputValue;
+    private _committedValue;
+    private _isOpen;
+    private _selectedIndex;
+    focusable: boolean;
+    constructor(options: ComboboxOption[], config?: ComboboxOptions);
+    get value(): string;
+    get filtered(): ComboboxOption[];
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface LinearPromptOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface LinearPromptOptions {
+    question: string;
+    activeColor?: Style['fg'];
+    onSelect?: (option: LinearPromptOption, index: number) => void;
+}
+declare class LinearPrompt extends Widget {
+    private _options;
+    private _selectedIndex;
+    private _question;
+    private _activeColor;
+    private _onSelect?;
+    focusable: boolean;
+    constructor(options: LinearPromptOption[], config: LinearPromptOptions);
+    get selectedOption(): LinearPromptOption | undefined;
+    get selectedIndex(): number;
+    selectNext(): void;
+    selectPrev(): void;
+    confirm(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface Page {
+    name: string;
+    content: Widget;
+    overlay?: boolean;
+}
+interface PagesOptions {
+    style?: Partial<Style>;
+}
+declare class Pages extends Widget {
+    private _pages;
+    private _activePageName?;
+    constructor(pages: Page[], options?: PagesOptions);
+    get activePage(): string | undefined;
+    switchTo(name: string): void;
+    protected _renderSelf(_screen: Screen): void;
+    private _updatePageVisibility;
+}
+
+declare class ContentSwitcher extends Widget {
+    private _activeId?;
+    constructor(style?: Partial<Style>);
+    get activeId(): string | undefined;
+    addChild(child: Widget): void;
+    setActive(id: string): void;
+    protected _renderSelf(_screen: Screen): void;
+    private _updateChildVisibility;
+}
+
+interface SnippetPromptOptions {
+    validate?: Record<string, (value: string) => string | null>;
+}
+declare class SnippetPrompt extends Widget {
+    private _placeholders;
+    private _values;
+    private _errors;
+    private _validators;
+    private _activeIndex;
+    constructor(template: string, options?: SnippetPromptOptions);
+    readonly template: string;
+    get placeholders(): string[];
+    get activeField(): string | undefined;
+    get values(): Record<string, string>;
+    get errors(): Record<string, string>;
+    setValue(field: string, value: string): void;
+    nextField(): void;
+    prevField(): void;
+    validate(): boolean;
+    buildResult(): string;
+    protected _renderSelf(_screen: Screen): void;
+    private _parsePlaceholders;
+}
+
 interface MultiSelectOption {
     label: string;
     value: string;
@@ -128,6 +463,42 @@ declare class MultiSelect extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
+interface TransferItem {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface TransferOptions {
+    activeColor?: Style['fg'];
+    onChange?: (targetValues: string[]) => void;
+}
+declare class Transfer extends Widget {
+    private _sourceItems;
+    private _targetItems;
+    private _sourceCursorIndex;
+    private _targetCursorIndex;
+    private _activePane;
+    private _activeColor;
+    private _onChange?;
+    focusable: boolean;
+    constructor(items: TransferItem[], config?: TransferOptions);
+    get targetValues(): string[];
+    get sourceValues(): string[];
+    get targetItems(): TransferItem[];
+    get sourceItems(): TransferItem[];
+    get activePane(): 'source' | 'target';
+    get sourceCursorIndex(): number;
+    get targetCursorIndex(): number;
+    toggleActivePane(): void;
+    private _clampCursors;
+    selectNext(): void;
+    selectPrev(): void;
+    transferToTarget(): void;
+    transferToSource(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
 interface TreeNode {
     label: string;
     children?: TreeNode[];
@@ -153,6 +524,26 @@ declare class Tree extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
+interface SortPromptOptions {
+    activeColor?: Style['fg'];
+    onSubmit?: (items: string[]) => void;
+}
+declare class SortPrompt extends Widget {
+    private _items;
+    private _cursorIndex;
+    private _activeColor;
+    private _onSubmit?;
+    focusable: boolean;
+    constructor(items: string[], options?: SortPromptOptions);
+    selectNext(): void;
+    selectPrev(): void;
+    moveItemUp(): void;
+    moveItemDown(): void;
+    submit(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
 type ToastType = 'info' | 'success' | 'warning' | 'error';
 interface ToastMessage {
     text: string;
@@ -163,18 +554,22 @@ interface ToastOptions {
     position?: 'top-right' | 'bottom-right' | 'top-left' | 'bottom-left';
     durationMs?: number;
     maxVisible?: number;
+    /** Enable screen reader announcements (default: true) */
+    announce?: boolean;
 }
 declare class Toast extends Widget {
     private _messages;
     private _position;
     private _durationMs;
     private _maxVisible;
+    private _announce;
     constructor(options?: ToastOptions);
     push(text: string, type?: ToastType): void;
     info(text: string): void;
     success(text: string): void;
     warning(text: string): void;
     error(text: string): void;
+    private _announceToScreenReader;
     protected _renderSelf(screen: Screen): void;
 }
 
@@ -204,9 +599,13 @@ declare class ConfirmDialog extends Widget {
     selectCancel(): void;
     toggleSelection(): void;
     confirm(): void;
+    private handleKey;
     protected _renderSelf(screen: Screen): void;
 }
 
+type InputValidator = StandardSchemaV1 | ((v: unknown) => string | undefined | null);
+declare function validateInput(validator: InputValidator | undefined, value: unknown): string | undefined;
+
 interface FormField {
     name: string;
     label: string;
@@ -214,7 +613,7 @@ interface FormField {
     placeholder?: string;
     required?: boolean;
     options?: string[];
-    validate?: (value: string) => string | null;
+    validate?: InputValidator;
 }
 interface FormOptions {
     labelColor?: Style['fg'];
@@ -240,6 +639,8 @@ declare class Form extends Widget {
     insertChar(ch: string): void;
     deleteBack(): void;
     submit(): void;
+    /** Minimal key router — printable chars -> insertChar, backspace -> deleteBack */
+    handleKey(event: KeyEvent): void;
     protected _renderSelf(screen: Screen): void;
 }
 
@@ -278,10 +679,72 @@ declare class CommandPalette extends Widget {
     selectNext(): void;
     selectPrev(): void;
     confirm(): void;
+    /**
+     * Handle a KeyEvent from @termuijs/core.
+     *
+     * Wires all palette interactions to a single entry point so callers
+     * only need:
+     *   app.on('key', e => palette.handleKey(e))
+     *
+     * Built-in bindings (only active while the palette is visible):
+     *   Ctrl+P          — open / close (toggle)
+     *   ArrowUp / k     — move selection up
+     *   ArrowDown / j   — move selection down
+     *   Enter           — confirm selected command
+     *   Escape          — close
+     *   Backspace       — delete last character
+     *   any printable   — append character to query
+     *
+     * Ctrl+P is also handled while hidden so the palette can be opened.
+     * All handled events have stopPropagation() called automatically.
+     */
+    handleKey(event: KeyEvent): void;
     private _filter;
     protected _renderSelf(screen: Screen): void;
 }
 
+interface UseCommandPaletteOptions extends CommandPaletteOptions {
+    /** Initial command list */
+    commands: Command[];
+}
+interface UseCommandPaletteReturn {
+    /** The CommandPalette widget instance — add it to your layout */
+    palette: CommandPalette;
+    /**
+     * Pass this directly to your app's key event listener.
+     *
+     * @example
+     * ```ts
+     * const { palette, handleKey } = useCommandPalette({ commands })
+     * app.on('key', handleKey)
+     * layout.add(palette)
+     * ```
+     */
+    handleKey: (event: KeyEvent) => void;
+}
+/**
+ * Create a CommandPalette and return the widget plus a bound key handler.
+ *
+ * The handler automatically wires Ctrl+P (open/close), arrow navigation,
+ * Enter, Escape, Backspace, and character input — no manual binding needed.
+ *
+ * @example
+ * ```ts
+ * import { useCommandPalette } from '@termuijs/ui'
+ *
+ * const { palette, handleKey } = useCommandPalette({
+ *   commands: [
+ *     { id: 'save', label: 'Save File', shortcut: 'Ctrl+S', action: () => save() },
+ *     { id: 'quit', label: 'Quit', category: 'App', action: () => process.exit(0) },
+ *   ],
+ * })
+ *
+ * app.on('key', handleKey)
+ * rootLayout.add(palette)
+ * ```
+ */
+declare function useCommandPalette(options: UseCommandPaletteOptions): UseCommandPaletteReturn;
+
 declare class NonInteractiveError extends Error {
     constructor();
 }
@@ -341,6 +804,7 @@ declare class NotificationStore {
     push(message: string, type?: Notification['type'], durationMs?: number): string;
     dismiss(id: string): void;
     dismissAll(): void;
+    reset(): void;
     subscribe(fn: (notifications: Notification[]) => void): () => void;
     get notifications(): Notification[];
     private _emit;
@@ -461,6 +925,80 @@ declare class NumberInput extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
+interface TagInputOptions {
+    placeholder?: string;
+    defaultTags?: string[];
+    onChange?: (tags: string[]) => void;
+}
+declare class TagInput extends Widget {
+    private _tags;
+    private _draft;
+    private _placeholder;
+    private _onChange?;
+    focusable: boolean;
+    constructor(style?: Partial<Style>, options?: TagInputOptions);
+    /** The current list of committed tags. */
+    get tags(): string[];
+    /** Add a tag to the list. Empty/whitespace-only strings are ignored. */
+    addTag(tag: string): void;
+    /** Remove the last tag from the list. No-op if the list is empty. */
+    removeLast(): void;
+    /**
+     * Handle key events. Call this from your input loop.
+     */
+    handleKey(event: KeyEvent): void;
+    /** Format a single chip token using caps.unicode for glyph choice. */
+    private _formatChip;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface MaskedInputOptions {
+    /** Mask template. '_' = editable slot. Other chars are fixed. Example: '__/__/____' */
+    mask: string;
+    /** Character shown in empty slots. Default: '_' */
+    placeholder?: string;
+    /** Callback when all slots are filled */
+    onComplete?: (value: string) => void;
+    /** Callback on every change */
+    onChange?: (value: string) => void;
+    /** Color for the text */
+    color?: Color;
+}
+declare class MaskedInput extends Widget {
+    private _mask;
+    private _slots;
+    private _cursorSlotIndex;
+    private _placeholder;
+    private _onComplete?;
+    private _onChange?;
+    private _color?;
+    focusable: boolean;
+    constructor(style: Partial<Style> | undefined, options: MaskedInputOptions);
+    /** Get the complete masked string with current values filled in. */
+    getValue(): string;
+    /** Reset all slots to empty and position cursor at first slot. */
+    reset(): void;
+    /** Check if all slots are filled. */
+    private _isComplete;
+    /** Move cursor to the next empty slot, skipping filled ones. Auto-advance on input. */
+    private _advanceToNextEmpty;
+    /** Move cursor right to the next slot. */
+    private _moveCursorRight;
+    /** Move cursor to the previous slot. */
+    private _moveCursorLeft;
+    /** Insert a digit character at the current slot. Auto-advance past filled chars. */
+    private _insertDigit;
+    /** Clear the previous slot and move cursor back. */
+    private _deleteBack;
+    /**
+     * Handle key events. Call this from your input loop.
+     */
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+    /** Calculate the display position of the cursor (account for fixed chars before it). */
+    private _getCursorDisplayPos;
+}
+
 interface PathInputOptions {
     placeholder?: string;
     maxLength?: number;
@@ -557,4 +1095,1055 @@ declare class KeyboardShortcuts extends Widget {
     protected _renderSelf(screen: Screen): void;
 }
 
-export { type Command, CommandPalette, type CommandPaletteOptions, ConfirmDialog, type ConfirmDialogOptions, type ConfirmPromptOptions, Divider, type DividerOptions, Form, type FormField, type FormOptions, KeyboardShortcuts, type KeyboardShortcutsOptions, Modal, type ModalOptions, MultiSelect, type MultiSelectOption, type MultiSelectOptions, NonInteractiveError, type Notification, NotificationCenter, type NotificationCenterOptions, NotificationStore, NumberInput, type NumberInputOptions, PasswordInput, type PasswordInputOptions, PathInput, type PathInputOptions, Select, type SelectOption, type SelectOptions, type SelectPromptOptions, type ShortcutBinding, Spacer, type Tab, Tabs, type TabsOptions, type TextPromptOptions, Toast, type ToastMessage, type ToastOptions, type ToastType, Tree, type TreeNode, type TreeOptions, notifications, prompt, useNotifications };
+/** A single entry shown in the file picker list. */
+interface FileEntry {
+    /** Basename only (never a full path). */
+    name: string;
+    /** True when the entry is a directory. */
+    isDir: boolean;
+    /** Resolved absolute path. */
+    fullPath: string;
+}
+interface FilePickerOptions {
+    /** Initial directory. Defaults to `process.cwd()`. */
+    startPath?: string;
+    /**
+     * Extension filter (e.g. `['.ts', '.tsx']`).
+     * When provided, only files whose extension matches are shown.
+     * Directories are always shown regardless of this filter.
+     */
+    filter?: string[];
+    /** Show dot-files / dot-directories. Default: `false`. */
+    showHidden?: boolean;
+    /** Foreground colour for directory entries. Default: cyan. */
+    dirColor?: Style['fg'];
+    /** Foreground colour for file entries. Default: white. */
+    fileColor?: Style['fg'];
+    /** Foreground colour for the highlighted (active) row. Default: yellow. */
+    activeColor?: Style['fg'];
+    /** Called with the absolute path when the user selects a file. */
+    onSelect?: (path: string) => void;
+    /** Called when the user presses Escape. */
+    onCancel?: () => void;
+}
+/**
+ * FilePicker — an interactive file browser widget.
+ *
+ * Wire keyboard events via `handleKey(event)`.
+ * The widget is self-contained: it reads the filesystem on construction
+ * and every time the directory changes.
+ */
+declare class FilePicker extends Widget {
+    private _cwd;
+    private _filter;
+    private _showHidden;
+    private _entries;
+    private _cursor;
+    private _scrollTop;
+    private _dirColor;
+    private _fileColor;
+    private _activeColor;
+    private _onSelect?;
+    private _onCancel?;
+    focusable: boolean;
+    constructor(options?: FilePickerOptions);
+    /** The absolute path of the directory currently being displayed. */
+    get currentPath(): string;
+    /** The `FileEntry` the cursor is currently on, or `undefined` if the list is empty. */
+    get selectedEntry(): FileEntry | undefined;
+    /** Read-only snapshot of the currently visible entries. */
+    get entries(): readonly FileEntry[];
+    /** Current cursor index within `entries`. */
+    get cursorIndex(): number;
+    /** Move the cursor one row down. Clamps at the last entry. */
+    selectNext(): void;
+    /** Move the cursor one row up. Clamps at the first entry. */
+    selectPrev(): void;
+    /**
+     * Confirm the current selection:
+     * - If the entry is a directory (including `..`), navigate into it.
+     * - If the entry is a file, fire `onSelect(fullPath)`.
+     */
+    confirm(): void;
+    /**
+     * Navigate to the parent directory.
+     * No-ops when already at the filesystem root.
+     */
+    goUp(): void;
+    /** Fire `onCancel`. */
+    cancel(): void;
+    /**
+     * Convenience key handler. Wire this to your app's input loop.
+     *
+     * | Key               | Action         |
+     * |-------------------|----------------|
+     * | `up` / `k`        | `selectPrev()` |
+     * | `down` / `j`      | `selectNext()` |
+     * | `enter`/`return`  | `confirm()`    |
+     * | `backspace`       | `goUp()`       |
+     * | `escape`          | `cancel()`     |
+     */
+    handleKey(event: KeyEvent): void;
+    /**
+     * Navigate to an absolute directory path.
+     * Reloads the entry list and resets cursor / scroll.
+     */
+    private _navigateTo;
+    /**
+     * Read `this._cwd` and populate `this._entries`.
+     *
+     * Layout:
+     *  1. `..` parent entry (omitted at root)
+     *  2. Directories — alpha-sorted
+     *  3. Files       — alpha-sorted, filtered by `this._filter`
+     */
+    private _loadEntries;
+    /** Safe stat to check if a symlink target is a directory. Never throws. */
+    private _isDir;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface DatePickerOptions {
+    value?: Date;
+    onChange?: (date: Date) => void;
+}
+declare class DatePicker extends Widget {
+    private _selectedDate;
+    private _currentMonth;
+    private _onChange?;
+    focusable: boolean;
+    constructor(options?: DatePickerOptions);
+    get value(): Date;
+    set value(date: Date);
+    moveSelection(days: number): void;
+    changeMonth(months: number): void;
+    confirm(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface TimePickerOptions {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    use24Hour?: boolean;
+}
+declare class TimePicker extends Widget {
+    private _date;
+    private _use24Hour;
+    private _activeSegment;
+    private _onChange?;
+    focusable: boolean;
+    constructor(options?: TimePickerOptions);
+    get value(): Date;
+    set value(val: Date);
+    private _updateSegment;
+    private _nextSegment;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface DateRange {
+    start: Date;
+    end: Date;
+}
+interface DateRangePickerOptions {
+    value?: Partial<DateRange>;
+    onChange?: (range: Partial<DateRange>) => void;
+}
+declare class DateRangePicker extends Widget {
+    private _cursorDate;
+    private _currentMonth;
+    private _rangeStart;
+    private _rangeEnd;
+    private _selectionState;
+    private _onChange?;
+    focusable: boolean;
+    constructor(options?: DateRangePickerOptions);
+    private _zeroTime;
+    get range(): Partial<DateRange>;
+    moveSelection(days: number): void;
+    changeMonth(months: number): void;
+    confirm(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ColorPickerOptions {
+    value?: string | Color;
+    onChange?: (color: Color) => void;
+}
+declare class ColorPicker extends Widget {
+    private _selectedColor;
+    private _hexValue;
+    private _paletteIndex;
+    private _onChange?;
+    focusable: boolean;
+    constructor(options?: ColorPickerOptions);
+    get value(): Color;
+    set value(val: string | Color);
+    private _colorToHexStr;
+    private _colorsEqual;
+    private _updateFromHexInput;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface AccordionItem {
+    title: string;
+    body: string;
+}
+interface AccordionOptions {
+    /** Allow multiple sections open at once. Default: false (one at a time) */
+    multi?: boolean;
+    onToggle?: (index: number, open: boolean) => void;
+}
+declare class Accordion extends Widget {
+    private _items;
+    private _multi;
+    private _onToggle?;
+    private _focusIndex;
+    private _openSet;
+    focusable: boolean;
+    constructor(items: AccordionItem[], style?: Partial<Style>, opts?: AccordionOptions);
+    setItems(items: AccordionItem[]): void;
+    openSection(index: number): void;
+    closeSection(index: number): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface AppShellOptions {
+    header?: Widget;
+    footer?: Widget;
+    sidebar?: Widget;
+    main: Widget;
+    sidebarWidth?: number;
+}
+declare class AppShell extends Widget {
+    private _header?;
+    private _footer?;
+    private _sidebar?;
+    private _main;
+    private _sidebarWidth;
+    private _sidebarVisible;
+    private _mainScrollOffset;
+    constructor(options: AppShellOptions);
+    get sidebarVisible(): boolean;
+    getLayoutNode(): LayoutNode;
+    updateRect(rect: Rect): void;
+    handleResize(cols: number, rows: number): void;
+    scrollUp(lines?: number): void;
+    scrollDown(lines?: number): void;
+    handleKey(event: KeyEvent): void;
+    toggleSidebar(): void;
+    protected _renderSelf(_screen: Screen): void;
+    render(screen: Screen): void;
+    private _renderFooter;
+    private _renderFixedChild;
+    private _clampMainScroll;
+    private _bodyHeight;
+}
+
+interface PaginationOptions {
+    onChange?: (page: number) => void;
+}
+declare class Pagination extends Widget {
+    private _page;
+    private _totalPages;
+    private _onChange?;
+    focusable: boolean;
+    constructor(page: number, totalPages: number, options?: PaginationOptions);
+    get page(): number;
+    get totalPages(): number;
+    private _clamp;
+    setPage(n: number): void;
+    next(): void;
+    prev(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ScalePromptOptions {
+    max?: number;
+    question?: string;
+    endLabels?: [string, string];
+    activeColor?: Color;
+    onSelect?: (value: number) => void;
+}
+declare class ScalePrompt extends Widget {
+    private _max;
+    private _value;
+    private _question?;
+    private _endLabels?;
+    private _activeColor;
+    private _onSelect?;
+    focusable: boolean;
+    constructor(style?: Partial<Style>, opts?: ScalePromptOptions);
+    getValue(): number;
+    private _setValue;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SegmentedControlOptions {
+    options: string[];
+    value?: string;
+    activeColor?: Style['fg'];
+    onChange?: (value: string) => void;
+}
+declare class SegmentedControl extends Widget {
+    private _options;
+    private _selectedIndex;
+    private _activeColor;
+    private _onChange?;
+    focusable: boolean;
+    constructor(config: SegmentedControlOptions);
+    get value(): string;
+    private _setIndex;
+    next(): void;
+    prev(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+declare class SearchableSelect extends Widget {
+    private _searchQuery;
+    private _options;
+    private _selectedIndex;
+    constructor();
+    get searchQuery(): string;
+    get selectedOption(): string;
+    handleKey(event: KeyEvent): void;
+    selectNext(): void;
+    selectPrev(): void;
+    confirm(): void;
+    private _filterOptions;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface AutocompleteOptions {
+    /** List of search suggestions / candidates */
+    items: string[];
+    /** Callback when an item is selected or submitted */
+    onSelect?: (value: string) => void;
+    /** Callback when the query text changes */
+    onChange?: (value: string) => void;
+    /** Custom filter function to override default lowercase startsWith matching */
+    filter?: (query: string, item: string) => boolean;
+    /** Maximum number of suggestions to display in dropdown. Default: 5 */
+    maxSuggestions?: number;
+    /** Placeholder text when query is empty */
+    placeholder?: string;
+    /** Highlight color for the selected suggestion */
+    highlightColor?: Color;
+}
+declare class Autocomplete extends Widget {
+    private _items;
+    private _query;
+    private _isOpen;
+    private _selectedIndex;
+    private _onSelect?;
+    private _onChange?;
+    private _filter;
+    private _maxSuggestions;
+    private _placeholder;
+    private _highlightColor;
+    constructor(style?: Partial<Style>, options?: AutocompleteOptions);
+    get query(): string;
+    set query(value: string);
+    get items(): string[];
+    setItems(items: string[]): void;
+    private get _filteredItems();
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ToggleOptions {
+    defaultValue?: boolean;
+    label?: string;
+    onChange?: (value: boolean) => void;
+}
+declare class Toggle extends Widget {
+    private _value;
+    private _label?;
+    onChange?: (value: boolean) => void;
+    focusable: boolean;
+    constructor(options?: ToggleOptions);
+    get value(): boolean;
+    setValue(value: boolean): void;
+    toggle(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SwitchOptions {
+    defaultValue?: boolean;
+    label?: string;
+    onChange?: (value: boolean) => void;
+}
+declare class Switch extends Widget {
+    private _value;
+    private _label?;
+    onChange?: (value: boolean) => void;
+    focusable: boolean;
+    constructor(options?: SwitchOptions);
+    get value(): boolean;
+    setValue(value: boolean): void;
+    toggle(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface CheckboxOptions {
+    label: string;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+}
+declare class Checkbox extends Widget {
+    private _checked;
+    private _label;
+    onChange?: (checked: boolean) => void;
+    focusable: boolean;
+    constructor(options: CheckboxOptions);
+    get checked(): boolean;
+    setChecked(checked: boolean): void;
+    toggle(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface CheckboxGroupOption {
+    label: string;
+    value: string;
+}
+interface CheckboxGroupOptions {
+    options: CheckboxGroupOption[];
+    defaultValues?: string[];
+    onChange?: (selectedValues: string[]) => void;
+}
+declare class CheckboxGroup extends Widget {
+    private _options;
+    private _selected;
+    private _focusedIndex;
+    onChange?: (selectedValues: string[]) => void;
+    focusable: boolean;
+    constructor(options: CheckboxGroupOptions);
+    get selectedValues(): string[];
+    private emitChange;
+    selectNext(): void;
+    selectPrev(): void;
+    toggleCurrent(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ButtonGroupItem {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface ButtonGroupOptions {
+    activeColor?: Color;
+    inactiveColor?: Color;
+    onSelect?: (value: string) => void;
+}
+declare class ButtonGroup extends Widget {
+    private _items;
+    private _activeIndex;
+    private _activeColor;
+    private _inactiveColor;
+    private _onSelect?;
+    focusable: boolean;
+    constructor(items: ButtonGroupItem[], style?: Partial<Style>, opts?: ButtonGroupOptions);
+    setItems(items: ButtonGroupItem[]): void;
+    setActiveValue(value: string): void;
+    getActiveValue(): string;
+    handleKey(event: KeyEvent): void;
+    private _firstEnabledIndex;
+    private _move;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface WizardStep {
+    title: string;
+    render: () => Widget;
+    validate?: () => boolean | string;
+}
+interface WizardOptions {
+    style?: Partial<Style>;
+    onComplete?: (stepData: unknown[]) => void;
+}
+declare class Wizard extends Widget {
+    private _steps;
+    private _stepWidgets;
+    private _currentStepIndex;
+    private _error;
+    private _onComplete?;
+    focusable: boolean;
+    constructor(steps: WizardStep[], options?: WizardOptions);
+    get currentStepIndex(): number;
+    get error(): string;
+    get stepWidgets(): ReadonlyArray<Widget>;
+    nextStep(): void;
+    prevStep(): void;
+    complete(): void;
+    private _showStep;
+    private _getStepData;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface MultilineTextInputOptions {
+    placeholder?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+}
+declare class MultilineTextInput extends Widget {
+    /** Each element is one logical line (no '\n' inside). */
+    private _lines;
+    /** Cursor position: line index. */
+    private _cursorLine;
+    /** Cursor position: column index within the logical line. */
+    private _cursorCol;
+    private _placeholder;
+    private _onChange?;
+    private _onSubmit?;
+    focusable: boolean;
+    constructor(style?: Partial<Style>, options?: MultilineTextInputOptions);
+    /** Full text value with newlines. */
+    get value(): string;
+    /** Set text programmatically. */
+    set value(v: string);
+    /** Clear all content. */
+    clear(): void;
+    /** Insert a single printable character at the cursor position. */
+    insertChar(char: string): void;
+    /** Insert a newline — splits the current line at cursor. */
+    insertNewline(): void;
+    /** Delete the character before the cursor (Backspace). */
+    deleteBack(): void;
+    /** Delete the character after the cursor (Delete). */
+    deleteForward(): void;
+    moveCursorLeft(): void;
+    moveCursorRight(): void;
+    moveCursorUp(): void;
+    moveCursorDown(): void;
+    moveCursorHome(): void;
+    moveCursorEnd(): void;
+    submit(): void;
+    /**
+     * Handle key events. Call this from your application input loop.
+     * Returns true if the event was consumed.
+     */
+    handleKey(event: KeyEvent): boolean;
+    protected _renderSelf(screen: Screen): void;
+    private _notify;
+    private _softWrap;
+    /**
+     * Compute the display row and column for the current cursor position,
+     * given the content area width.
+     */
+    private _cursorDisplayPos;
+    /**
+     * Calculate a scroll offset so the cursor row is always visible.
+     */
+    private _calcScrollY;
+}
+
+interface BasicAuthCredentials {
+    username: string;
+    password: string;
+}
+interface BasicAuthPromptOptions {
+    usernameLabel?: string;
+    passwordLabel?: string;
+    onSubmit?: (credentials: BasicAuthCredentials) => void;
+}
+declare class BasicAuthPrompt extends Widget {
+    private _username;
+    private _password;
+    private _activeField;
+    private _opts;
+    private get _maskChar();
+    constructor(style?: Partial<Style>, opts?: BasicAuthPromptOptions);
+    getCredentials(): BasicAuthCredentials;
+    private onSubmit;
+    private deleteBackward;
+    private insertChar;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface TextAreaOptions {
+    /** Number of visible rows (default: 4) */
+    rows?: number;
+    placeholder?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+}
+/**
+ * TextArea - a multi-line text input field.
+ *
+ * Supports:
+ * - Multi-line editing (Enter for newline)
+ * - Cursor movement (up/down/left/right)
+ * - Ctrl+Enter to submit
+ * - Horizontal/Vertical scrolling when content overflows
+ */
+declare class TextArea extends Widget {
+    private _lines;
+    private _cursor;
+    private _placeholder;
+    private _onChange?;
+    private _onSubmit?;
+    constructor(style?: Partial<Style>, options?: TextAreaOptions);
+    get value(): string;
+    set value(v: string);
+    insertChar(char: string): void;
+    insertNewline(): void;
+    deleteBack(): void;
+    moveCursorLeft(): void;
+    moveCursorRight(): void;
+    moveCursorUp(): void;
+    moveCursorDown(): void;
+    handleKey(event: KeyEvent): void;
+    private _notify;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface StepperOptions {
+    completedColor?: Style['fg'];
+    activeColor?: Style['fg'];
+    pendingColor?: Style['fg'];
+    connectorChar?: string;
+}
+declare class Stepper extends Widget {
+    private _labels;
+    private _activeStep;
+    private _completedColor;
+    private _activeColor;
+    private _pendingColor;
+    private _connectorChar;
+    constructor(labels: string[], style?: Partial<Style>, opts?: StepperOptions);
+    get activeStep(): number;
+    setActiveStep(index: number): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type Shortcut = {
+    key: string;
+    label: string;
+};
+interface ShortcutHelpOverlayProps {
+    shortcuts?: Shortcut[];
+}
+declare function ShortcutHelpOverlay({ shortcuts }: ShortcutHelpOverlayProps): any;
+
+interface RadioGroupOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface RadioGroupOptions {
+    options: Array<RadioGroupOption>;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+}
+/**
+ * RadioGroup — renders a vertical list of mutually exclusive options.
+ *
+ * Example output (unicode):
+ *   (o) Dark
+ *   ( ) Light
+ *   ( ) System
+ */
+declare class RadioGroup extends Widget {
+    private _options;
+    private _selectedValue;
+    private _focusedIndex;
+    /** Fires whenever the confirmed selection changes. */
+    onChange?: (value: string) => void;
+    focusable: boolean;
+    constructor(config: RadioGroupOptions);
+    /** The value of the currently confirmed selection. */
+    get selectedValue(): string;
+    /** The index currently under the keyboard cursor. */
+    get focusedIndex(): number;
+    /** Move cursor to the next enabled option. */
+    selectNext(): void;
+    /** Move cursor to the previous enabled option. */
+    selectPrev(): void;
+    /** Confirm the focused option and fire onChange. */
+    confirm(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface RatingOptions {
+    /** Total number of stars. Default: 5 */
+    max?: number;
+    /** Initial rating. Default: 0 */
+    value?: number;
+    /** Filled star character. Default: '★' with ASCII fallback '*' */
+    filledChar?: string;
+    /** Empty star character. Default: '☆' with ASCII fallback '-' */
+    emptyChar?: string;
+    /** Color for filled stars */
+    filledColor?: Color;
+    /** Callback when the user confirms a rating via enter */
+    onSelect?: (value: number) => void;
+}
+/**
+ * Rating — renders a row of star glyphs for a 1-to-N rating.
+ *
+ * Example output (unicode, max=5, value=3):
+ *   ★★★☆☆
+ *
+ * ASCII fallback:
+ *   ***--
+ */
+declare class Rating extends Widget {
+    private _value;
+    private _max;
+    private _filledChar?;
+    private _emptyChar?;
+    private _filledColor?;
+    /** Callback when the user confirms a rating via enter. */
+    onSelect?: (value: number) => void;
+    focusable: boolean;
+    constructor(style?: Partial<Style>, opts?: RatingOptions);
+    /** The current rating value (0 to max). */
+    get value(): number;
+    /** The maximum number of stars. */
+    get max(): number;
+    /** Set the rating value (clamped to 0..max). Calls markDirty(). */
+    setValue(value: number): void;
+    /** Get the current rating value. */
+    getValue(): number;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ThemeSwitcherOptions {
+    themes?: string[];
+    activeTheme?: string;
+    onChange?: (theme: string) => void;
+    activeColor?: Style['fg'];
+}
+declare class ThemeSwitcher extends Widget {
+    private _themes;
+    private _activeTheme;
+    private _selectedIndex;
+    private _onChange?;
+    private _activeColor;
+    focusable: boolean;
+    constructor(options?: ThemeSwitcherOptions);
+    get activeTheme(): string;
+    set activeTheme(theme: string);
+    get themes(): string[];
+    get selectedIndex(): number;
+    selectNext(): void;
+    selectPrev(): void;
+    confirm(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface TreeSelectNode {
+    label: string;
+    value: string;
+    children?: TreeSelectNode[];
+    expanded?: boolean;
+}
+interface TreeSelectOptions {
+    multiple?: boolean;
+    activeColor?: Style['fg'];
+    onChange?: (values: string[]) => void;
+}
+declare class TreeSelect extends Widget {
+    private _roots;
+    private _cursorIndex;
+    private _selected;
+    private _multiple;
+    private _activeColor;
+    private _onChange?;
+    focusable: boolean;
+    constructor(roots: TreeSelectNode[], options?: TreeSelectOptions);
+    get selectedValues(): string[];
+    private _flatten;
+    selectNext(): void;
+    selectPrev(): void;
+    expand(): void;
+    collapse(): void;
+    toggleSelection(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface EmailInputOptions {
+    placeholder?: string;
+    /** Common domains to suggest after '@'. Default: ['gmail.com','outlook.com','yahoo.com'] */
+    domains?: string[];
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string, valid: boolean) => void;
+    errorColor?: Color;
+}
+declare class EmailInput extends Widget {
+    private _raw;
+    private _cursorPos;
+    private _placeholder;
+    private _domains;
+    private _onSubmit?;
+    private _onChange?;
+    private _errorColor;
+    focusable: boolean;
+    constructor(style?: Partial<Style>, opts?: EmailInputOptions);
+    getValue(): string;
+    isValid(): boolean;
+    private _notify;
+    insertChar(char: string): void;
+    deleteBack(): void;
+    deleteForward(): void;
+    moveCursorLeft(): void;
+    moveCursorRight(): void;
+    moveCursorHome(): void;
+    moveCursorEnd(): void;
+    autocompleteDomain(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface QuizQuestion {
+    question: string;
+    options: string[];
+    correctIndex: number;
+}
+interface QuizResult {
+    total: number;
+    correct: number;
+    answers: number[];
+}
+interface QuizPromptOptions {
+    correctColor?: Style['fg'];
+    wrongColor?: Style['fg'];
+    onComplete?: (result: QuizResult) => void;
+}
+declare class QuizPrompt extends Widget {
+    private _questions;
+    private _currentIndex;
+    private _selectedIndex;
+    private _answers;
+    private _feedback;
+    private _feedbackTimeout;
+    private _correctColor;
+    private _wrongColor;
+    private _onComplete?;
+    focusable: boolean;
+    constructor(questions: QuizQuestion[], style?: Partial<Style>, opts?: QuizPromptOptions);
+    getResult(): QuizResult;
+    handleKey(event: KeyEvent): void;
+    private submitAnswer;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface EditablePromptChoice {
+    type: 'checkbox' | 'text';
+    name: string;
+    message: string;
+    initial?: string;
+    disabled?: boolean;
+}
+interface EditablePromptResult {
+    selected: string[];
+    values: Record<string, string>;
+}
+interface EditablePromptOptions {
+    message?: string;
+    choices: EditablePromptChoice[];
+    onChange?: (result: EditablePromptResult) => void;
+}
+declare class EditablePrompt extends Widget {
+    private _message;
+    private _choices;
+    private _checkedNames;
+    private _textValues;
+    private _focusedIndex;
+    private _editingIndex;
+    private _editingValue;
+    private _onChange?;
+    focusable: boolean;
+    constructor(options: EditablePromptOptions);
+    get result(): EditablePromptResult;
+    private emitChange;
+    selectNext(): void;
+    selectPrev(): void;
+    toggleCheckbox(): void;
+    enterEditMode(): void;
+    submitEdit(): void;
+    cancelEdit(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface SurveyQuestion {
+    id: string;
+    question: string;
+    type: "text" | "choice";
+    options?: string[];
+}
+interface SurveyPromptOptions {
+    onComplete?: (answers: Record<string, string>) => void;
+}
+declare class SurveyPrompt extends Widget {
+    private _questions;
+    private _currentIndex;
+    private _answers;
+    private _textBuffer;
+    private _choiceIndex;
+    private _onComplete?;
+    focusable: boolean;
+    constructor(questions: SurveyQuestion[], style?: Partial<Style>, opts?: SurveyPromptOptions);
+    getAnswers(): Record<string, string>;
+    getCurrentIndex(): number;
+    private _advance;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    onSelect?: () => void;
+}
+interface BreadcrumbOptions {
+    items: BreadcrumbItem[];
+    currentColor?: Color;
+    inactiveColor?: Color;
+    separatorColor?: Color;
+}
+declare class Breadcrumb extends Widget {
+    private _items;
+    private _focusedIndex;
+    private _currentColor;
+    private _inactiveColor;
+    private _separatorColor;
+    focusable: boolean;
+    constructor(options: BreadcrumbOptions);
+    get items(): ReadonlyArray<BreadcrumbItem>;
+    get focusedIndex(): number;
+    setItems(items: BreadcrumbItem[]): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface DisclosureOptions {
+    summary: string;
+    defaultOpen?: boolean;
+    onToggle?: (open: boolean) => void;
+}
+declare class Disclosure extends Widget {
+    private _isOpen;
+    private summary;
+    private onToggleCallback?;
+    private content;
+    private _customStyle;
+    constructor(content: Widget, options: DisclosureOptions, style?: Partial<Style>);
+    get isOpen(): boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    handleKey(event: KeyEvent): void;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface ListbarItem {
+    label: string;
+    key?: string;
+    action?: () => void;
+    disabled?: boolean;
+}
+interface ListbarOptions {
+    activeColor?: Color;
+    keyColor?: Color;
+    separator?: string;
+}
+declare class Listbar extends Widget {
+    private _items;
+    private _activeIndex;
+    private _activeColor;
+    private _keyColor;
+    private _separator;
+    focusable: boolean;
+    constructor(items: ListbarItem[], style?: Partial<Style>, opts?: ListbarOptions);
+    get activeItem(): number;
+    setItems(items: ListbarItem[]): void;
+    handleKey(event: KeyEvent): void;
+    private _initActiveIndex;
+    private _nextEnabled;
+    protected _renderSelf(screen: Screen): void;
+}
+
+type PopoverPlacement = 'top' | 'bottom' | 'left' | 'right';
+interface PopoverOptions {
+    /** The placement of the popover relative to the anchor. Default: 'bottom'. */
+    placement?: PopoverPlacement;
+    /** Title shown in the panel border. */
+    title?: string;
+    /** Border color. */
+    borderColor?: Style['fg'];
+    /** * The specific terminal coordinates (row/col) to anchor this popover to.
+     * If omitted, it will attempt to use its own rect as the anchor bounds.
+     */
+    anchor?: {
+        x: number;
+        y: number;
+    };
+}
+declare class Popover extends Widget {
+    private _isOpen;
+    private content;
+    private opts;
+    constructor(content: Widget, style?: Partial<Style>, opts?: PopoverOptions);
+    get isOpen(): boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    /** Update the anchor coordinates dynamically */
+    setAnchor(x: number, y: number): void;
+    handleKey(event: KeyEvent): void;
+    private getBorderChars;
+    protected _renderSelf(screen: Screen): void;
+}
+
+interface FormContextValue {
+    submit: () => void;
+}
+interface FormBuilderProps {
+    onSubmit?: () => void;
+    children?: VNode | VNode[];
+}
+declare function FormBuilder({ onSubmit, children }: FormBuilderProps): VNode;
+declare function useForm(): FormContextValue;
+
+interface SearchInputOptions {
+    placeholder?: string;
+    debounce?: number;
+    onSearch?: (value: string) => void;
+}
+declare class SearchInput extends Widget {
+    private _value;
+    private _placeholder;
+    private _debounce;
+    onSearch?: (value: string) => void;
+    private _debounceTimer;
+    focusable: boolean;
+    constructor(options?: SearchInputOptions);
+    get value(): string;
+    setValue(value: string): void;
+    clear(): void;
+    handleKey(event: KeyEvent): void;
+    private _scheduleSearch;
+    private _cancelDebounce;
+    protected _renderSelf(screen: Screen): void;
+}
+
+export { Accordion, type AccordionItem, type AccordionOptions, AppShell, type AppShellOptions, Autocomplete, type AutocompleteOptions, type BasicAuthCredentials, BasicAuthPrompt, type BasicAuthPromptOptions, Breadcrumb, type BreadcrumbItem, type BreadcrumbOptions, ButtonGroup, type ButtonGroupItem, type ButtonGroupOptions, Carousel, type CarouselOptions, Checkbox, CheckboxGroup, type CheckboxGroupOption, type CheckboxGroupOptions, type CheckboxOptions, ColorPicker, type ColorPickerOptions, Combobox, type ComboboxOption, type ComboboxOptions, type Command, CommandPalette, type CommandPaletteOptions, ConfirmDialog, type ConfirmDialogOptions, type ConfirmPromptOptions, ContentSwitcher, DatePicker, type DatePickerOptions, type DateRange, DateRangePicker, type DateRangePickerOptions, Disclosure, type DisclosureOptions, Divider, type DividerOptions, Drawer, type DrawerOptions, type DrawerPosition, EditablePrompt, type EditablePromptChoice, type EditablePromptOptions, type EditablePromptResult, EmailInput, type EmailInputOptions, type FileEntry, FilePicker, type FilePickerOptions, Form, FormBuilder, type FormBuilderProps, type FormField, type FormOptions, type InputValidator, KeyboardShortcuts, type KeyboardShortcutsOptions, LinearPrompt, type LinearPromptOption, type LinearPromptOptions, Listbar, type ListbarItem, type ListbarOptions, MaskedInput, type MaskedInputOptions, Menu, MenuBar, type MenuBarItem, type MenuItem$1 as MenuBarItemType, type MenuBarOptions, type MenuItem, type MenuOptions, Modal, type ModalOptions, MultiSelect, type MultiSelectOption, type MultiSelectOptions, MultilineTextInput, type MultilineTextInputOptions, NonInteractiveError, type Notification, NotificationCenter, type NotificationCenterOptions, NotificationStore, NumberInput, type NumberInputOptions, type Page, Pages, type PagesOptions, Pagination, type PaginationOptions, PasswordInput, type PasswordInputOptions, PathInput, type PathInputOptions, Popover, type PopoverOptions, type PopoverPlacement, QuizPrompt, type QuizPromptOptions, type QuizQuestion, type QuizResult, RadioGroup, type RadioGroupOption, type RadioGroupOptions, RangeInput, Rating, type RatingOptions, ScalePrompt, type ScalePromptOptions, SearchInput, type SearchInputOptions, SearchableSelect, SegmentedControl, type SegmentedControlOptions, Select, type SelectOption, type SelectOptions, type SelectPromptOptions, type Shortcut, type ShortcutBinding, ShortcutHelpOverlay, type ShortcutHelpOverlayProps, Slider, SnippetPrompt, type SnippetPromptOptions, SortPrompt, type SortPromptOptions, Spacer, Stepper, type StepperOptions, SurveyPrompt, type SurveyPromptOptions, type SurveyQuestion, Switch, type SwitchOptions, type Tab, Tabs, type TabsOptions, TagInput, type TagInputOptions, TextArea, type TextAreaOptions, type TextPromptOptions, ThemeSwitcher, type ThemeSwitcherOptions, TimePicker, type TimePickerOptions, Toast, type ToastMessage, type ToastOptions, type ToastType, Toggle, type ToggleOptions, Transfer, type TransferItem, type TransferOptions, Tree, type TreeNode, type TreeOptions, TreeSelect, type TreeSelectNode, type TreeSelectOptions, type UseCommandPaletteOptions, type UseCommandPaletteReturn, Wizard, type WizardOptions, type WizardStep, notifications, prompt, useCommandPalette, useForm, useNotifications, validateInput };