@vertz/tui 0.2.3

package/dist/index.d.ts

@@ -0,0 +1,720 @@
+/** Style attributes for a single terminal cell. */
+interface CellStyle {
+	color?: string;
+	bgColor?: string;
+	bold?: boolean;
+	dim?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	strikethrough?: boolean;
+}
+/** A single terminal cell: one character with style. */
+interface Cell {
+	char: string;
+	width: number;
+	style: CellStyle;
+}
+/** Computed layout box — the result of layout computation. */
+interface LayoutBox {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+/** Border style options. */
+type BorderStyle = "single" | "double" | "round" | "bold" | "none";
+/** Layout properties for a node. */
+interface LayoutProps {
+	direction: "row" | "column";
+	padding: number;
+	paddingX: number;
+	paddingY: number;
+	gap: number;
+	width: number | "full" | undefined;
+	height: number | undefined;
+	grow: number;
+	align: "start" | "center" | "end";
+	justify: "start" | "center" | "end" | "between";
+	border: BorderStyle;
+}
+/** A persistent TUI element (like <Box> or <Text>). Built once, mutated by effects. */
+interface TuiElement {
+	_tuiElement: true;
+	tag: string;
+	props: Record<string, unknown>;
+	style: CellStyle;
+	layoutProps: LayoutProps;
+	children: TuiChild[];
+	parent: TuiElement | null;
+	dirty: boolean;
+	/** Computed layout box. */
+	box: LayoutBox;
+}
+/** A persistent text node. Updated in-place by reactive effects. */
+interface TuiTextNode {
+	_tuiText: true;
+	text: string;
+	style: CellStyle;
+	dirty: boolean;
+	box: LayoutBox;
+}
+/** A conditional node that swaps between branches. */
+interface TuiConditionalNode {
+	_tuiConditional: true;
+	current: TuiElement | TuiTextNode | null;
+	dirty: boolean;
+}
+/** A list node that manages keyed items. */
+interface TuiListNode {
+	_tuiList: true;
+	items: TuiElement[];
+	dirty: boolean;
+}
+/** Any child in a persistent TUI tree. */
+type TuiChild = TuiElement | TuiTextNode | TuiConditionalNode | TuiListNode;
+/** Any renderable TUI content. */
+type TuiNode = TuiElement2 | TuiTextNode2 | TuiConditionalNode | TuiListNode | null | undefined | false | TuiNode[];
+/** A TUI element (like <Box> or <Text>). */
+interface TuiElement2 {
+	_tuiElement: true;
+	tag: string;
+	props: Record<string, unknown>;
+	style: CellStyle;
+	layoutProps: LayoutProps;
+	children: TuiNode[];
+	/** Computed layout box. */
+	box: LayoutBox;
+	/** Component function, if this is a component element. */
+	component?: (props: Record<string, unknown>) => TuiNode;
+}
+/** A text node (raw string or number). */
+interface TuiTextNode2 {
+	_tuiText: true;
+	text: string;
+	style: CellStyle;
+	box: LayoutBox;
+}
+/** Color type for Text components. */
+type Color = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | `#${string}`;
+import { Computed, DisposeFn as DisposeFn2, ReadonlySignal, Signal as Signal3 } from "@vertz/ui";
+import { batch, computed, createContext, onMount, signal, useContext } from "@vertz/ui";
+/**
+* Output adapter interface. Abstracts stdout for testing.
+*/
+interface OutputAdapter {
+	/** Write a string to the output. */
+	write(data: string): void;
+	/** Get terminal width in columns. */
+	readonly columns: number;
+	/** Get terminal height in rows. */
+	readonly rows: number;
+}
+/** A region of cells that changed between two buffers. */
+interface DirtyRegion {
+	row: number;
+	col: number;
+	cells: Cell[];
+}
+/**
+* 2D grid of cells representing the terminal screen.
+* Double-buffered: write to current, diff against previous.
+*/
+declare class TerminalBuffer {
+	readonly width: number;
+	readonly height: number;
+	private _cells;
+	constructor(width: number, height: number);
+	private static _createGrid;
+	/** Get a cell at the given position. Returns undefined if out of bounds. */
+	get(row: number, col: number): Cell | undefined;
+	/** Set a cell at the given position. No-op if out of bounds. */
+	set(row: number, col: number, char: string, style: CellStyle): void;
+	/** Write a string starting at the given position. */
+	writeString(row: number, col: number, text: string, style: CellStyle): void;
+	/** Fill the entire buffer with empty cells. */
+	clear(): void;
+	/**
+	* Diff this buffer against another, returning regions that differ.
+	* Each dirty region is a contiguous run of changed cells on one row.
+	*/
+	diff(previous: TerminalBuffer): DirtyRegion[];
+	/** Create a deep copy of this buffer. */
+	clone(): TerminalBuffer;
+	/** Get the text content of a specific row (no styling). */
+	getRowText(row: number): string;
+	/** Get all text content (no styling), rows joined by newlines. */
+	getText(): string;
+}
+/**
+* Test output adapter that captures rendered output for assertions.
+* Instead of writing to stdout, maintains a TerminalBuffer that can be inspected.
+*/
+declare class TestAdapter implements OutputAdapter {
+	readonly columns: number;
+	readonly rows: number;
+	/** The current terminal buffer (public for test inspection). */
+	buffer: TerminalBuffer;
+	/** Raw ANSI output captured from write calls. */
+	rawOutput: string[];
+	constructor(columns?: number, rows?: number);
+	write(data: string): void;
+	/** Get the text content of a specific row. */
+	textAt(row: number): string;
+	/** Get all text content, rows joined by newlines. */
+	text(): string;
+	/** Reset captured output. */
+	reset(): void;
+}
+/** Parsed key event from terminal stdin. */
+interface KeyEvent {
+	/** Key name: 'a', 'return', 'up', 'down', 'tab', 'escape', 'space', etc. */
+	name: string;
+	/** Printable character or empty string. */
+	char: string;
+	ctrl: boolean;
+	shift: boolean;
+	meta: boolean;
+}
+type KeyListener = (key: KeyEvent) => void;
+/**
+* Test stdin that allows programmatic key injection for testing.
+*/
+declare class TestStdin {
+	private _listeners;
+	/** Register a key listener. Returns a cleanup function. */
+	onKey(listener: KeyListener): () => void;
+	/** Simulate a key press. */
+	pressKey(name: string, options?: Partial<Omit<KeyEvent, "name">>): void;
+	/** Simulate typing a string character by character. */
+	type(text: string): void;
+	/** Remove all listeners. */
+	dispose(): void;
+}
+interface TuiMountOptions {
+	mode?: "inline" | "fullscreen" | "alternate";
+	stdout?: NodeJS.WriteStream;
+	stdin?: NodeJS.ReadStream;
+	/** Test adapter for headless rendering. */
+	adapter?: TestAdapter;
+	/** Test stdin for key injection. */
+	testStdin?: TestStdin;
+}
+interface TuiHandle {
+	unmount(): void;
+	waitUntilExit(): Promise<void>;
+	/** The output adapter (for testing). */
+	output: OutputAdapter & {
+		textAt?(row: number): string;
+		text?(): string;
+	};
+}
+/**
+* Mount a TUI application.
+*
+* The component function is called ONCE to build the persistent tree.
+* Reactive updates happen through effects created by the internals
+* (__child, __attr, __conditional, __list), which call scheduleRender()
+* to trigger re-renders.
+*
+* For backward compatibility, old-style components (using useComponentState
+* and jsx()) are still supported via an effect wrapper.
+*/
+declare function mount(app: () => TuiNode, options?: TuiMountOptions): TuiHandle;
+/** Exit the current TUI app. */
+declare function exit(): void;
+declare const tui: {
+	mount: typeof mount;
+	exit: typeof exit;
+};
+/** Configuration for the device code auth flow. */
+interface AuthConfig {
+	/** OAuth client ID. */
+	clientId: string;
+	/** URL for the device authorization endpoint (POST). */
+	deviceCodeUrl: string;
+	/** URL for the token endpoint (POST). */
+	tokenUrl: string;
+	/** OAuth scopes to request. */
+	scopes?: string[];
+	/** Callback invoked when tokens are successfully obtained. */
+	onTokens?: (tokens: AuthTokens) => void | Promise<void>;
+	/** Custom fetch function. Defaults to globalThis.fetch. */
+	fetcher?: (url: string, init: RequestInit) => Promise<Response>;
+	/** Title displayed in the auth box. Defaults to "Authenticate". */
+	title?: string;
+}
+/** RFC 8628 device authorization response. */
+interface DeviceCodeResponse {
+	device_code: string;
+	user_code: string;
+	verification_uri: string;
+	verification_uri_complete?: string;
+	expires_in: number;
+	interval: number;
+}
+/** OAuth 2.0 token response. */
+interface TokenResponse {
+	access_token: string;
+	token_type: string;
+	expires_in: number;
+	refresh_token?: string;
+	scope?: string;
+}
+/** Normalized tokens returned to the consumer. */
+interface AuthTokens {
+	accessToken: string;
+	refreshToken?: string;
+	expiresIn: number;
+}
+/** Status of the device code flow. */
+type AuthStatus = "idle" | "requesting-code" | "awaiting-approval" | "polling" | "success" | "error" | "expired" | "denied" | "cancelled";
+/** Error thrown when the user denies authorization. */
+declare class AuthDeniedError extends Error {
+	constructor();
+}
+/** Error thrown when the device code expires before approval. */
+declare class AuthExpiredError extends Error {
+	constructor();
+}
+/** Error thrown when the user cancels the flow (Esc key). */
+declare class AuthCancelledError extends Error {
+	constructor();
+}
+interface DeviceCodeAuthOptions extends AuthConfig {
+	/** Internal: test mount options. */
+	_mountOptions?: TuiMountOptions;
+}
+/** High-level imperative device code auth flow. */
+declare function DeviceCodeAuth(config: DeviceCodeAuthOptions): Promise<AuthTokens>;
+/** Request a device code from the authorization server. */
+declare function requestDeviceCode(config: AuthConfig): Promise<DeviceCodeResponse>;
+/**
+* Poll the token endpoint until authorization completes, is denied, or expires.
+* Handles `authorization_pending`, `slow_down`, `access_denied`, and `expired_token`.
+*/
+declare function pollTokenUntilComplete(config: AuthConfig, deviceCode: DeviceCodeResponse, signal?: AbortSignal): Promise<AuthTokens>;
+interface BannerProps {
+	title: string;
+	subtitle?: string;
+	border?: "single" | "double" | "round" | "bold";
+	titleColor?: string;
+}
+declare function Banner({ title, subtitle, border, titleColor }: BannerProps): TuiElement;
+interface BoxProps {
+	direction?: "row" | "column";
+	padding?: number;
+	paddingX?: number;
+	paddingY?: number;
+	gap?: number;
+	width?: number | "full";
+	height?: number;
+	grow?: number;
+	align?: "start" | "center" | "end";
+	justify?: "start" | "center" | "end" | "between";
+	border?: BorderStyle;
+	borderColor?: Color;
+	children?: TuiNode;
+}
+/**
+* Box — the only layout container.
+* Direction is a prop, not separate Row/Column components.
+*/
+declare function Box(_props: BoxProps): TuiNode;
+interface ConfirmProps {
+	message: string;
+	onSubmit?: (confirmed: boolean) => void;
+}
+declare function Confirm(props: ConfirmProps): TuiElement;
+interface DashboardProps {
+	/** Fixed element at the top of the dashboard. */
+	header?: TuiElement;
+	/** Fixed element at the bottom of the dashboard. */
+	footer?: TuiElement;
+	/** Content to display in the middle (scrollable area). */
+	children?: TuiChild;
+}
+/**
+* Dashboard — three-region layout for long-running CLI tools.
+*
+* Divides the terminal into:
+* - Header (fixed at top, 1 row minimum)
+* - Content (fills remaining space, grows to fit)
+* - Footer (fixed at bottom, 1 row minimum)
+*
+* Use with `tui.mount(App, { mode: 'alternate' })` for clean restore on exit.
+*/
+declare function Dashboard({ header, footer, children }: DashboardProps): TuiElement;
+interface SourceLine {
+	number: number;
+	text: string;
+}
+interface DiagnosticItem {
+	severity: "error" | "warning" | "info";
+	code: string;
+	message: string;
+	file?: string;
+	line?: number;
+	column?: number;
+	sourceLines?: SourceLine[];
+	highlightStart?: number;
+	highlightLength?: number;
+	suggestion?: string;
+}
+interface DiagnosticViewProps {
+	diagnostics: DiagnosticItem[];
+	showSource?: boolean;
+	showSuggestions?: boolean;
+}
+declare function DiagnosticView({ diagnostics, showSource, showSuggestions }: DiagnosticViewProps): TuiElement;
+interface DividerProps {
+	label?: string;
+	char?: string;
+	width?: number;
+	color?: string;
+}
+declare function Divider({ label, char, width, color }: DividerProps): TuiElement;
+interface KeyValueEntry {
+	key: string;
+	value: string;
+}
+interface KeyValueProps {
+	entries: KeyValueEntry[];
+	separator?: string;
+	keyBold?: boolean;
+}
+declare function KeyValue({ entries, separator, keyBold }: KeyValueProps): TuiElement;
+interface LogProps<T> {
+	items: T[];
+	children: (item: T) => TuiChild;
+}
+declare function Log<T>(props: LogProps<T>): TuiElement;
+interface LogStreamProps<T> {
+	/** Log entries to display. */
+	entries: T[];
+	/** Render function for each entry. */
+	children: (entry: T) => TuiChild;
+	/** Maximum number of entries to keep visible. Older entries are trimmed. */
+	maxLines?: number;
+}
+/**
+* LogStream — scrollable log output for CLI tools.
+*
+* Renders a list of entries in a column layout. When `maxLines` is set,
+* only the most recent entries are shown (tail behavior).
+*/
+declare function LogStream<T>({ entries, children: renderEntry, maxLines }: LogStreamProps<T>): TuiElement;
+interface SelectOption<T = string> {
+	label: string;
+	value: T;
+	hint?: string;
+}
+interface SelectProps<T = string> {
+	message: string;
+	options: SelectOption<T>[];
+	onSubmit?: (value: T) => void;
+}
+/**
+* Select prompt component.
+*
+* Uses `signal()` + internals API (`__element`, `__append`, `__child`) directly
+* instead of JSX because framework components are pre-built JS that doesn't pass
+* through the Vertz compiler. See the block comment at the top of `internals.ts`
+* for the full explanation of this dual-usage pattern.
+*/
+declare function Select<T>(props: SelectProps<T>): TuiElement;
+interface MultiSelectProps<T = string> {
+	message: string;
+	options: SelectOption<T>[];
+	defaultValue?: T[];
+	onSubmit?: (values: T[]) => void;
+}
+declare function MultiSelect<T>(props: MultiSelectProps<T>): TuiElement;
+interface PasswordInputProps {
+	value?: string;
+	onChange?: (value: string) => void;
+	onSubmit?: (value: string) => void;
+	placeholder?: string;
+}
+declare function PasswordInput(props: PasswordInputProps): TuiElement;
+interface ProgressBarProps {
+	value: number;
+	max: number;
+	label?: string;
+	width?: number;
+}
+declare function ProgressBar(props: ProgressBarProps): TuiElement;
+/**
+* Spacer — fills remaining space (grow: 1).
+* Used in row layouts to push content to opposite ends.
+*/
+declare function Spacer(_props: Record<string, never>): TuiNode;
+interface SpinnerProps {
+	label?: string;
+}
+declare function Spinner(props: SpinnerProps): TuiElement;
+interface TableColumn<T> {
+	key: keyof T & string;
+	header: string;
+	width?: number;
+	align?: "left" | "right" | "center";
+}
+interface TableProps<T extends Record<string, unknown>> {
+	data: T[];
+	columns: TableColumn<T>[];
+}
+declare function Table<T extends Record<string, unknown>>(props: TableProps<T>): TuiElement;
+type TaskStatus = "pending" | "running" | "success" | "error" | "skipped";
+interface TaskConfig {
+	label: string;
+	run: () => unknown | Promise<unknown>;
+}
+interface TaskResult {
+	label: string;
+	status: TaskStatus;
+	value?: unknown;
+	error?: Error;
+	duration: number;
+}
+interface TaskRunnerConfig {
+	tasks: TaskConfig[];
+}
+interface TaskRunnerHandle {
+	run(): Promise<TaskResult[]>;
+	component(): TuiElement;
+}
+declare function TaskRunner(config: TaskRunnerConfig): TaskRunnerHandle;
+interface TextProps {
+	color?: Color;
+	bgColor?: Color;
+	bold?: boolean;
+	dim?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	strikethrough?: boolean;
+	wrap?: "wrap" | "truncate" | "truncate-end";
+	children?: TuiNode;
+}
+/**
+* Text — styled text component.
+* Supports nesting for mixed styles.
+*/
+declare function Text(_props: TextProps): TuiNode;
+interface TextInputProps {
+	value?: string;
+	onChange?: (value: string) => void;
+	onSubmit?: (value: string) => void;
+	placeholder?: string;
+}
+declare function TextInput(props: TextInputProps): TuiElement;
+import { Context as Context_rri5bl } from "@vertz/ui";
+interface FocusState {
+	focused: boolean;
+}
+/** Focus context for interactive components. */
+declare const FocusContext: Context_rri5bl<FocusState>;
+/**
+* Hook to check if the current component has focus.
+* Returns { focused: boolean }.
+*/
+declare function useFocus(): FocusState;
+/**
+* Register a keyboard handler for the current app.
+* Calls the callback whenever a key is pressed.
+* Safe to call inside effects — deduplicates registrations.
+*/
+declare function useKeyboard(callback: (key: KeyEvent) => void): void;
+/** Maps key patterns (e.g. 'up', 'ctrl+c', 'shift+tab') to handler functions. */
+type KeyMap = Record<string, (key: KeyEvent) => void>;
+/**
+* Create a keyboard handler that dispatches key events to pattern-matched handlers.
+*
+* Patterns are parsed once at call time, not per keystroke. Matching is exact:
+* `'up'` won't match `ctrl+up`. First match wins. No match = no-op.
+*
+* @example
+* ```ts
+* useKeyboard(match({
+*   up: () => selectedIndex--,
+*   down: () => selectedIndex++,
+*   return: () => onSubmit(),
+*   'ctrl+c': () => tui.exit(),
+* }));
+* ```
+*/
+declare function match(keyMap: KeyMap): (key: KeyEvent) => void;
+/**
+* Detect whether the current environment is interactive (has a TTY).
+* Returns false in CI, piped stdin, or non-TTY environments.
+*/
+declare function isInteractive(): boolean;
+/** Error thrown when an interactive prompt is required but the environment is non-interactive. */
+declare class NonInteractiveError extends Error {
+	constructor(promptType: string);
+}
+import { Signal as Signal2 } from "@vertz/ui";
+type RenderFn = () => string;
+interface Renderable {
+	render: RenderFn;
+	dispose?: () => void;
+}
+type MessageType = "info" | "error" | "warning" | "success";
+interface MessageConfig {
+	type: MessageType;
+	children: (() => string) | string;
+}
+/** @deprecated Use `<Text>` with `symbols` instead. */
+declare function Message({ type, children }: MessageConfig): Renderable;
+interface Choice {
+	label: string;
+	value: string;
+}
+interface SelectListConfig {
+	title: () => string;
+	choices: () => readonly Choice[];
+	selectedIndex: Signal2<number>;
+}
+/** @deprecated Use `<Select>` instead. */
+declare function SelectList({ title, choices, selectedIndex }: SelectListConfig): Renderable;
+type TaskStatus2 = "pending" | "running" | "done" | "error";
+interface TaskConfig2 {
+	name: () => string;
+	status: Signal2<TaskStatus2>;
+	detail?: Signal2<string | undefined>;
+}
+/** @deprecated Use custom `<Box>` + `<Text>` + `<Spinner>` instead. */
+declare function Task({ name, status, detail }: TaskConfig2): Renderable;
+interface TaskItem {
+	name: string;
+	status: TaskStatus2;
+	detail?: string;
+}
+interface TaskListConfig {
+	title: () => string;
+	tasks: Signal2<readonly TaskItem[]>;
+}
+/** @deprecated Use custom JSX components instead. */
+declare function TaskList({ title, tasks }: TaskListConfig): Renderable;
+interface TaskHandle {
+	update(message: string): void;
+	succeed(message?: string): void;
+	fail(message?: string): void;
+}
+interface TaskGroup {
+	task(name: string, fn: (handle: TaskHandle) => Promise<void>): Promise<void>;
+	dismiss(): void;
+}
+interface TaskRunner2 {
+	group(name: string): TaskGroup;
+	info(message: string): void;
+	warn(message: string): void;
+	error(message: string): void;
+	success(message: string): void;
+	cleanup(): void;
+}
+/** @deprecated Use `prompt.spinner()` or custom JSX instead. */
+declare function createTaskRunner(): TaskRunner2;
+interface TextPromptConfig {
+	message: string;
+	placeholder?: string;
+	default?: string;
+	validate?: (value: string) => string | undefined;
+	_mountOptions?: TuiMountOptions;
+}
+interface SelectPromptConfig<T> {
+	message: string;
+	options: SelectOption<T>[];
+	default?: T;
+}
+interface MultiSelectPromptConfig<T> {
+	message: string;
+	options: SelectOption<T>[];
+	defaultValue?: T[];
+}
+interface ConfirmPromptConfig {
+	message: string;
+	default?: boolean;
+}
+interface PasswordPromptConfig {
+	message: string;
+	placeholder?: string;
+	default?: string;
+}
+interface SpinnerHandle {
+	start(message: string): void;
+	stop(message: string): void;
+}
+interface LogMethods {
+	info(message: string): void;
+	warn(message: string): void;
+	error(message: string): void;
+	success(message: string): void;
+}
+interface PromptAPI {
+	text(config: TextPromptConfig): Promise<string>;
+	select<T>(config: SelectPromptConfig<T>): Promise<T>;
+	multiSelect<T>(config: MultiSelectPromptConfig<T>): Promise<T[]>;
+	confirm(config: ConfirmPromptConfig): Promise<boolean>;
+	password(config: PasswordPromptConfig): Promise<string>;
+	spinner(): SpinnerHandle;
+	intro(title: string): void;
+	outro(message: string): void;
+	log: LogMethods;
+}
+/** Imperative prompt API — sugar built on top of persistent tree components. */
+declare const prompt: PromptAPI;
+interface RenderToStringOptions {
+	/** Terminal width in columns. Defaults to 80. */
+	width?: number;
+	/** Terminal height in rows. Defaults to 24. */
+	height?: number;
+}
+/**
+* Render a TUI component tree to an ANSI-formatted string.
+* No terminal or TTY required — works entirely in memory.
+*/
+declare function renderToString(node: TuiNode, options?: RenderToStringOptions): string;
+declare const symbols: Readonly<{
+	success: string;
+	error: string;
+	warning: string;
+	info: string;
+	arrow: string;
+	pointer: string;
+	bullet: string;
+	dash: string;
+}>;
+declare const colors: Readonly<{
+	success: string;
+	error: string;
+	warning: string;
+	info: string;
+	dim: string;
+	method: Readonly<{
+		GET: string;
+		POST: string;
+		PUT: string;
+		PATCH: string;
+		DELETE: string;
+	}>;
+}>;
+interface WizardStep<
+	TId extends string = string,
+	TValue = unknown
+> {
+	id: TId;
+	prompt: (ctx: WizardContext) => Promise<TValue>;
+}
+interface WizardContext {
+	answers: Record<string, unknown>;
+}
+interface WizardConfig<TSteps extends readonly WizardStep[]> {
+	steps: TSteps;
+	onStep?: (info: {
+		current: number;
+		total: number;
+		id: string;
+	}) => void;
+}
+type WizardResult<TSteps extends readonly WizardStep[]> = { [K in TSteps[number] as K["id"]] : K extends WizardStep<string, infer V> ? V : never };
+declare function wizard<const TSteps extends readonly WizardStep[]>(config: WizardConfig<TSteps>): Promise<WizardResult<TSteps>>;
+export { wizard, useKeyboard, useFocus, useContext, tui, symbols, signal, requestDeviceCode, renderToString, prompt, pollTokenUntilComplete, onMount, match, isInteractive, createTaskRunner, createContext, computed, colors, batch, WizardStep, WizardResult, WizardContext, WizardConfig, TuiMountOptions, TuiHandle, TokenResponse, TextProps, TextPromptConfig, TextInputProps, TextInput, Text, TaskStatus, TaskRunnerHandle, TaskRunnerConfig, TaskRunner, TaskResult, TaskList, TaskHandle, TaskGroup, TaskConfig, Task, TableProps, TableColumn, Table, SpinnerProps, Spinner, Spacer, SourceLine, Signal3 as Signal, SelectProps, SelectPromptConfig, SelectOption, SelectList, Select, RenderToStringOptions, ReadonlySignal, PromptAPI, ProgressBarProps, ProgressBar, PasswordPromptConfig, PasswordInputProps, PasswordInput, NonInteractiveError, MultiSelectProps, MultiSelectPromptConfig, MultiSelect, Message, LogStreamProps, LogStream, LogProps, Log, TaskRunner2 as LegacyTaskRunner, KeyValueProps, KeyValueEntry, KeyValue, KeyMap, KeyEvent, FocusContext, DividerProps, Divider, DisposeFn2 as DisposeFn, DiagnosticViewProps, DiagnosticView, DiagnosticItem, DeviceCodeResponse, DeviceCodeAuthOptions, DeviceCodeAuth, DashboardProps, Dashboard, ConfirmProps, ConfirmPromptConfig, Confirm, Computed, Color, BoxProps, Box, BannerProps, Banner, AuthTokens, AuthStatus, AuthExpiredError, AuthDeniedError, AuthConfig, AuthCancelledError };