import { Widget, BarChartOptions, Command, DiffViewOptions, JSONViewOptions, ToolCallOptions, TreeNode, BarGroup, ChatMessageOptions, CommandPaletteOptions, DiffLine, ProgressItem, MultiProgressOptions, StreamingTextOptions } from '@termuijs/widgets';
export { BarChartOptions, BarGroup, DiffLine, ToolCallStatus, TreeNode } from '@termuijs/widgets';
import { Style, Color } from '@termuijs/core';
export { batch } from '@termuijs/store';
export { AsyncState, KeyBinding, MotionPreferences, useAsync, useKeymap, useMotion } from '@termuijs/jsx';
export { Notification, useNotifications } from '@termuijs/ui';
export { useTheme } from '@termuijs/tss';
export { CpuMetrics, DiskMetrics, MemoryMetrics, NetworkMetrics, SystemInfo, useCpu, useDisk, useHttpHealth, useMemory, useNetwork, useSystemInfo, useTopProcesses } from '@termuijs/data';

/**
 * A reactive value — either a static value or a function that returns one.
 * Functions are re-evaluated on each refresh tick.
 */
type Reactive<T> = T | (() => T);
/**
 * Resolve a reactive value — calls the function if it is one,
 * otherwise returns the static value.
 */
declare function resolve<T>(value: Reactive<T>): T;
/**
 * Check if a value is a reactive function.
 */
declare function isReactive<T>(value: Reactive<T>): value is () => T;

/** Anything that can go into a layout slot */
type LayoutChild = Widget | string | Reactive<string>;
/**
 * Convert a loose child value into a proper Widget.
 * - Widget → pass through
 * - string → wrap in Text
 * - () => string → wrap in reactive Text (updated externally)
 */
declare function toWidget(child: LayoutChild, style?: Partial<Style>): Widget;
/**
 * Horizontal row layout — children arranged left-to-right.
 */
declare function row(...children: LayoutChild[]): Widget;
/**
 * Vertical column layout — children arranged top-to-bottom.
 */
declare function col(...children: LayoutChild[]): Widget;
/**
 * Grid layout — equal-sized cells in a rows × cols grid.
 */
declare function grid(rows: number, cols: number, items: LayoutChild[]): Widget;
/**
 * Vertical stack, children top-to-bottom, sized to content rather than
 * growing to fill. Use when col()'s flexGrow is too greedy.
 */
declare function stack(...children: LayoutChild[]): Widget;
/**
 * Flexible empty gap. Grows to fill free space and pushes siblings apart.
 * Optional fixed size in cells.
 */
declare function spacer(size?: number): Widget;

/**
 * The main fluent builder. Users call `app('title')` to start.
 *
 * @example
 * ```ts
 * app('My Dashboard')
 *   .rows(
 *     row(gauge('CPU', cpu.percent), gauge('Mem', memory.percent)),
 *     table('Processes', processes.top(5), ['name', 'cpu%']),
 *   )
 *   .keys({ q: 'quit', r: 'refresh' })
 *   .refresh('1s')
 *   .run();
 * ```
 */
declare class AppBuilder {
    private _title;
    private _children;
    private _keyMap;
    private _refreshInterval;
    private _onError;
    private _fullscreen;
    private _app;
    constructor(title: string);
    /**
     * Set the layout using vertical rows.
     */
    rows(...children: LayoutChild[]): this;
    /**
     * Bind hotkeys:
     * - `'quit'` — exits the app
     * - `'refresh'` — forces an immediate refresh
     * - `() => void` — custom handler
     */
    keys(map: Record<string, string | (() => void)>): this;
    /**
     * Set auto-refresh interval. Accepts: '500ms', '1s', '5s', '1m'.
     */
    refresh(interval: string): this;
    /** Register an error handler for reactive widget errors. */
    onError(handler: (err: unknown) => void): this;
    /**
     * Set fullscreen mode (default: true).
     */
    fullscreen(enabled: boolean): this;
    /**
     * Build the widget tree and run the app.
     * Returns a promise that resolves when the app exits.
     *
     * If widget-tree construction throws, an error panel is shown instead
     * of crashing the process (analogous to an ErrorBoundary for widget-mode).
     */
    run(): Promise<number>;
    /**
     * Build the root Box widget tree from the configured children, title, and key hints.
     * Throws on any widget-construction error — caught by run() as an error boundary.
     */
    private _buildRoot;
    /**
     * Wire up the App, key events, focus management, and refresh loop for a built root widget.
     */
    private _runWithRoot;
    /**
     * Walk the widget tree and update any reactive values.
     */
    private _refreshReactiveWidgets;
}
/**
 * Create a new TermUI app with a fluent builder API.
 *
 * @example
 * ```ts
 * import { app, row, gauge } from '@termuijs/quick';
 * import { cpu, memory } from '@termuijs/data';
 *
 * app('System Monitor')
 *   .rows(
 *     row(gauge('CPU', () => cpu.percent / 100)),
 *     row(gauge('Memory', () => memory.percent / 100)),
 *   )
 *   .keys({ q: 'quit' })
 *   .refresh('1s')
 *   .run();
 * ```
 */
declare function app(title: string): AppBuilder;

interface QuickTextOptions {
    bold?: boolean;
    dim?: boolean;
    italic?: boolean;
    color?: Color;
    align?: 'left' | 'center' | 'right';
}
declare function text(content: string | Reactive<string>, opts?: QuickTextOptions): Widget;
interface QuickGaugeOptions {
    color?: Color;
}
declare function gauge(label: string, value: Reactive<number>, opts?: QuickGaugeOptions): Widget;
type QuickTableRow = Record<string, string | number>;
declare function table(title: string, data: Reactive<QuickTableRow[]>, columns: string[]): Widget;
interface QuickListOptions {
    selectable?: boolean;
    onSelect?: (index: number) => void;
    renderItem?: (item: string, index: number, selected: boolean) => string;
}
declare function list(items: Reactive<string[]>, opts?: QuickListOptions): Widget;
interface QuickInputOptions {
    onSubmit?: (value: string) => void;
}
declare function input(placeholder: string, opts?: QuickInputOptions): Widget;
interface QuickSparklineOptions {
    color?: Color;
}
declare function sparkline(label: string, data: Reactive<number[]>, opts?: QuickSparklineOptions): Widget;
interface QuickStatusOptions {
    upColor?: Color;
    downColor?: Color;
}
declare function status(label: string, isUp: Reactive<boolean>, opts?: QuickStatusOptions): Widget;
interface QuickLogViewOptions {
    highlight?: Record<string, Color>;
}
declare function logView(lines: Reactive<string[]>, opts?: QuickLogViewOptions): Widget;
interface QuickTreeOptions {
    onSelect?: (node: TreeNode, path: number[]) => void;
    indent?: number;
}
declare function tree(data: TreeNode[], opts?: QuickTreeOptions): Widget;
interface QuickSkeletonOptions {
    variant?: 'pulse' | 'shimmer';
    intervalMs?: number;
    color?: Color;
}
declare function skeleton(opts?: QuickSkeletonOptions): Widget;
interface QuickGridOptions {
    gap?: number;
}
declare function gridWidget(columns: number, items: Widget[], opts?: QuickGridOptions): Widget;
interface QuickBarChartOptions extends BarChartOptions {
}
declare function barChart(data: Reactive<BarGroup[]>, opts?: QuickBarChartOptions): Widget;
interface QuickProgressBarOptions {
    color?: Color;
    showLabel?: boolean;
}
declare function progressBar(value: Reactive<number>, opts?: QuickProgressBarOptions): Widget;
interface QuickSpinnerOptions {
    label?: string;
    color?: Color;
}
declare function spinner(opts?: QuickSpinnerOptions): Widget;
interface QuickJSONViewOptions extends Pick<JSONViewOptions, 'onSelect' | 'indent'> {
}
declare function jsonView(data: unknown, opts?: QuickJSONViewOptions): Widget;
interface QuickDiffViewOptions extends Omit<DiffViewOptions, 'lines'> {
}
declare function diffView(diff: string | DiffLine[], opts?: QuickDiffViewOptions): Widget;
declare function streamingText(opts: StreamingTextOptions, style?: Partial<Style>): Widget;
declare function chatMessage(opts: ChatMessageOptions, style?: Partial<Style>): Widget;
interface QuickToolCallOptions extends Omit<ToolCallOptions, 'args'> {
    args?: Record<string, unknown>;
}
declare function toolCall(opts: QuickToolCallOptions, style?: Partial<Style>): Widget;
interface QuickCommand extends Omit<Command, 'id'> {
    id?: string;
}
declare function commandPalette(commands: QuickCommand[], opts?: Omit<CommandPaletteOptions, 'commands'>): Widget;
declare function multiProgress(items: ProgressItem[] | Reactive<ProgressItem[]>, opts?: Omit<MultiProgressOptions, 'items'>): Widget;
interface QuickTabsOptions {
    /** Index of the initially active tab. Default: 0 */
    active?: number;
    /** Called when the active tab changes. */
    onChange?: (index: number) => void;
}
/** Tabbed container. `tabs` is a list of [label, content] pairs. */
declare function tabs(items: Array<[string, Widget]>, opts?: QuickTabsOptions): Widget;
interface QuickSelectOptions {
    /** Called when an option is chosen. */
    onSelect?: (value: string, index: number) => void;
}
/** Single-choice select list from string options. */
declare function select(options: string[], opts?: QuickSelectOptions): Widget;

export { AppBuilder, type LayoutChild, type QuickBarChartOptions, type QuickCommand, type QuickDiffViewOptions, type QuickGaugeOptions, type QuickGridOptions, type QuickInputOptions, type QuickJSONViewOptions, type QuickListOptions, type QuickLogViewOptions, type QuickProgressBarOptions, type QuickSelectOptions, type QuickSkeletonOptions, type QuickSparklineOptions, type QuickSpinnerOptions, type QuickStatusOptions, type QuickTableRow, type QuickTabsOptions, type QuickTextOptions, type QuickToolCallOptions, type QuickTreeOptions, type Reactive, app, barChart, chatMessage, col, commandPalette, diffView, gauge, grid, gridWidget, input, isReactive, jsonView, list, logView, multiProgress, progressBar, resolve, row, select, skeleton, spacer, sparkline, spinner, stack, status, streamingText, table, tabs, text, toWidget, toolCall, tree };