@carto/ps-react-ui 5.0.0 → 6.0.0

package/dist/types/widgets/spread/types.d.ts

@@ -1,40 +1,25 @@
-import { TypographyProps } from '@mui/material';
-import { ReactNode } from 'react';
-import { BaseWidgetState, WidgetsStoreProps } from '../stores/types.js';
-import { WrapperState } from '../wrapper/types.js';
-import { DownloadItem } from '../actions/download/types.js';
-import { SeriesConfig } from '../formula/types.js';
-export interface SpreadUIProps {
-    id: WidgetsStoreProps['id'];
-}
+import { FormulaSeries } from '../formula/index.js';
+/**
+ * A single min/max pair rendered by the Spread widget. Mirrors
+ * {@link FormulaDataItem} — same optional `series`, `prefix`, `suffix`,
+ * `color`, and `note` slots — but the value is a range (`min` … `max`)
+ * rather than a single `value`.
+ */
 export interface SpreadDataItem {
     min: number;
     max: number;
-    prefix?: string | ReactNode;
-    suffix?: string | ReactNode;
+    prefix?: string;
+    suffix?: string;
+    /** Override the values' text colour (e.g. `'success.main'`). */
     color?: string;
+    /** Optional series indicator — coloured avatar with first letter of `name`. */
+    series?: FormulaSeries;
+    /** Optional caption rendered below the values. */
+    note?: string;
 }
-export interface RowProps {
-    id: WidgetsStoreProps['id'];
-    children: ReactNode | ((props: {
-        index: number;
-    }) => ReactNode);
-}
-export interface ValueProps extends Omit<ItemProps, 'children'> {
-    id: WidgetsStoreProps['id'];
-    index?: number;
-}
-export interface ItemProps {
-    children: ReactNode;
-    disabled?: boolean;
-    TypographyProps?: TypographyProps;
-}
-export type SpreadWidgetData = SpreadDataItem[];
-export type SpreadWidgetState = BaseWidgetState<WrapperState<SpreadWidgetConfig> & {
-    data: SpreadWidgetData;
-}>;
-export interface SpreadWidgetConfig {
-    formatter?: (value: number) => string;
-    series?: SeriesConfig[];
-}
-export type SpreadDownloadConfig = DownloadItem<SpreadWidgetData>[];
+/**
+ * Spread widget data — an array of `{min, max, …}` pairs rendered
+ * top-to-bottom, one row per entry. Visual structure matches the Formula
+ * widget so the two can sit side-by-side without style drift.
+ */
+export type SpreadWidgetData = readonly SpreadDataItem[];

package/dist/types/widgets/stores/index.d.ts

@@ -1,3 +1,8 @@
-export { useWidgetStore, widgetStoreActions } from './widget-store.js';
-export { useWidgetSelector } from './use-widget-selector.js';
-export type { BaseWidgetState, ToolRegistration, ToolTransformFunction, ToolType, WidgetsStoreProps, WidgetState, WidgetStore, WidgetStoreActions, WidgetStoreState, } from './types.js';
+export type { TransformType, TransformDescriptor, TransformFn, Transform, TransformPair, WidgetState, WidgetInit, WidgetStoreApi, } from './types.js';
+export { applyTransforms, upsertTransform, removeTransform } from './transforms.js';
+export { pipelineMiddleware } from './pipeline-middleware.js';
+export { WidgetContext, useWidgetId } from './widget-context.js';
+export { getWidgetStore, hasWidgetStore, deleteWidgetStore, resetWidgetStore, clearAllWidgetStores, registerWidgetStore, unregisterWidgetStore, setWidgetStoreEntry, createWidgetStore, useWidget, useWidgetShallow, setCaptureEl, getCaptureEl, clearAllCaptureEls, setEchartInstance, getEchartInstance, subscribeEchartInstance, clearAllEchartInstances, __debugListWidgetStores, } from './widget-store-registry.js';
+export { useEchartInstance } from './use-echart-instance.js';
+export { useTransform, useSingleTransform, type UseTransformOptions, type TransformControls, } from './use-transform.js';
+export { useTransformEnabled } from './use-transform-enabled.js';

package/dist/types/widgets/stores/types.d.ts

@@ -1,182 +1,55 @@
-import { RefObject } from 'react';
-/**
- * Tool type determines which pipeline a tool participates in.
- * - 'data': transforms widget data (default)
- * - 'config': transforms widget config/option
- */
-export type ToolType = 'data' | 'config';
-export interface WidgetsStoreProps {
-    /** Unique identifier for the widget */
+import { StoreApi } from 'zustand';
+export type TransformType = 'data' | 'config';
+export interface TransformDescriptor {
     id: string;
-    /** Type of widget */
-    type: string;
-    /** Widget data - flexible to accommodate different widget types */
-    data: unknown;
-    /** Original pre-pipeline data. Used by NoData to distinguish
-     *  "no data from API" from "pipeline tools filtered everything out".
-     *  Set automatically by executeToolPipeline — not a component prop. */
-    sourceData?: unknown;
-    /** Loading state */
-    isLoading: boolean;
-    /** Fetching state (e.g., for async data) */
-    isFetching: boolean;
-    /** Error message if any */
-    error?: {
-        title?: string;
-        message?: string;
-    };
-    /** Whether widget is visible */
-    visible?: boolean;
-    /** Reference to the widget ui instance */
-    refUI?: RefObject<HTMLElement | null>;
-    /** Registered tools for the widget's transformation pipeline */
-    registeredTools?: ToolRegistration[];
-    /** Formatter function for widget values */
-    formatter?: (value: number) => string;
-    /** Formatter function for widget label/category values */
-    labelFormatter?: (value: string | number) => string | number;
-    /** Locale for number formatting (e.g., 'en-US', 'es-ES', 'fr-FR') */
-    locale?: string;
-}
-/**
- * Tool transformation function type
- * Can be synchronous or asynchronous to support remote operations
- */
-export type ToolTransformFunction = (data: unknown) => unknown;
-/**
- * Tool registration for widget pipeline
- *
- * @example Basic tool registration
- * ```typescript
- * registerTool(widgetId, {
- *   id: 'searcher',
- *   order: 10,
- *   enabled: true,
- *   fn: (data) => filterData(data),
- * })
- * ```
- *
- * @example Tool with dependencies
- * ```typescript
- * registerTool(widgetId, {
- *   id: 'lock-selection',
- *   order: 20,
- *   enabled: true,
- *   fn: (data) => lockData(data),
- *   disables: ['searcher', 'relative-data'], // Disable these when active
- * })
- * ```
- *
- * Dependency Management:
- * - Multiple tools can disable the same target (reference counting)
- * - Target is only re-enabled when ALL disabling tools are inactive
- * - Original enabled state is preserved and restored
- * - Circular dependencies are detected and throw errors
- */
-export interface ToolRegistration {
-    /** Unique tool identifier (e.g., 'searcher', 'relative-data') */
-    id: string;
-    /** Execution priority - lower numbers execute first */
+    type: TransformType;
     order: number;
-    /** Transformation function */
-    fn: ToolTransformFunction;
-    /** Whether tool is currently enabled */
-    enabled: boolean;
-    /** 'data' (default) transforms data, 'config' transforms widget config/option */
-    type?: ToolType;
-    /**
-     * Array of tool IDs to disable when this tool is active.
-     * During pipeline execution, if this tool is enabled, any tools listed
-     * in this array will be excluded from the pipeline.
-     *
-     * @example
-     * ```typescript
-     * disables: ['searcher', 'relative-data']
-     * ```
-     */
     disables?: string[];
+    replaceMergeKeys?: string[];
 }
-/**
- * Base widget state interface
- */
-export type BaseWidgetState<T> = WidgetsStoreProps & T;
-/**
- * Union type for all widget states
- */
-export type WidgetState = BaseWidgetState<unknown>;
-/**
- * Widget store state with tool registration
- */
-export interface WidgetStoreState {
-    /** Map of widget id to widget state */
-    widgets: Record<string, WidgetState>;
+export type TransformFn = (input: unknown) => unknown;
+export interface Transform extends TransformDescriptor {
+    fn: TransformFn;
+    enabled: boolean;
 }
-/**
- * Widget store actions
- */
-export interface WidgetStoreActions {
-    /**
-     * Add or update a widget in the store
-     * @param id - Widget ID
-     * @param widget - Widget state properties to merge (accepts any object structure)
-     * @template T - Type of the widget state for type-safe access
-     */
-    setWidget: <T = any>(id: WidgetState['id'], widget: Partial<T>) => void;
-    /**
-     * Remove a widget from the store
-     * @param id - Widget ID to remove
-     */
-    removeWidget: (id: WidgetState['id']) => void;
-    /**
-     * Clear all widgets
-     */
-    clearWidgets: () => void;
-    /**
-     * Get widget by ID
-     * @param id - Widget ID
-     * @returns Widget state or undefined if not found
-     */
-    getWidget: <T extends WidgetState = WidgetState>(id: WidgetState['id']) => T | undefined;
-    /**
-     * Register a tool with the widget's transformation pipeline
-     * @param widgetId - Widget ID
-     * @param tool - Tool registration object
-     */
-    registerTool: (widgetId: string, tool: ToolRegistration) => void;
-    /**
-     * Unregister a tool from the widget's transformation pipeline
-     * @param widgetId - Widget ID
-     * @param toolId - Tool ID to remove
-     */
-    unregisterTool: (widgetId: string, toolId: string) => void;
-    /**
-     * Set tool enabled state
-     * @param widgetId - Widget ID
-     * @param toolId - Tool ID
-     * @param enabled - Whether tool should be enabled
-     */
-    setToolEnabled: (widgetId: string, toolId: string, enabled: boolean) => void;
-    /**
-     * Trigger pipeline re-execution by bumping the registeredTools reference.
-     * @param widgetId - Widget ID
-     */
-    triggerToolPipeline: (widgetId: string) => void;
+export interface TransformPair {
+    descriptor: TransformDescriptor;
+    fn: TransformFn;
+}
+export interface WidgetState {
+    rawData: unknown;
+    data: unknown;
+    dataTransforms: readonly Transform[];
+    configTransforms: readonly Transform[];
+    transformStates: Record<string, {
+        enabled: boolean;
+        [k: string]: unknown;
+    }>;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
     /**
-     * Execute the tool transformation pipeline
-     * Supports both synchronous and asynchronous tools
-     * @param widgetId - Widget ID
-     * @param sourceData - Original data to transform
+     * Original formatter as supplied by the consumer (Provider's `formatter`
+     * prop). Always live-synced — never overridden by actions. Actions that need
+     * to display a different formatter (e.g. {@link RelativeData}'s percent
+     * formatter) should write to {@link WidgetState.formatter} and read this
+     * field when restoring the absolute view.
      */
-    executeToolPipeline: (widgetId: string, sourceData: unknown) => Promise<void>;
+    rawFormatter?: (value: number) => string;
     /**
-     * Execute the config transformation pipeline
-     * Applies config-type tools to the base config, then sets the result on the widget
-     * @param widgetId - Widget ID
-     * @param baseConfig - Base config to transform
+     * Active formatter — what consumer code (tooltips, axis labels, legends,
+     * etc.) reads. Defaults to {@link WidgetState.rawFormatter}; actions may
+     * override it temporarily and restore it from `rawFormatter` later.
      */
-    executeConfigPipeline: (widgetId: string, baseConfig: object) => Promise<void>;
+    formatter?: (value: number) => string;
+    labelFormatter?: (value: string | number) => string | number;
+}
+export interface WidgetInit {
+    data: unknown;
+    isLoading?: boolean;
+    isFetching?: boolean;
+    error?: unknown;
+    formatter?: (value: number) => string;
+    labelFormatter?: (value: string | number) => string | number;
 }
-/**
- * Complete widget store interface
- */
-export type WidgetStore = WidgetStoreState & WidgetStoreActions;
+export type WidgetStoreApi = StoreApi<WidgetState>;

package/dist/types/widgets/subheader/style.d.ts

@@ -1,19 +1,10 @@
-import { Theme } from '@mui/material';
 export declare const styles: {
     root: {
-        display: "flex";
+        display: "grid";
+        gridTemplateColumns: string;
         alignItems: "center";
-        gap: ({ spacing }: Theme) => string;
-        minHeight: ({ spacing }: Theme) => string;
-    };
-    slotLeft: {
-        flexShrink: number;
-    };
-    slotRight: {
-        flexGrow: number;
-        display: "flex";
-        justifyContent: "flex-end";
-        alignItems: "center";
-        gap: ({ spacing }: Theme) => string;
+        gap: number;
+        minHeight: number;
+        pb: number;
     };
 };

package/dist/types/widgets/subheader/subheader.d.ts

@@ -1,13 +1,11 @@
-import { WidgetSubHeaderProps } from './types.js';
+import { SxProps, Theme } from '@mui/material';
+import { ReactNode } from 'react';
+export interface SubheaderProps {
+    sx?: SxProps<Theme>;
+    children: ReactNode;
+}
 /**
- * Flexible two-slot layout for displaying supplementary widget information such as totals, timestamps, or controls. Uses flexbox with space-between justification.
- *
- * @example
- * ```tsx
- * <WidgetSubHeader
- *   slotLeft={<Typography variant="caption">Total: 1,234</Typography>}
- *   slotRight={<Typography variant="caption">Updated: 2m ago</Typography>}
- * />
- * ```
+ * Stateless layout: CSS grid `1fr auto`. Children self-place — typically
+ * `<Widget.SelectionSummary />` (left) and `<Widget.Toolbox>` (right).
  */
-export declare function WidgetSubHeader({ slotLeft, slotRight, sx, }: WidgetSubHeaderProps): import('react').JSX.Element;
+export declare function Subheader({ sx, children }: SubheaderProps): import('react').JSX.Element;

package/dist/types/widgets/table/helpers.d.ts

@@ -1,38 +1,32 @@
-import { ReactNode } from 'react';
+import { TableColumn, TableRow, TableSortDirection, TableWidgetData } from './types.js';
 /**
- * Get formatted cell value for display
- * Handles primitives, arrays, objects, and custom formatters
- *
- * @param cellValue - Raw cell value
- * @param formatter - Optional formatter function
- * @returns Formatted value for display
+ * Compares two values with a consistent ordering across primitive types.
+ * Strings use locale comparison; numbers subtract; booleans rank false < true;
+ * objects/arrays compare by JSON serialization. Null/undefined sort to the end
+ * regardless of direction.
  */
-export declare function getCellValue<T>(cellValue: T): ReactNode;
+export declare function compareValues(a: unknown, b: unknown, direction: TableSortDirection): number;
+/** Returns a new array sorted by the named column. Does not mutate the input. */
+export declare function sortRows<T extends TableRow>(rows: readonly T[], columnId: string, direction: TableSortDirection): T[];
+/** Returns the slice for the requested page. Out-of-range pages return []. */
+export declare function paginateRows<T>(rows: readonly T[], page: number, pageSize: number): T[];
 /**
- * Compare two values for sorting
- * Handles strings, numbers, and other types
- *
- * @param a - First value
- * @param b - Second value
- * @param direction - Sort direction
- * @returns Comparison result (-1, 0, 1)
+ * Resolves the effective column list. When the widget store has a
+ * `columnOrder` set (e.g. ChangeColumn was used), the column array is
+ * reordered to match. Unknown ids in the order are skipped; columns not
+ * present in the order keep their original relative position at the end.
  */
-export declare function compareValues(a: unknown, b: unknown, direction: 'asc' | 'desc'): number;
-/**
- * Sort data array by column
- *
- * @param data - Data array to sort
- * @param columnId - Column ID to sort by
- * @param direction - Sort direction
- * @returns Sorted data array (new array, does not mutate original)
- */
-export declare function sortData<T extends Record<string, unknown>>(data: T[], columnId: string, direction: 'asc' | 'desc'): T[];
-/**
- * Paginate data array
- *
- * @param data - Data array to paginate
- * @param page - Current page (0-indexed)
- * @param rowsPerPage - Number of rows per page
- * @returns Paginated data slice
- */
-export declare function paginateData<T>(data: T[], page: number, rowsPerPage: number): T[];
+export declare function resolveColumns(columns: readonly TableColumn[], columnOrder: readonly string[] | undefined): readonly TableColumn[];
+/** Applies sort and pagination to the input data. Pure. */
+export declare function deriveVisibleRows<T extends TableRow>(rows: readonly T[], options: {
+    sort?: {
+        columnId: string | null;
+        direction: TableSortDirection;
+    };
+    page: number;
+    pageSize: number;
+}): {
+    sorted: readonly T[];
+    visible: T[];
+};
+export declare function tableDataToCsv(data: TableWidgetData, columns: readonly TableColumn[]): string;

package/dist/types/widgets/table/index.d.ts

@@ -1,17 +1,8 @@
-export { CellHeader } from './components/cell-header.js';
-export { Row } from './components/row.js';
-export { Pagination } from './components/pagination.js';
-export { PaginationActions } from './components/pagination-actions.js';
-export { Table } from './table-ui.js';
-export { usePagination } from './hooks/use-pagination.js';
-export { useSort } from './hooks/use-sort.js';
-export { useSelection } from './hooks/use-selection.js';
-export { tableConfig, tableDownloadConfig } from './config.js';
-export { TableSkeleton } from './skeleton.js';
-export { sanitizeTableRow, sanitizeTableData } from './serializer.js';
-export { getCellValue, compareValues, sortData, paginateData } from './helpers.js';
-export { styles as tableStyles } from './style.js';
-export type { TableUIProps, TableColumn, TableRow, TableWidgetData, TablePaginationState, SortDirection, SortState, Mode, TableWidgetConfig, TableWidgetState, TableDownloadConfig, TableProps, CellHeaderProps, RowProps, PaginationProps, PaginationActionsProps, } from './types.js';
-export type { UsePaginationResult } from './hooks/use-pagination.js';
-export type { UseSortResult } from './hooks/use-sort.js';
-export type { UseSelectionOptions, UseSelectionResult, } from './hooks/use-selection.js';
+export { Table, type TableProps } from './table.js';
+export { TableUI, type TableUIProps } from './table-ui.js';
+export { TableSkeleton, type TableSkeletonProps } from './skeleton.js';
+export { createTableDownloadConfig } from './download.js';
+export { filterTableByLockedRows } from './transforms.js';
+export { compareValues, sortRows, paginateRows, resolveColumns, deriveVisibleRows, tableDataToCsv, } from './helpers.js';
+export { DEFAULT_TABLE_LABELS, type TableLabels } from './labels.js';
+export { DEFAULT_TABLE_PAGE_SIZE, DEFAULT_TABLE_PAGE_SIZE_OPTIONS, type TableColumn, type TableRow, type TableWidgetData, type TableWidgetState, type TableSortDirection, type TableSortState, } from './types.js';

package/dist/types/widgets/table/skeleton.d.ts

@@ -1,10 +1,22 @@
+import { TableProps as MuiTableProps } from '@mui/material';
 export interface TableSkeletonProps {
-    /** Number of columns to display */
-    columns?: number;
-    /** Number of rows to display */
+    /** Number of body rows to render. Defaults to `5` (matches v1). */
     rows?: number;
+    /** Number of columns to render. Defaults to `4` (matches v1). */
+    columns?: number;
+    /**
+     * Forwarded to MUI's `<Table size>` so the loading layout matches the
+     * size you'll render in {@link TableUI}. Leave `undefined` (the
+     * default) to use MUI's own default density.
+     */
+    size?: MuiTableProps['size'];
 }
 /**
- * Table skeleton loader component
+ * Loading placeholder for the Table widget. Renders the same MUI table
+ * primitives that {@link TableUI} uses so the loading layout (column
+ * widths, header band, row density) doesn't shift when data resolves.
+ *
+ * Mirrors the v1 widget's `<TableSkeleton>` structure with v2's themed
+ * `styles.headerCell`.
  */
-export declare function TableSkeleton({ columns, rows }: TableSkeletonProps): import('react').JSX.Element;
+export declare function TableSkeleton({ rows, columns, size, }: TableSkeletonProps): import('react').JSX.Element;

package/dist/types/widgets/table/style.d.ts

@@ -1,33 +1,40 @@
-import { Theme } from '@mui/material';
 export declare const styles: {
     container: {
         width: string;
-        overflow: "auto";
+        overflowX: "auto";
     };
     table: {
         minWidth: number;
     };
     headerCell: {
         fontWeight: number;
-        backgroundColor: (theme: Theme) => string;
+        backgroundColor: "background.paper";
     };
+    /**
+     * Strip the bottom border from the last body row so the body flushes
+     * against the pagination border instead of doubling it up. Mirrors v1.
+     */
     row: {
         '&:last-child td, &:last-child th': {
             border: number;
         };
     };
-    rowHover: {
-        '&:hover': {
-            backgroundColor: (theme: Theme) => string;
-        };
-    };
-    rowSelected: {
-        backgroundColor: (theme: Theme) => string;
-        '&:hover': {
-            backgroundColor: (theme: Theme) => string;
-        };
+    rowClickable: {
+        cursor: "pointer";
     };
     pagination: {
-        borderTop: (theme: Theme) => string;
+        borderTop: string;
+        borderColor: "divider";
+    };
+    paginationActions: {
+        display: "flex";
+        alignItems: "center";
+        gap: number;
+        ml: number;
+    };
+    empty: {
+        textAlign: "center";
+        color: "text.secondary";
+        py: number;
     };
 };

package/dist/types/widgets/table/table-ui.d.ts

@@ -1,32 +1,44 @@
-import { TableCell, TableProps as MuiTableProps } from '@mui/material';
-import { Ref } from 'react';
-import { TableUIProps } from './types.js';
-/**
- * Props for the base Table component
- */
-interface TableComponentProps extends MuiTableProps {
-    /** Table element ref */
-    ref?: Ref<HTMLTableElement>;
-}
-/**
- * Base Table component with compound component pattern
- * Provides Table.Head, Table.Body, Table.Row, Table.Cell, Table.CellHeader, Table.Pagination
- */
-declare function Table({ children, ref, stickyHeader, ...props }: TableComponentProps): import('react').JSX.Element;
-declare namespace Table {
-    var Head: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").TableHeadTypeMap<{}, "thead">>;
-    var CellHeader: typeof import("./index.js").CellHeader;
-    var Body: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").TableBodyTypeMap<{}, "tbody">>;
-    var Row: typeof import("./index.js").Row;
-    var Cell: typeof TableCell;
-    var Container: typeof TableContainer;
-    var Paper: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").PaperTypeMap<{}, "div">>;
-    var Pagination: typeof import("./index.js").Pagination;
-    var PaginationActions: typeof import("./index.js").PaginationActions;
+import { TableProps as MuiTableProps } from '@mui/material';
+import { TableLabels } from './labels.js';
+import { TableColumn, TableRow, TableSortState } from './types.js';
+export interface TableUIProps<T extends TableRow = TableRow> {
+    columns: readonly TableColumn[];
+    /** Already-paginated, already-sorted rows for the current view. */
+    rows: readonly T[];
+    /** Total row count (across all pages). Required for pagination footer. */
+    total: number;
+    page: number;
+    pageSize: number;
+    pageSizeOptions?: readonly number[];
+    sort?: TableSortState;
+    /**
+     * Column name to use as the row identity. Drives selection lookup,
+     * React keys, and aria labels. Defaults to `'id'` — point it at
+     * another column when your rows don't carry an `id` field.
+     */
+    keyColumn?: string;
+    /** Selected row ids. Destination-owned. */
+    selection?: readonly (string | number)[];
+    selectable?: boolean;
+    onSortChange?: (next: TableSortState) => void;
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    onSelectionChange?: (next: readonly (string | number)[]) => void;
+    onRowClick?: (row: T) => void;
+    onRowHover?: (row: T | null) => void;
+    labels?: Partial<TableLabels>;
+    /** Row rendered when `rows` is empty for the current page. */
+    emptyContent?: React.ReactNode;
+    /**
+     * Forwarded to MUI's `<Table size>` — `'small'` for compact rows,
+     * `'medium'` for the default density. Leave `undefined` (the default)
+     * to let MUI's own default kick in.
+     */
+    size?: MuiTableProps['size'];
 }
-export { Table };
 /**
- * TableContainer widget component
- * Integrates with widget store and provides ref registration using custom hook
+ * Pure renderer for a paginated, sortable, optionally-selectable table.
+ * Has no widget-store coupling — `<Table>` (the bridge) reads from the store
+ * and feeds this UI with already-projected data.
  */
-declare function TableContainer(props: TableUIProps): import('react').JSX.Element;
+export declare function TableUI<T extends TableRow = TableRow>({ columns, rows, total, page, pageSize, pageSizeOptions, sort, keyColumn, selection, selectable, onSortChange, onPageChange, onPageSizeChange, onSelectionChange, onRowClick, onRowHover, labels, emptyContent, size, }: TableUIProps<T>): import('react').JSX.Element;