import * as react_jsx_runtime from 'react/jsx-runtime';
import React__default, { ReactNode } from 'react';

interface ListItem {
    key: string;
    label: string;
    description?: string;
    color?: string;
}
interface ListProps {
    items: ListItem[];
    onSelect?: (item: ListItem) => void;
    filterable?: boolean;
    height?: number;
    cursor?: string;
}
declare function List({ items, onSelect, filterable, height, cursor, }: ListProps): react_jsx_runtime.JSX.Element;

interface Column<T = Record<string, unknown>> {
    key: keyof T & string;
    header: string;
    width?: number;
    align?: 'left' | 'right' | 'center';
}
interface TableProps<T extends Record<string, unknown> = Record<string, unknown>> {
    data: T[];
    columns: Column<T>[];
    sortable?: boolean;
    selectable?: boolean;
    onSelect?: (row: T) => void;
    maxRows?: number;
    borderColor?: string;
    /** Border style. Default: 'round' */
    borderStyle?: 'single' | 'double' | 'round' | 'bold' | 'singleDouble' | 'doubleSingle' | 'classic';
    /** Column separator string. Default: ' │ ' */
    columnSeparator?: string;
    /** Row separator fill character. Default: '─' */
    rowSeparatorChar?: string;
}
declare function Table<T extends Record<string, unknown> = Record<string, unknown>>({ data, columns, sortable, selectable, onSelect, maxRows, borderColor, borderStyle, columnSeparator, rowSeparatorChar, }: TableProps<T>): react_jsx_runtime.JSX.Element;

interface CardProps {
    title?: string;
    subtitle?: string;
    children: ReactNode;
    footer?: ReactNode;
    borderColor?: string;
    width?: number;
    /** Border style. Default: 'round' */
    borderStyle?: 'single' | 'double' | 'round' | 'bold' | 'singleDouble' | 'doubleSingle' | 'classic';
    /** Horizontal padding. Default: 1 */
    paddingX?: number;
    /** Vertical padding. Default: 0 */
    paddingY?: number;
    /** Character used for the footer divider. Default: '─' */
    footerDividerChar?: string;
}
declare function Card({ title, subtitle, children, footer, borderColor, width, borderStyle, paddingX, paddingY, footerDividerChar, }: CardProps): react_jsx_runtime.JSX.Element;

interface KeyValueItem {
    key: string;
    value: ReactNode;
    color?: string;
}
interface KeyValueProps {
    items: KeyValueItem[];
    keyWidth?: number;
    separator?: string;
    keyColor?: string;
    valueColor?: string;
}
declare function KeyValue({ items, keyWidth, separator, keyColor, valueColor, }: KeyValueProps): react_jsx_runtime.JSX.Element;

interface DefinitionItem {
    term: string;
    description: string;
}
interface DefinitionProps {
    items: DefinitionItem[];
    termColor?: string;
}
declare function Definition({ items, termColor }: DefinitionProps): react_jsx_runtime.JSX.Element;

interface VirtualListProps<T> {
    items: T[];
    renderItem: (item: T, index: number, isActive: boolean) => ReactNode;
    height: number;
    onSelect?: (item: T, index: number) => void;
    cursor?: string;
    overscan?: number;
    /** Enable built-in search/filter */
    searchable?: boolean;
    /** Custom filter function. Default: case-insensitive substring on String(item) */
    filterFn?: (item: T, query: string) => boolean;
    /** Called when search query changes (for server-side filtering) */
    onSearch?: (query: string) => void;
}
declare function VirtualList<T>({ items, renderItem, height, onSelect, overscan, searchable, filterFn, onSearch, }: VirtualListProps<T>): react_jsx_runtime.JSX.Element;

interface TreeNode {
    key: string;
    label: string;
    children?: TreeNode[];
    icon?: string;
}
interface TreeProps {
    nodes: TreeNode[];
    onSelect?: (node: TreeNode) => void;
    defaultExpanded?: string[];
    /** Icon shown for expanded branch nodes. Default: '▼' */
    expandedIcon?: string;
    /** Icon shown for collapsed branch nodes. Default: '▶' */
    collapsedIcon?: string;
    /** Default icon for leaf nodes (overridden by node.icon). Default: '•' */
    leafIcon?: string;
}
declare function Tree({ nodes, onSelect, defaultExpanded, expandedIcon, collapsedIcon, leafIcon, }: TreeProps): react_jsx_runtime.JSX.Element;

interface JSONViewProps {
    data: unknown;
    /** Initial indent spaces. Default: 2 */
    indent?: number;
    /** Whether nodes start collapsed. Default: false */
    collapsed?: boolean;
    label?: string;
}
declare function JSONView({ data, indent, collapsed, label }: JSONViewProps): react_jsx_runtime.JSX.Element;

interface DirectoryTreeProps {
    /** Root path to display. Default: process.cwd() */
    rootPath?: string;
    onSelect?: (path: string) => void;
    /** Max depth to show initially. Default: 2 */
    maxDepth?: number;
    /** Show hidden files (starting with .). Default: false */
    showHidden?: boolean;
    label?: string;
}
declare function DirectoryTree({ rootPath, onSelect, maxDepth, showHidden, label, }: DirectoryTreeProps): react_jsx_runtime.JSX.Element;

interface GitStatusProps {
    branch: string;
    staged?: number;
    modified?: number;
    ahead?: number;
    behind?: number;
}
/** Presentational git summary line for use with `useGit` from `termui/git`. */
declare function GitStatus({ branch, staged, modified, ahead, behind, }: GitStatusProps): react_jsx_runtime.JSX.Element;

interface DataGridColumn<T = Record<string, unknown>> {
    key: keyof T & string;
    header: string;
    width?: number;
    align?: 'left' | 'right' | 'center';
    render?: (value: unknown, row: T) => string;
    filterable?: boolean;
    sortable?: boolean;
}
interface DataGridProps<T extends Record<string, unknown> = Record<string, unknown>> {
    data: T[];
    columns: DataGridColumn<T>[];
    pageSize?: number;
    onRowSelect?: (row: T) => void;
    onCellEdit?: (row: T, key: string, value: string) => void;
    borderColor?: string;
    borderStyle?: 'single' | 'double' | 'round' | 'bold';
    showRowNumbers?: boolean;
    filterPlaceholder?: string;
    /** Default sort applied on first render (uncontrolled) */
    defaultSort?: {
        column: string;
        direction: 'asc' | 'desc';
    };
    /**
     * Controlled sort callback. When provided the component will NOT sort
     * internally — it just calls this handler and expects the consumer to
     * supply already-sorted `data`.
     */
    onSort?: (column: string, direction: 'asc' | 'desc' | null) => void;
    /** Column keys that are always rendered first (left-pinned). */
    pinnedColumns?: string[];
}
declare const DataGrid: <T extends Record<string, unknown> = Record<string, unknown>>(props: DataGridProps<T>) => React__default.ReactElement;

type DiffMode = 'unified' | 'split' | 'inline';
interface DiffViewProps {
    oldText: string;
    newText: string;
    filename?: string;
    language?: string;
    mode?: DiffMode;
    context?: number;
    showLineNumbers?: boolean;
}
declare const DiffView: React__default.NamedExoticComponent<DiffViewProps>;

export { Card, type CardProps, type Column, DataGrid, type DataGridColumn, type DataGridProps, Definition, type DefinitionItem, type DefinitionProps, type DiffMode, DiffView, type DiffViewProps, DirectoryTree, type DirectoryTreeProps, GitStatus, type GitStatusProps, JSONView, type JSONViewProps, KeyValue, type KeyValueItem, type KeyValueProps, List, type ListItem, type ListProps, Table, type TableProps, Tree, type TreeNode, type TreeProps, VirtualList, type VirtualListProps };