react-table-craft 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,639 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ComponentType, ReactNode } from 'react';
+import { ColumnDef, Table, Column } from '@tanstack/react-table';
+import { ClassValue } from 'clsx';
+import * as export_to_csv from 'export-to-csv';
+
+/** A selectable option used in filter dropdowns. */
+interface Option {
+    label: string;
+    value: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+}
+/** Configuration for a text-searchable column (client-side filtering). */
+interface DataTableSearchableColumn<TData> {
+    id: keyof TData;
+    title: string;
+    type?: 'text' | 'number' | 'checkbox' | 'date';
+}
+/** Configuration for a server-side searchable column with a custom input handler. */
+interface DataTableQuerySearchable<TData> {
+    id: keyof TData;
+    title: string;
+    type?: 'text' | 'number';
+    handleInputChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    defaultSearch?: string;
+}
+/** Configuration for a filterable column with predefined selectable options. */
+interface DataTableFilterableColumn<TData> {
+    id: keyof TData;
+    title: string;
+    options: Option[];
+    /** When true, only one option can be selected at a time (radio behavior). */
+    isSingleSelect?: boolean;
+}
+/** Configuration for an advanced filter option (used in the filter builder UI). */
+interface DataTableFilterOption<TData> {
+    id: string;
+    label: string;
+    value: keyof TData | string;
+    items: Option[];
+    /** When true, this filter is part of a multi-condition group. */
+    isMulti?: boolean;
+}
+
+interface FilterOptions {
+    [key: string]: string | number | undefined;
+}
+
+interface CustomButtonProps {
+    text?: string;
+    function?: () => void;
+    className?: string;
+    icon?: React__default.ReactElement;
+    attr?: any;
+    children?: React__default.ReactNode;
+    toolTip?: string;
+}
+interface MoreActionsProps {
+    text?: string;
+    function?: () => void;
+    icon?: React__default.ReactElement;
+    disabled?: boolean;
+    attr?: any;
+    toolTip?: string;
+}
+interface CommonActionProps {
+    action?: () => void;
+    disabled?: boolean;
+    tooltip?: string;
+}
+interface Props {
+    editAction?: CommonActionProps;
+    showAction?: CommonActionProps;
+    deleteAction?: CommonActionProps;
+    cancelAction?: CommonActionProps;
+    downloadAction?: CommonActionProps;
+    className?: string;
+    customButtons?: CustomButtonProps[] | React__default.ReactElement;
+    text?: string;
+    dropMoreActions?: MoreActionsProps[];
+    useDropdown?: boolean;
+}
+declare const ButtonTooltip: ({ content }: {
+    content: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const TableActionsRow: ({ editAction, showAction, deleteAction, downloadAction, className, customButtons, text, dropMoreActions, useDropdown, cancelAction, }: Props) => react_jsx_runtime.JSX.Element;
+
+/** Deep-partial helper: makes every property (and nested property) optional. */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? U[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/** Adapter for framework-agnostic routing. */
+interface TableRouterAdapter {
+    /** Navigate to a URL string. */
+    push: (url: string) => void;
+    /** Replace current URL without adding to history. */
+    replace?: (url: string) => void;
+    /** Get current URL search params. */
+    getSearchParams: () => URLSearchParams;
+    /** Get current pathname. */
+    getPathname: () => string;
+}
+/** Feature flags controlling which UI elements are rendered. */
+interface TableFeatureFlags {
+    /** Show search inputs. */
+    search: boolean;
+    /** Show filter dropdowns. */
+    filter: boolean;
+    /** Show pagination controls. */
+    pagination: boolean;
+    /** Show column visibility toggle. */
+    columnVisibility: boolean;
+    /** Show CSV export button. */
+    csvExport: boolean;
+    /** Enable row selection checkboxes. */
+    rowSelection: boolean;
+    /** Show table/card view toggle. */
+    viewToggle: boolean;
+    /** Show floating action bar for selected rows. */
+    floatingBar: boolean;
+    /** Enable advanced filter builder UI. */
+    advancedFilter: boolean;
+    /** Enable column sorting. */
+    sorting: boolean;
+}
+/** Pagination configuration. */
+interface TablePaginationConfig {
+    /** Available page size options in the dropdown. */
+    pageSizeOptions: number[];
+    /** Default number of rows per page. */
+    defaultPageSize: number;
+}
+/** Search configuration. */
+interface TableSearchConfig {
+    /** Debounce delay in milliseconds for search input. */
+    debounceMs: number;
+    /** Minimum number of characters before search triggers. */
+    minSearchLength: number;
+}
+/** Internationalization configuration. */
+interface TableI18nConfig {
+    /** Current locale string (e.g. 'en', 'ar'). */
+    locale: string;
+    /** Text direction: 'ltr', 'rtl', or 'auto' (derived from locale). */
+    direction: 'ltr' | 'rtl' | 'auto';
+    /** Custom translation function. When provided, used for all UI strings. */
+    translationFn?: (key: string) => string;
+    /** Translation namespace (for organizational purposes). */
+    namespace: string;
+}
+/** Performance tuning configuration. */
+interface TablePerformanceConfig {
+    /** Memoization strategy: 'smart' (default), 'aggressive', or 'manual'. */
+    memoStrategy: 'smart' | 'aggressive' | 'manual';
+    /** Number of extra rows rendered above/below the visible area for virtualization. */
+    virtualizationOverscan: number;
+    /** Whether to batch state updates. */
+    batchUpdates: boolean;
+}
+/** Enterprise-grade configuration. */
+interface TableEnterpriseConfig {
+    /** Enforce strict ARIA compliance. */
+    strictAccessibility: boolean;
+    /** Wrap table in error boundary for graceful recovery. */
+    errorRecovery: boolean;
+    /** Enable debug mode with extra logging. */
+    debugMode: boolean;
+}
+/** Developer experience configuration (dev-only). */
+interface TableDevConfig {
+    /** Show console warnings for misconfigurations. */
+    warnings: boolean;
+    /** Show performance optimization hints. */
+    performanceHints: boolean;
+    /** Threshold in ms for flagging slow renders. */
+    renderCostThresholdMs: number;
+}
+/** Plugin interface for extending table config. */
+interface TablePlugin {
+    /** Unique plugin name. */
+    name: string;
+    /** Merge priority (lower = applied first). */
+    priority: number;
+    /** Partial config to deep-merge. */
+    config: DeepPartial<TableConfig>;
+    /** Callback invoked after config resolution. */
+    onResolve?: (resolvedConfig: TableConfig) => void;
+}
+/** Root config interface — the fully resolved config shape. */
+interface TableConfig {
+    features: TableFeatureFlags;
+    pagination: TablePaginationConfig;
+    search: TableSearchConfig;
+    i18n: TableI18nConfig;
+    performance: TablePerformanceConfig;
+    enterprise: TableEnterpriseConfig;
+    dev: TableDevConfig;
+    plugins: TablePlugin[];
+    /** Optional router adapter for URL synchronization. */
+    router?: TableRouterAdapter;
+}
+/** What consumers pass — everything optional via DeepPartial. */
+type TableConfigInput = DeepPartial<TableConfig>;
+
+interface PaginationMeta {
+    current_page: number;
+    last_page: number;
+    per_page: number;
+    total: number;
+    from?: number;
+    to?: number;
+}
+interface PaginationLinks {
+    first?: string;
+    last?: string;
+    prev?: string | null;
+    next?: string | null;
+}
+interface Pagination {
+    meta: PaginationMeta;
+    links?: PaginationLinks;
+}
+interface BackendPagination {
+    meta: PaginationMeta;
+    links?: PaginationLinks;
+}
+
+type BaseProps$3<TData, TValue> = {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    pageCount: number;
+    pageSize?: number;
+    filterableColumns?: DataTableFilterableColumn<TData>[];
+    showFilter?: boolean;
+    showPagination?: boolean;
+    floatingBar?: boolean;
+    addItemPagePath?: {
+        url: string;
+        text?: string;
+    };
+    deleteRowsAction?: React$1.MouseEventHandler<HTMLButtonElement>;
+    isShowExportButtons?: {
+        isShow: boolean;
+        ignoredCols?: string[];
+        fileName?: string;
+    };
+    customButtons?: CustomButtonProps[] | React$1.ReactElement;
+    isLoading?: boolean;
+    customCss?: string;
+    isShowAdvancedFilter?: boolean;
+    config?: TableConfigInput;
+};
+type QueryFilterProps$4<TData, TValue> = {
+    isQueryFilter: true;
+    handleFilterChange: (key: keyof FilterOptions, value: string | number | undefined) => void;
+    filterableQuery: DataTableFilterableColumn<TData>[];
+    filterableColumns?: never;
+    currentFilters?: FilterOptions;
+    onClearFilters?: () => void;
+};
+type LocalFilterProps$4<TData, TValue> = {
+    isQueryFilter?: false;
+    handleFilterChange?: never;
+    filterableQuery?: never;
+    filterableColumns?: DataTableFilterableColumn<TData>[];
+    currentFilters?: never;
+    onClearFilters?: never;
+};
+type QuerySearchProps$2<TData, TValue> = {
+    isQuerySearch: true;
+    searchableQuery: DataTableQuerySearchable<TData>[];
+    searchableColumns?: never;
+};
+type LocalSearchProps$1<TData, TValue> = {
+    isQuerySearch?: false;
+    searchableQuery?: never;
+    searchableColumns?: DataTableSearchableColumn<TData>[];
+};
+type QueryPaginationProps$2<TData, TValue> = {
+    isQueryPagination: true;
+    paginationData: {
+        paginationResponse: Pagination;
+        onPageChange: (page: number) => void;
+        onPageSizeChange: (size: number) => void;
+    };
+};
+type LocalPaginationProps$2<TData, TValue> = {
+    isQueryPagination?: false;
+    paginationData?: never;
+};
+type DataTableProps<TData, TValue> = BaseProps$3<TData, TValue> & (QuerySearchProps$2<TData, TValue> | LocalSearchProps$1<TData, TValue>) & (QueryPaginationProps$2<TData, TValue> | LocalPaginationProps$2<TData, TValue>) & (QueryFilterProps$4<TData, TValue> | LocalFilterProps$4<TData, TValue>);
+declare function DataTable<TData, TValue>({ columns, data, pageCount, pageSize: defaultPageSize, filterableColumns, searchableColumns, showFilter, showPagination, floatingBar, deleteRowsAction, addItemPagePath, isShowExportButtons, customButtons, isQueryPagination, paginationData, isQuerySearch, searchableQuery, isLoading, isQueryFilter, handleFilterChange, filterableQuery, currentFilters, onClearFilters, customCss, isShowAdvancedFilter, config: instanceConfig, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+type BaseProps$2<TData, TValue> = {
+    data: TData[];
+    pageCount: number;
+    pageSize?: number;
+    columns: ColumnDef<TData, TValue>[];
+    showFilter?: boolean;
+    showPagination?: boolean;
+    addItemPagePath?: {
+        url: string;
+        text?: string;
+    };
+    isShowExportButtons?: {
+        isShow: boolean;
+        ignoredCols?: string[];
+        fileName?: string;
+    };
+    customButtons?: CustomButtonProps[] | React$1.ReactElement;
+    withIndex?: boolean;
+    isLoading?: boolean;
+    customCss?: string;
+    isShowAdvancedFilter?: boolean;
+    config?: TableConfigInput;
+};
+type QueryFilterProps$3<TData, TValue> = {
+    isQueryFilter: true;
+    handleFilterChange: (key: keyof FilterOptions, value: string | number | undefined) => void;
+    filterableQuery: DataTableFilterableColumn<TData>[];
+    filterableColumns?: never;
+    currentFilters?: FilterOptions;
+    onClearFilters?: () => void;
+};
+type LocalFilterProps$3<TData, TValue> = {
+    isQueryFilter?: false;
+    handleFilterChange?: never;
+    filterableQuery?: never;
+    filterableColumns?: DataTableFilterableColumn<TData>[];
+    currentFilters?: never;
+    onClearFilters?: never;
+};
+type QuerySearchProps$1<TData, TValue> = {
+    isQuerySearch: true;
+    searchableQuery: DataTableQuerySearchable<TData>[];
+    searchableColumns?: never;
+};
+type LocalSearchProps<TData, TValue> = {
+    isQuerySearch?: false;
+    searchableQuery?: never;
+    searchableColumns?: DataTableSearchableColumn<TData>[];
+};
+type QueryPaginationProps$1<TData, TValue> = {
+    isQueryPagination: true;
+    paginationData: {
+        paginationResponse: Pagination;
+        onPageChange: (page: number) => void;
+        onPageSizeChange: (size: number) => void;
+    };
+};
+type LocalPaginationProps$1<TData, TValue> = {
+    isQueryPagination?: false;
+    paginationData?: never;
+};
+type TasksTableShellProps<TData, TValue> = BaseProps$2<TData, TValue> & (QuerySearchProps$1<TData, TValue> | LocalSearchProps<TData, TValue>) & (QueryPaginationProps$1<TData, TValue> | LocalPaginationProps$1<TData, TValue>) & (QueryFilterProps$3<TData, TValue> | LocalFilterProps$3<TData, TValue>);
+declare function ClientSideTable<TData, TValue>({ data, pageCount, pageSize, columns: initialColumns, searchableColumns, showFilter, showPagination, filterableColumns, addItemPagePath, isShowExportButtons, customButtons, withIndex, isQueryPagination, paginationData, isLoading, isQuerySearch, searchableQuery, isQueryFilter, handleFilterChange, filterableQuery, currentFilters, onClearFilters, customCss, isShowAdvancedFilter, config, }: TasksTableShellProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+type ViewMode = 'table' | 'cards';
+type BaseProps$1<TData> = {
+    table: Table<TData>;
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    newRowLink?: string;
+    deleteRowsAction?: React$1.MouseEventHandler<HTMLButtonElement>;
+    addItemPagePath?: {
+        url: string;
+        text?: string;
+    };
+    isShowExportButtons?: {
+        isShow: boolean;
+        ignoredCols?: string[];
+        fileName?: string;
+    };
+    customButtons?: CustomButtonProps[] | React$1.ReactElement;
+    customCss?: string;
+};
+type QueryFilterProps$2<TData> = {
+    isQueryFilter: true;
+    handleFilterChange: (key: keyof FilterOptions, value: string | number | undefined) => void;
+    filterableQuery: DataTableFilterableColumn<TData>[];
+    filterableColumns?: never;
+    currentFilters?: FilterOptions;
+    onClearFilters?: () => void;
+};
+type LocalFilterProps$2<TData> = {
+    isQueryFilter?: false;
+    handleFilterChange?: never;
+    filterableQuery?: never;
+    filterableColumns?: DataTableFilterableColumn<TData>[];
+    currentFilters?: never;
+    onClearFilters?: never;
+};
+type QuerySearchProps<TData> = BaseProps$1<TData> & {
+    isQuerySearch: true;
+    searchableQuery: DataTableQuerySearchable<TData>[];
+    searchableColumns?: never;
+};
+type LocalQuerySearchProps<TData> = BaseProps$1<TData> & {
+    isQuerySearch?: false;
+    searchableQuery?: never;
+    searchableColumns?: DataTableSearchableColumn<TData>[];
+};
+type DataTableToolbarProps$1<TData> = BaseProps$1<TData> & (QuerySearchProps<TData> | LocalQuerySearchProps<TData>) & (QueryFilterProps$2<TData> | LocalFilterProps$2<TData>);
+declare function DataTableToolbar<TData>({ table, viewMode, onViewModeChange, filterableColumns, searchableColumns, newRowLink, addItemPagePath, deleteRowsAction, isShowExportButtons, customButtons, isQuerySearch, searchableQuery, isQueryFilter, handleFilterChange, filterableQuery, currentFilters, onClearFilters, customCss, }: DataTableToolbarProps$1<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableToolbarProps<TData> {
+    table: Table<TData>;
+    filterableColumns?: DataTableFilterableColumn<TData>[];
+    searchableColumns?: DataTableSearchableColumn<TData>[];
+    addItemPagePath?: {
+        url: string;
+        text?: string;
+    };
+    isShowExportButtons?: {
+        isShow: boolean;
+        ignoredCols?: string[];
+        fileName?: string;
+    };
+    customButtons?: CustomButtonProps[] | React$1.ReactElement;
+}
+declare function DataTableMobileToolbar<TData>({ table, filterableColumns, searchableColumns, addItemPagePath, isShowExportButtons, customButtons, }: DataTableToolbarProps<TData>): react_jsx_runtime.JSX.Element;
+
+type BaseProps<TData> = {
+    table: Table<TData>;
+    pageSizeOptions?: number[];
+};
+type QueryPaginationProps<TData> = BaseProps<TData> & {
+    isQueryPagination: true;
+    paginationData: {
+        paginationResponse: Pagination;
+        onPageChange: (page: number) => void;
+        onPageSizeChange: (size: number) => void;
+    };
+};
+type LocalPaginationProps<TData> = BaseProps<TData> & {
+    isQueryPagination?: false;
+    paginationData?: never | undefined;
+};
+type DataTablePaginationProps<TData> = QueryPaginationProps<TData> | LocalPaginationProps<TData>;
+declare function DataTablePagination<TData>({ table, pageSizeOptions, isQueryPagination, paginationData, }: DataTablePaginationProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableColumnHeaderProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface DataTableViewOptionsProps<TData> {
+    table: Table<TData>;
+}
+declare function DataTableViewOptions<TData>({ table }: DataTableViewOptionsProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableCardViewProps<TData> {
+    table: Table<TData>;
+}
+declare function DataTableCardView<TData>({ table }: DataTableCardViewProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableFloatingBarProps<TData> extends React.HTMLAttributes<HTMLElement> {
+    table: Table<TData>;
+    deleteRowsAction?: React.MouseEventHandler<HTMLButtonElement>;
+}
+declare function DataTableFloatingBar<TData>({ table, deleteRowsAction, className, ...props }: DataTableFloatingBarProps<TData>): react_jsx_runtime.JSX.Element | null;
+
+interface DataTableRoleFilterProps<TData> {
+    column?: Column<TData, unknown>;
+    title?: string;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    paramKey?: string;
+}
+declare function DataTableRoleFilter<TData>({ column, title, options, paramKey, }: DataTableRoleFilterProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableFacetedFilterBase<TData, TValue> {
+    title?: string;
+    options: Option[];
+    variant?: 'popover' | 'command';
+    className?: string;
+}
+type QueryFilterProps$1<TData> = {
+    isQueryFilter: true;
+    column?: DataTableFilterableColumn<TData>;
+    handleFilterChange: (key: keyof FilterOptions, value: string | undefined) => void;
+    currentValue?: string;
+};
+type LocalFilterProps$1<TData, TValue> = {
+    isQueryFilter?: false;
+    handleFilterChange?: never;
+    column?: Column<TData, TValue>;
+    currentValue?: never;
+};
+type DataTableFacetedFilterProps<TData, TValue> = DataTableFacetedFilterBase<TData, TValue> & (QueryFilterProps$1<TData> | LocalFilterProps$1<TData, TValue>);
+declare function DataTableFacetedFilter<TData, TValue>({ column, title, options, variant, className, isQueryFilter, handleFilterChange, currentValue, }: DataTableFacetedFilterProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface DataTableSingleSelectFilterBase<TData, TValue> {
+    title?: string;
+    options: Option[];
+    className?: string;
+    placeholder?: string;
+}
+type QueryFilterProps<TData> = {
+    isQueryFilter: true;
+    column?: DataTableFilterableColumn<TData>;
+    handleFilterChange: (key: keyof FilterOptions, value: string | undefined) => void;
+    currentValue?: string;
+};
+type LocalFilterProps<TData, TValue> = {
+    isQueryFilter?: false;
+    handleFilterChange?: never;
+    column?: Column<TData, TValue>;
+    currentValue?: never;
+};
+type DataTableSingleSelectFilterProps<TData, TValue> = DataTableSingleSelectFilterBase<TData, TValue> & (QueryFilterProps<TData> | LocalFilterProps<TData, TValue>);
+declare function DataTableSingleSelectFilter<TData, TValue>({ column, title, options, className, isQueryFilter, handleFilterChange, currentValue, }: DataTableSingleSelectFilterProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface DataTableLoadingProps {
+    columnCount: number;
+    rowCount?: number;
+}
+declare const DataTableLoading: React__default.NamedExoticComponent<DataTableLoadingProps>;
+
+interface DataTableAdvancedFilterProps<TData> {
+    options: DataTableFilterOption<TData>[];
+    selectedOptions: DataTableFilterOption<TData>[];
+    setSelectedOptions: React$1.Dispatch<React$1.SetStateAction<DataTableFilterOption<TData>[]>>;
+    children?: React$1.ReactNode;
+}
+declare function DataTableAdvancedFilter<TData>({ options, selectedOptions, setSelectedOptions, children, }: DataTableAdvancedFilterProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableAdvancedFilterItemProps<TData> {
+    table: Table<TData>;
+    selectedOption: DataTableFilterOption<TData>;
+    setSelectedOptions: React$1.Dispatch<React$1.SetStateAction<DataTableFilterOption<TData>[]>>;
+}
+declare function DataTableAdvancedFilterItem<TData>({ table, selectedOption, setSelectedOptions, }: DataTableAdvancedFilterItemProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableAdvancedToolbarProps<TData> {
+    table: Table<TData>;
+    searchableColumns?: DataTableSearchableColumn<TData>[];
+    filterableColumns?: DataTableFilterableColumn<TData>[];
+    addItemPagePath?: string;
+}
+declare function DataTableAdvancedToolbar<TData>({ table, filterableColumns, searchableColumns, addItemPagePath, }: DataTableAdvancedToolbarProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare const operators: {
+    label: string;
+    value: string;
+}[];
+interface DataTableMultiFilterProps<TData> {
+    table: Table<TData>;
+    allOptions: DataTableFilterOption<TData>[];
+    options: DataTableFilterOption<TData>[];
+    setSelectedOptions: React$1.Dispatch<React$1.SetStateAction<DataTableFilterOption<TData>[]>>;
+}
+declare function DataTableMultiFilter<TData>({ table, allOptions, options, setSelectedOptions, }: DataTableMultiFilterProps<TData>): react_jsx_runtime.JSX.Element;
+interface MultiFilterRowProps<TData> extends DataTableMultiFilterProps<TData> {
+    i: number;
+    option: DataTableFilterOption<TData>;
+    operator?: (typeof operators)[number];
+    setOperator: React$1.Dispatch<React$1.SetStateAction<(typeof operators)[number]>>;
+}
+declare function MultiFilterRow<TData>({ i, table, option, allOptions, options, setSelectedOptions, operator, setOperator, }: MultiFilterRowProps<TData>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Core default config (Layer 1).
+ * All values match the current hardcoded behavior across components.
+ * Frozen to prevent accidental mutation.
+ */
+declare const DEFAULT_TABLE_CONFIG: Readonly<TableConfig>;
+
+/**
+ * Deep-merge two config objects.
+ * - Arrays replace entirely (not concatenated).
+ * - `undefined` values in overrides are skipped.
+ * - Only merges 2 levels deep (sufficient for TableConfig shape).
+ */
+declare function deepMergeConfig(base: TableConfig, overrides: DeepPartial<TableConfig>): TableConfig;
+
+/**
+ * Factory function to create a resolved, frozen TableConfig.
+ * Can be used outside React to pre-build configs in constants files.
+ */
+declare function createTableConfig(input?: TableConfigInput): TableConfig;
+
+interface TableProviderProps {
+    config: TableConfigInput;
+    children: ReactNode;
+}
+/**
+ * Optional global config provider (Layer 2).
+ * Wrapping your app or page with this merges your config with defaults.
+ * If omitted, all components fall back to DEFAULT_TABLE_CONFIG.
+ */
+declare function TableProvider({ config, children }: TableProviderProps): React__default.FunctionComponentElement<React__default.ProviderProps<TableConfig | null>>;
+/**
+ * Internal hook: returns the provider's config or defaults if no provider exists.
+ */
+declare function useGlobalTableConfig(): TableConfig;
+
+/**
+ * Resolves config across all layers: Core Defaults -> Provider -> Instance -> Plugins.
+ * Memoized and runs dev validation.
+ */
+declare function useResolvedTableConfig(instanceConfig?: TableConfigInput): TableConfig;
+
+/**
+ * Consumer hook for reading the resolved table config.
+ *
+ * Overloaded:
+ * - `useTableConfig()` — returns the full config object
+ * - `useTableConfig(selector)` — returns a derived slice (prevents unnecessary re-renders)
+ */
+declare function useTableConfig(): TableConfig;
+declare function useTableConfig<T>(selector: (config: TableConfig) => T): T;
+
+/**
+ * Translation hook for table components.
+ *
+ * If config provides a custom `translationFn`, uses that.
+ * Otherwise falls back to built-in English strings.
+ */
+declare function useTableTranslations(): (key: string) => string;
+
+declare function useDebounce<T>(value: T, delay: number): T;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+interface CsvExportOptions {
+    fileName?: string;
+    ignoredCols?: string[];
+}
+declare function createCsvConfig(options?: CsvExportOptions): Required<export_to_csv.ConfigOptions>;
+declare function exportSelectedRowsCsv<TData>(table: Table<TData>, options?: CsvExportOptions): void;
+
+export { type BackendPagination, ButtonTooltip, ClientSideTable, type CustomButtonProps, DEFAULT_TABLE_CONFIG, DataTable, DataTableAdvancedFilter, DataTableAdvancedFilterItem, DataTableAdvancedToolbar, DataTableCardView, DataTableColumnHeader, DataTableFacetedFilter, type DataTableFilterOption, type DataTableFilterableColumn, DataTableFloatingBar, DataTableLoading, DataTableMobileToolbar, DataTableMultiFilter, DataTablePagination, type DataTableQuerySearchable, DataTableRoleFilter, type DataTableSearchableColumn, DataTableSingleSelectFilter, DataTableToolbar, DataTableViewOptions, type DeepPartial, type FilterOptions, type MoreActionsProps, MultiFilterRow, type Option, type Pagination, type PaginationLinks, type PaginationMeta, TableActionsRow, type TableConfig, type TableConfigInput, type TableDevConfig, type TableEnterpriseConfig, type TableFeatureFlags, type TableI18nConfig, type TablePaginationConfig, type TablePerformanceConfig, type TablePlugin, TableProvider, type TableRouterAdapter, type TableSearchConfig, type ViewMode, cn, createCsvConfig, createTableConfig, deepMergeConfig, exportSelectedRowsCsv, useDebounce, useGlobalTableConfig, useResolvedTableConfig, useTableConfig, useTableTranslations };