@startsimpli/ui 0.1.0 → 0.1.3

package/dist/components/unified-table/index.d.mts

@@ -0,0 +1,725 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import { ReactNode, RefObject } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { DropResult } from '@hello-pangea/dnd';
+
+interface UnifiedTableProps<TData> {
+    data: TData[];
+    columns: ColumnConfig<TData>[];
+    tableId: string;
+    getRowId: (row: TData) => string;
+    pagination?: PaginationConfig;
+    selection?: SelectionConfig;
+    filters?: FiltersConfig;
+    bulkActions?: BulkAction[];
+    rowActions?: RowAction<TData>[];
+    search?: SearchConfig;
+    sorting?: SortingConfig;
+    columnVisibility?: ColumnVisibilityConfig;
+    columnReorder?: ColumnReorderConfig;
+    columnResize?: ColumnResizeConfig;
+    inlineEdit?: InlineEditConfig<TData>;
+    savedViews?: SavedViewsConfig;
+    urlPersistence?: URLPersistenceConfig;
+    export?: ExportConfig;
+    onRowClick?: (row: TData) => void;
+    mobileConfig?: MobileCardConfig$1<TData>;
+    loading?: boolean;
+    loadingRows?: Set<string>;
+    className?: string;
+    emptyState?: ReactNode;
+    errorState?: ReactNode;
+}
+interface ColumnConfig<TData> {
+    id: string;
+    header: string | ((props: any) => ReactNode);
+    accessorKey?: string;
+    accessorFn?: (row: TData) => any;
+    cell?: (row: TData) => ReactNode;
+    sortable?: boolean;
+    sortingFn?: (a: TData, b: TData) => number;
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    mobilePrimary?: boolean;
+    mobileSecondary?: boolean;
+    hideOnMobile?: boolean;
+    hideable?: boolean;
+    editable?: boolean;
+    editType?: 'text' | 'number' | 'select' | 'date';
+    editOptions?: string[];
+    validate?: (value: any, row: TData) => string | null;
+}
+interface PaginationConfig {
+    enabled: boolean;
+    pageSize: number;
+    totalCount: number;
+    currentPage: number;
+    serverSide: boolean;
+    onPageChange: (page: number) => void;
+}
+interface SelectionConfig {
+    enabled: boolean;
+    selectAllPages?: boolean;
+    selectedIds?: Set<string>;
+    onSelectionChange?: (ids: Set<string>) => void;
+    onSelectAllPages?: (enabled: boolean) => void;
+    renderSelectionCell?: (row: any) => ReactNode;
+}
+interface FiltersConfig {
+    enabled: boolean;
+    position: 'top' | 'side';
+    collapsible: boolean;
+    config: FilterConfig;
+    value: FilterState;
+    onChange: (filters: FilterState) => void;
+    presets?: FilterPreset[];
+    showPresets?: boolean;
+}
+interface FilterConfig {
+    sections: FilterSection[];
+}
+interface FilterSection {
+    id: string;
+    type: 'chips' | 'buckets' | 'dropdown' | 'search' | 'range' | 'date' | 'collapsible' | 'custom';
+    label?: string;
+    filters?: FilterItem[];
+    buckets?: FilterBucket[];
+    customFilter?: CustomFilterHandler;
+}
+interface CustomFilterHandler {
+    render: (value: any, onChange: (value: any) => void) => ReactNode;
+    apply?: <TData>(data: TData[], filterValue: any) => TData[];
+    toApiParams?: (filterValue: any) => Record<string, string>;
+    defaultValue?: any;
+    isActive?: (value: any) => boolean;
+}
+interface FilterItem {
+    id: string;
+    label: string;
+    type?: 'chips' | 'dropdown' | 'search' | 'checkbox';
+    options?: string[];
+    multiple?: boolean;
+}
+interface FilterBucket {
+    label: string;
+    min: number;
+    max: number;
+}
+interface FilterState {
+    [key: string]: any;
+}
+interface FilterPreset {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    filters: FilterState;
+    description?: string;
+}
+interface BulkAction {
+    id: string;
+    label: string;
+    icon: LucideIcon;
+    variant: 'default' | 'gradient-purple' | 'gradient-green' | 'gradient-indigo' | 'gradient-orange' | 'gradient-blue';
+    onClick: (selectedIds: Set<string>) => Promise<void> | void;
+    maxSelection?: number;
+    confirmMessage?: string;
+    disabled?: (selectedIds: Set<string>) => boolean;
+}
+interface RowAction<TData> {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    onClick: (row: TData) => void;
+    disabled?: (row: TData) => boolean;
+    destructive?: boolean;
+    separator?: boolean;
+}
+interface SearchConfig {
+    enabled: boolean;
+    placeholder: string;
+    value: string;
+    onChange: (value: string) => void;
+    debounceMs?: number;
+    autoFocus?: boolean;
+    preserveFocus?: boolean;
+}
+interface SortingConfig {
+    enabled: boolean;
+    serverSide: boolean;
+    value?: SortState;
+    onChange?: (sort: SortState) => void;
+}
+interface SortState {
+    sortBy: string | null;
+    sortDirection: 'asc' | 'desc';
+}
+interface URLPersistenceConfig {
+    enabled: boolean;
+    debounceMs?: number;
+}
+interface ColumnVisibilityConfig {
+    enabled: boolean;
+    defaultVisible?: string[];
+    alwaysVisible?: string[];
+    persistKey?: string;
+}
+interface ColumnVisibilityState {
+    [columnId: string]: boolean;
+}
+interface ColumnReorderConfig {
+    enabled: boolean;
+    initialOrder?: string[] | null;
+    onOrderChange?: (order: string[]) => void;
+}
+interface ColumnResizeConfig {
+    enabled: boolean;
+    initialWidths?: {
+        [columnId: string]: number;
+    } | null;
+    minWidth?: number;
+    onWidthChange?: (widths: {
+        [columnId: string]: number;
+    }) => void;
+}
+interface InlineEditConfig<TData> {
+    enabled: boolean;
+    onSave: (rowId: string, columnId: string, value: any, row: TData) => Promise<void>;
+    onCancel?: () => void;
+    optimisticUpdate?: boolean;
+}
+interface SavedView {
+    id: string;
+    name: string;
+    isDefault?: boolean;
+    createdAt: string;
+    columnVisibility?: {
+        [columnId: string]: boolean;
+    };
+    columnOrder?: string[];
+    sortBy?: string | null;
+    sortDirection?: 'asc' | 'desc';
+    filters?: {
+        [key: string]: any;
+    };
+    pageSize?: number;
+}
+interface SavedViewsConfig {
+    enabled: boolean;
+    views?: SavedView[];
+    currentViewId?: string | null;
+    onSaveView: (view: Omit<SavedView, 'id' | 'createdAt'>) => Promise<SavedView>;
+    onUpdateView?: (viewId: string, updates: Partial<SavedView>) => Promise<void>;
+    onDeleteView?: (viewId: string) => Promise<void>;
+    onLoadView?: (viewId: string) => void;
+    getCurrentViewState?: () => Omit<SavedView, 'id' | 'name' | 'createdAt'>;
+}
+interface ExportConfig {
+    enabled: boolean;
+    baseFilename?: string;
+    formats?: ('csv' | 'excel')[];
+    showProgress?: boolean;
+    onExportStart?: (format: 'csv' | 'excel', scope: 'all' | 'filtered' | 'selected') => void;
+    onExportComplete?: (format: 'csv' | 'excel', scope: 'all' | 'filtered' | 'selected', rowCount: number) => void;
+    onExportError?: (error: Error) => void;
+}
+interface MobileCardConfig$1<TData> {
+    titleKey: string;
+    subtitleKey?: string;
+    descriptionKey?: string;
+    primaryFields: string[];
+    secondaryFields?: string[];
+    renderCustomContent?: (row: TData) => ReactNode;
+}
+interface TableState<TData> {
+    data: TData[];
+    filteredData: TData[];
+    displayedData: TData[];
+    currentPage: number;
+    pageSize: number;
+    totalPages: number;
+    totalCount: number;
+    selectedIds: Set<string>;
+    selectAllPages: boolean;
+    activeFilters: FilterState;
+    sortBy: string | null;
+    sortDirection: 'asc' | 'desc';
+    searchTerm: string;
+    debouncedSearchTerm: string;
+    loading: boolean;
+    loadingRows: Set<string>;
+    error: Error | null;
+    viewMode: 'table' | 'card';
+}
+interface UseTableStateReturn<TData> {
+    state: TableState<TData>;
+    setData: (data: TData[]) => void;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    setLoading: (loading: boolean) => void;
+    setLoadingRows: (ids: Set<string>) => void;
+    setError: (error: Error | null) => void;
+    setViewMode: (mode: 'table' | 'card') => void;
+}
+interface UseSelectionReturn {
+    selectedIds: Set<string>;
+    selectAllPages: boolean;
+    toggleRow: (id: string) => void;
+    toggleAll: () => void;
+    selectAllPagesToggle: () => void;
+    clearSelection: () => void;
+    getSelectedCount: () => number;
+}
+interface UsePaginationReturn {
+    currentPage: number;
+    pageSize: number;
+    totalPages: number;
+    totalCount: number;
+    canGoNext: boolean;
+    canGoPrevious: boolean;
+    goToPage: (page: number) => void;
+    goToFirstPage: () => void;
+    goToLastPage: () => void;
+    goToNextPage: () => void;
+    goToPreviousPage: () => void;
+    getPageNumbers: () => (number | '...')[];
+    getDisplayRange: () => {
+        start: number;
+        end: number;
+    };
+}
+interface UseFiltersReturn {
+    filters: FilterState;
+    setFilter: (key: string, value: any) => void;
+    clearFilter: (key: string) => void;
+    clearAllFilters: () => void;
+    hasActiveFilters: () => boolean;
+    getActiveFilterCount: () => number;
+}
+
+declare function UnifiedTable<TData>({ data, columns, tableId, getRowId, pagination: paginationConfig, selection: selectionConfig, filters: filtersConfig, bulkActions, rowActions, search: searchConfig, sorting: sortingConfig, columnVisibility: columnVisibilityConfig, columnReorder: columnReorderConfig, columnResize: columnResizeConfig, inlineEdit: inlineEditConfig, savedViews: savedViewsConfig, urlPersistence: urlPersistenceConfig, export: exportConfig, onRowClick, mobileConfig, loading, loadingRows, className, emptyState, errorState, }: UnifiedTableProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface MobileCardField {
+    key: string;
+    label?: string;
+    render?: (value: any, row: any) => ReactNode;
+    className?: string;
+}
+interface MobileCardAction {
+    id: string;
+    label: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    onClick: (row: any) => void | Promise<void>;
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+    disabled?: (row: any) => boolean;
+    hidden?: (row: any) => boolean;
+    className?: string;
+}
+interface MobileCardConfig<TData = any> {
+    titleKey: string;
+    titleRender?: (row: TData) => ReactNode;
+    subtitleKey?: string;
+    subtitleRender?: (row: TData) => ReactNode;
+    imageKey?: string;
+    imageRender?: (row: TData) => ReactNode;
+    primaryFields: MobileCardField[];
+    secondaryFields?: MobileCardField[];
+    actions?: MobileCardAction[];
+    renderCustomContent?: (row: TData) => ReactNode;
+    renderCustomHeader?: (row: TData) => ReactNode;
+    renderCustomFooter?: (row: TData) => ReactNode;
+    showSelection?: boolean;
+    onSelectionChange?: (id: string, selected: boolean) => void;
+    isSelected?: (row: TData) => boolean;
+    onClick?: (row: TData) => void;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+}
+interface MobileViewProps<TData = any> {
+    data: TData[];
+    config: MobileCardConfig<TData>;
+    getRowId?: (row: TData) => string;
+    loading?: boolean;
+    loadingRows?: Set<string>;
+    emptyState?: ReactNode;
+    className?: string;
+}
+interface CardProps<TData = any> {
+    row: TData;
+    config: MobileCardConfig<TData>;
+    rowId?: string;
+    isLoading?: boolean;
+    className?: string;
+}
+interface CardActionsProps {
+    actions: MobileCardAction[];
+    row: any;
+    className?: string;
+    maxVisibleActions?: number;
+}
+declare const MOBILE_BREAKPOINT = 768;
+
+declare function Card<TData = any>({ row, config, rowId, isLoading, className }: CardProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function CardActions({ actions, row, className, maxVisibleActions }: CardActionsProps): react_jsx_runtime.JSX.Element | null;
+
+declare function MobileView<TData = any>({ data, config, getRowId, loading, loadingRows, emptyState, className }: MobileViewProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface UseTableStateProps<TData> {
+    initialData?: TData[];
+    initialPageSize?: number;
+}
+declare function useTableState<TData>({ initialData, initialPageSize, }: UseTableStateProps<TData>): UseTableStateReturn<TData>;
+
+interface UseSelectionProps {
+    currentPageData: any[];
+    totalCount: number;
+    getRowId: (row: any) => string;
+    onSelectionChange?: (ids: Set<string>) => void;
+    onSelectAllPages?: (enabled: boolean) => void;
+    externalSelectedIds?: Set<string>;
+    externalSelectAllPages?: boolean;
+}
+declare function useSelection({ currentPageData, totalCount, getRowId, onSelectionChange, onSelectAllPages, externalSelectedIds, externalSelectAllPages, }: UseSelectionProps): UseSelectionReturn;
+
+interface UsePaginationProps {
+    totalCount: number;
+    initialPageSize?: number;
+    initialPage?: number;
+    serverSide?: boolean;
+    onPageChange?: (page: number) => void;
+}
+declare function usePagination({ totalCount, initialPageSize, initialPage, serverSide, onPageChange, }: UsePaginationProps): UsePaginationReturn;
+
+interface UseFiltersProps {
+    initialFilters?: FilterState;
+    onChange?: (filters: FilterState) => void;
+}
+declare function useFilters({ initialFilters, onChange, }: UseFiltersProps): UseFiltersReturn;
+
+interface ResponsiveBreakpoints {
+    mobile: number;
+    tablet: number;
+    desktop: number;
+}
+type ViewMode = 'mobile' | 'tablet' | 'desktop';
+declare function useResponsive(breakpoints?: ResponsiveBreakpoints): {
+    viewMode: ViewMode;
+    windowWidth: number;
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isMobileOrTablet: boolean;
+};
+
+interface UseColumnVisibilityOptions {
+    defaultVisibility?: ColumnVisibilityState;
+    persistKey?: string;
+    onVisibilityChange?: (visibility: ColumnVisibilityState) => void;
+}
+declare function useColumnVisibility({ defaultVisibility, persistKey, onVisibilityChange }?: UseColumnVisibilityOptions): {
+    columnVisibility: ColumnVisibilityState;
+    setColumnVisibility: React$1.Dispatch<React$1.SetStateAction<ColumnVisibilityState>>;
+    toggleColumn: (columnId: string) => void;
+    showColumn: (columnId: string) => void;
+    hideColumn: (columnId: string) => void;
+    showAllColumns: () => void;
+    hideAllColumns: (exceptColumns?: string[]) => void;
+    resetVisibility: () => void;
+    isColumnVisible: (columnId: string) => boolean;
+};
+
+interface TablePreferences {
+    columnVisibility: ColumnVisibilityState;
+    columnOrder: string[] | null;
+    defaultSortColumn: string | null;
+    defaultSortDirection: 'asc' | 'desc' | null;
+    pageSize: number;
+}
+interface UseTablePreferencesOptions {
+    tableId: string;
+    enabled?: boolean;
+    defaultColumnVisibility?: ColumnVisibilityState;
+    defaultPageSize?: number;
+    debounceMs?: number;
+    apiFetch?: typeof fetch;
+}
+interface UseTablePreferencesReturn {
+    preferences: TablePreferences | null;
+    isLoading: boolean;
+    error: Error | null;
+    updateColumnVisibility: (visibility: ColumnVisibilityState) => void;
+    updateColumnOrder: (order: string[]) => void;
+    updateSortPreference: (sort: SortState) => void;
+    updatePageSize: (size: number) => void;
+    resetPreferences: () => Promise<void>;
+}
+declare function useTablePreferences({ tableId, enabled, defaultColumnVisibility, defaultPageSize, debounceMs, apiFetch }: UseTablePreferencesOptions): UseTablePreferencesReturn;
+
+interface UseTableKeyboardProps<TData> {
+    data: TData[];
+    getRowId: (row: TData) => string;
+    selectedIds?: Set<string>;
+    onToggleRow?: (id: string) => void;
+    onToggleAll?: () => void;
+    onRowClick?: (row: TData) => void;
+    onDelete?: (ids: Set<string>) => void;
+    tableRef: RefObject<HTMLElement | null>;
+    enabled?: boolean;
+}
+interface UseTableKeyboardReturn {
+    focusedRowIndex: number;
+    setFocusedRowIndex: (index: number) => void;
+    handleKeyDown: (event: React.KeyboardEvent) => void;
+}
+/**
+ * Hook for handling keyboard navigation in UnifiedTable
+ *
+ * Features:
+ * - Arrow Up/Down: Navigate between rows
+ * - Enter: Expand/click row (trigger onRowClick)
+ * - Space: Toggle row selection
+ * - Tab: Move between interactive elements (native browser behavior)
+ * - Escape: Close menus/dialogs (handled by menu components)
+ * - Ctrl/Cmd+A: Select all rows
+ * - Delete: Trigger delete action if available
+ */
+declare function useTableKeyboard<TData>({ data, getRowId, selectedIds, onToggleRow, onToggleAll, onRowClick, onDelete, tableRef, enabled, }: UseTableKeyboardProps<TData>): UseTableKeyboardReturn;
+
+interface UseTableURLConfig {
+    tableId: string;
+    persistToUrl: boolean;
+    debounceMs?: number;
+}
+interface TableURLState {
+    sortBy: string | null;
+    sortDirection: 'asc' | 'desc';
+    filters: FilterState;
+    page: number;
+    search: string;
+}
+interface UseTableURLReturn {
+    getURLState: () => TableURLState;
+    setSortToURL: (sort: SortState) => void;
+    setFiltersToURL: (filters: FilterState) => void;
+    setPageToURL: (page: number) => void;
+    setSearchToURL: (search: string) => void;
+    clearURLState: () => void;
+    hasURLState: () => boolean;
+}
+/**
+ * Hook for persisting table state to URL query parameters.
+ * Enables shareability and browser navigation for table state.
+ *
+ * URL params are namespaced with tableId prefix:
+ * - {tableId}_sortBy: column ID
+ * - {tableId}_sortDir: 'asc' | 'desc'
+ * - {tableId}_page: current page number
+ * - {tableId}_search: search term
+ * - {tableId}_filter_{filterKey}: filter values (JSON encoded)
+ *
+ * @example
+ * const urlState = useTableURL({
+ *   tableId: 'firms',
+ *   persistToUrl: true,
+ *   debounceMs: 300
+ * })
+ *
+ * // Read initial state from URL
+ * const initialState = urlState.getURLState()
+ *
+ * // Update URL when state changes
+ * urlState.setSortToURL({ sortBy: 'name', sortDirection: 'asc' })
+ * urlState.setSearchToURL('acme')
+ */
+declare function useTableURL({ tableId, persistToUrl, debounceMs, }: UseTableURLConfig): UseTableURLReturn;
+
+interface UseColumnReorderOptions<TData> {
+    columns: ColumnConfig<TData>[];
+    initialOrder?: string[] | null;
+    enabled?: boolean;
+    onOrderChange?: (order: string[]) => void;
+}
+interface UseColumnReorderReturn<TData> {
+    orderedColumns: ColumnConfig<TData>[];
+    columnOrder: string[];
+    handleDragEnd: (result: DropResult) => void;
+    resetOrder: () => void;
+}
+declare function useColumnReorder<TData>({ columns, initialOrder, enabled, onOrderChange, }: UseColumnReorderOptions<TData>): UseColumnReorderReturn<TData>;
+
+interface ColumnWidths {
+    [columnId: string]: number;
+}
+interface UseColumnResizeOptions {
+    enabled?: boolean;
+    initialWidths?: ColumnWidths | null;
+    minWidth?: number;
+    onWidthChange?: (widths: ColumnWidths) => void;
+}
+interface UseColumnResizeReturn {
+    columnWidths: ColumnWidths;
+    getColumnWidth: (columnId: string, defaultWidth?: number) => number | undefined;
+    startResize: (columnId: string, startX: number, startWidth: number) => void;
+    resetWidths: () => void;
+    isResizing: boolean;
+    resizingColumn: string | null;
+}
+declare function useColumnResize({ enabled, initialWidths, minWidth, onWidthChange, }?: UseColumnResizeOptions): UseColumnResizeReturn;
+
+type CellRenderer<TData = any> = (value: any, row: TData) => ReactNode;
+interface RendererConfig {
+    [columnId: string]: CellRenderer;
+}
+declare function createCellRenderer<TData = any>(render: (value: any, row: TData) => ReactNode): CellRenderer<TData>;
+declare function getNestedValue(obj: any, path: string): any;
+declare const commonRenderers: {
+    text: CellRenderer<any>;
+    number: CellRenderer<any>;
+    currency: CellRenderer<any>;
+    percentage: CellRenderer<any>;
+    date: CellRenderer<any>;
+    datetime: CellRenderer<any>;
+    boolean: CellRenderer<any>;
+    badge: CellRenderer<any>;
+    truncate: CellRenderer<any>;
+    array: CellRenderer<any>;
+};
+declare function combineRenderers<TData = any>(...renderers: CellRenderer<TData>[]): CellRenderer<TData>;
+
+interface TableTheme {
+    name: string;
+    container: string;
+    header: string;
+    headerCell: string;
+    body: string;
+    row: string;
+    rowHover: string;
+    rowSelected: string;
+    cell: string;
+    pagination: string;
+    emptyState: string;
+    mobileCard: string;
+    mobileCardHeader: string;
+    mobileCardContent: string;
+}
+declare const defaultTheme: TableTheme;
+declare const compactTheme: TableTheme;
+declare const spaciousTheme: TableTheme;
+declare const minimalTheme: TableTheme;
+declare const themes: {
+    default: TableTheme;
+    compact: TableTheme;
+    spacious: TableTheme;
+    minimal: TableTheme;
+};
+type ThemeName = keyof typeof themes;
+declare function getTheme(themeName?: ThemeName): TableTheme;
+declare function createCustomTheme(baseTheme: ThemeName | undefined, overrides: Partial<TableTheme>): TableTheme;
+
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+declare function validateMobileCardConfig<TData = any>(config: MobileCardConfig<TData>): ValidationResult;
+declare function validateColumnConfig(columns: any[]): ValidationResult;
+declare function logValidationResults(configName: string, result: ValidationResult, throwOnError?: boolean): void;
+
+type ExportFormat = 'csv' | 'excel';
+interface ExportOptions {
+    filename: string;
+    format: ExportFormat;
+    includeHeaders?: boolean;
+    dateFormat?: string;
+}
+/**
+ * Exports data to CSV format
+ * @param data Array of data to export
+ * @param columns Visible columns configuration
+ * @param filename Name of the file to download (without extension)
+ * @param includeHeaders Whether to include header row (default: true)
+ */
+declare function exportToCSV<TData>(data: TData[], columns: ColumnConfig<TData>[], filename: string, includeHeaders?: boolean): void;
+/**
+ * Exports data to Excel format (XLSX)
+ * @param data Array of data to export
+ * @param columns Visible columns configuration
+ * @param filename Name of the file to download (without extension)
+ * @param includeHeaders Whether to include header row (default: true)
+ */
+declare function exportToExcel<TData>(data: TData[], columns: ColumnConfig<TData>[], filename: string, includeHeaders?: boolean): void;
+/**
+ * Generic export function that routes to CSV or Excel based on format
+ * @param data Array of data to export
+ * @param columns Visible columns configuration
+ * @param options Export options including format and filename
+ */
+declare function exportData<TData>(data: TData[], columns: ColumnConfig<TData>[], options: ExportOptions): void;
+/**
+ * Helper to generate a filename with timestamp
+ */
+declare function generateExportFilename(baseFilename: string): string;
+
+type ExportScope = 'all' | 'filtered' | 'selected';
+interface ExportButtonProps<TData> {
+    data: TData[];
+    filteredData?: TData[];
+    selectedData?: TData[];
+    columns: ColumnConfig<TData>[];
+    baseFilename?: string;
+    disabled?: boolean;
+    className?: string;
+    showProgress?: boolean;
+    onExportStart?: (format: 'csv' | 'excel', scope: ExportScope) => void;
+    onExportComplete?: (format: 'csv' | 'excel', scope: ExportScope, rowCount: number) => void;
+    onExportError?: (error: Error) => void;
+}
+
+interface SavedViewsDropdownProps {
+    views: SavedView[];
+    currentViewId?: string | null;
+    onSaveView: (view: Omit<SavedView, 'id' | 'createdAt'>) => Promise<SavedView>;
+    onUpdateView?: (viewId: string, updates: Partial<SavedView>) => Promise<void>;
+    onDeleteView?: (viewId: string) => Promise<void>;
+    onLoadView: (viewId: string) => void;
+    getCurrentViewState: () => Omit<SavedView, 'id' | 'name' | 'createdAt'>;
+}
+
+interface StandardTableToolbarProps<TData> {
+    searchEnabled?: boolean;
+    searchPlaceholder?: string;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchInputRef?: RefObject<HTMLInputElement | null>;
+    searchAutoFocus?: boolean;
+    columnVisibilityEnabled?: boolean;
+    hideableColumns?: ColumnConfig<TData>[];
+    columnVisibility?: ColumnVisibilityState;
+    onToggleColumnVisibility?: (columnId: string) => void;
+    exportEnabled?: boolean;
+    exportProps?: Omit<ExportButtonProps<TData>, 'data' | 'columns'>;
+    exportData?: TData[];
+    exportColumns?: ColumnConfig<TData>[];
+    savedViewsEnabled?: boolean;
+    savedViews?: SavedView[];
+    currentViewId?: string | null;
+    savedViewsProps?: Omit<SavedViewsDropdownProps, 'views' | 'currentViewId'>;
+    className?: string;
+}
+/**
+ * StandardTableToolbar provides a consistent toolbar layout across all tables.
+ *
+ * Layout (left to right):
+ * - Search input (left)
+ * - Export button
+ * - Columns dropdown (right)
+ */
+declare function StandardTableToolbar<TData>({ searchEnabled, searchPlaceholder, searchValue, onSearchChange, searchInputRef, searchAutoFocus, columnVisibilityEnabled, hideableColumns, columnVisibility, onToggleColumnVisibility, exportEnabled, exportProps, exportData, exportColumns, savedViewsEnabled, savedViews, currentViewId, savedViewsProps, className, }: StandardTableToolbarProps<TData>): react_jsx_runtime.JSX.Element;
+
+export { type BulkAction, Card, CardActions, type CardActionsProps, type CardProps, type CellRenderer, type ColumnConfig, type ColumnReorderConfig, type ColumnResizeConfig, type ColumnVisibilityConfig, type ColumnVisibilityState, type CustomFilterHandler, type ExportConfig, type ExportFormat, type ExportOptions, type FilterBucket, type FilterConfig, type FilterItem, type FilterPreset, type FilterSection, type FilterState, type FiltersConfig, type InlineEditConfig, MOBILE_BREAKPOINT, type MobileCardAction, type MobileCardConfig, type MobileCardField, MobileView, type MobileViewProps, type PaginationConfig, type RendererConfig, type ResponsiveBreakpoints, type RowAction, type SavedView, type SavedViewsConfig, type SearchConfig, type SelectionConfig, type SortState, type SortingConfig, StandardTableToolbar, type StandardTableToolbarProps, type TableState, type TableTheme, type TableURLState, type ThemeName, type URLPersistenceConfig, UnifiedTable, type UnifiedTableProps, type UseColumnVisibilityOptions, type UseFiltersReturn, type UsePaginationReturn, type UseSelectionReturn, type UseTableKeyboardProps, type UseTableKeyboardReturn, type UseTableStateReturn, type UseTableURLConfig, type UseTableURLReturn, type ValidationResult, type ViewMode, combineRenderers, commonRenderers, compactTheme, createCellRenderer, createCustomTheme, defaultTheme, exportData, exportToCSV, exportToExcel, generateExportFilename, getNestedValue, getTheme, logValidationResults, minimalTheme, spaciousTheme, themes, useColumnReorder, useColumnResize, useColumnVisibility, useFilters, usePagination, useResponsive, useSelection, useTableKeyboard, useTablePreferences, useTableState, useTableURL, validateColumnConfig, validateMobileCardConfig };