React Table.Api

import { ARIAButtonSlotProps } from '@fluentui/react-aria';
import type { AvatarSize } from '@fluentui/react-avatar';
import type { Checkbox } from '@fluentui/react-checkbox';
import type { CheckboxProps } from '@fluentui/react-checkbox';
import type { ComponentProps } from '@fluentui/react-utilities';
import type { ComponentState } from '@fluentui/react-utilities';
import type { ContextSelector } from '@fluentui/react-context-selector';
import { FC } from 'react';
import type { ForwardRefComponent } from '@fluentui/react-utilities';
import type { JSXElement } from '@fluentui/react-utilities';
import { Provider } from 'react';
import { ProviderProps } from 'react';
import type { Radio } from '@fluentui/react-radio';
import * as React_2 from 'react';
import { SelectionHookParams } from '@fluentui/react-utilities';
import { SelectionMode as SelectionMode_2 } from '@fluentui/react-utilities';
import type { Slot } from '@fluentui/react-utilities';
import type { SlotClassNames } from '@fluentui/react-utilities';
import { TabsterDOMAttribute } from '@fluentui/react-tabster';

// @public (undocumented)
export type CellRenderFunction<TItem = unknown> = (column: TableColumnDefinition<TItem>, dataGridContextValue: DataGridContextValue) => React_2.ReactNode;

// @public (undocumented)
export const ColumnIdContextProvider: React_2.Provider<TableColumnId | undefined>;

// @public
export function createTableColumn<TItem>(options: CreateTableColumnOptions<TItem>): {
    columnId: TableColumnId;
    renderCell: (item: TItem) => React_2.ReactNode;
    renderHeaderCell: (data?: unknown) => React_2.ReactNode;
    compare: (a: TItem, b: TItem) => number;
};

// @public (undocumented)
export interface CreateTableColumnOptions<TItem> extends Partial<TableColumnDefinition<TItem>> {
    // (undocumented)
    columnId: TableColumnId;
}

// @public
export const DataGrid: ForwardRefComponent<DataGridProps>;

// @public
export const DataGridBody: ForwardRefComponent<DataGridBodyProps> & (<TItem>(props: DataGridBodyProps<TItem>) => JSXElement);

// @public (undocumented)
export const dataGridBodyClassNames: SlotClassNames<DataGridBodySlots>;

// @public
export type DataGridBodyProps<TItem = unknown> = Omit<TableBodyProps, 'children'> & {
    children: RowRenderFunction<TItem>;
};

// @public (undocumented)
export type DataGridBodySlots = TableBodySlots;

// @public
export type DataGridBodyState = TableBodyState & {
    rows: TableRowData<unknown>[];
    renderRow: RowRenderFunction;
};

// @public
export const DataGridCell: ForwardRefComponent<DataGridCellProps>;

// @public (undocumented)
export const dataGridCellClassNames: SlotClassNames<DataGridCellSlots>;

// @public
export type DataGridCellFocusMode = 'group' | 'none' | 'cell';

// @public
export type DataGridCellProps = TableCellProps & {
    focusMode?: DataGridCellFocusMode;
};

// @public (undocumented)
export type DataGridCellSlots = TableCellSlots;

// @public
export type DataGridCellState = TableCellState;

// @public (undocumented)
export const dataGridClassNames: SlotClassNames<DataGridSlots>;

// @public (undocumented)
export const DataGridContextProvider: Provider<DataGridContextValue | undefined> & FC<ProviderProps<DataGridContextValue | undefined>>;

// @public (undocumented)
export type DataGridContextValue = TableFeaturesState<any> & {
    focusMode: DataGridFocusMode;
    selectableRows: boolean;
    subtleSelection: boolean;
    selectionAppearance: TableRowProps['appearance'];
    resizableColumns?: boolean;
    compositeRowTabsterAttribute: TabsterDOMAttribute;
};

// @public (undocumented)
export type DataGridContextValues = TableContextValues & {
    dataGrid: DataGridContextValue;
};

// @public (undocumented)
export type DataGridFocusMode = 'none' | 'cell' | 'row_unstable' | 'composite';

// @public
export const DataGridHeader: ForwardRefComponent<DataGridHeaderProps>;

// @public
export const DataGridHeaderCell: ForwardRefComponent<DataGridHeaderCellProps>;

// @public (undocumented)
export const dataGridHeaderCellClassNames: SlotClassNames<DataGridHeaderCellSlots>;

// @public
export type DataGridHeaderCellProps = Omit<TableHeaderCellProps, 'sortable'> & Pick<DataGridCellProps, 'focusMode'>;

// @public (undocumented)
export type DataGridHeaderCellSlots = TableHeaderCellSlots;

// @public
export type DataGridHeaderCellState = TableHeaderCellState;

// @public (undocumented)
export const dataGridHeaderClassNames: SlotClassNames<DataGridHeaderSlots>;

// @public
export type DataGridHeaderProps = TableHeaderProps;

// @public (undocumented)
export type DataGridHeaderSlots = TableHeaderSlots;

// @public
export type DataGridHeaderState = TableHeaderState;

// @public
export type DataGridProps = TableProps & Pick<DataGridContextValue, 'items' | 'columns' | 'getRowId'> & Pick<Partial<DataGridContextValue>, 'focusMode' | 'subtleSelection' | 'selectionAppearance' | 'resizableColumns'> & Pick<UseTableSortOptions, 'sortState' | 'defaultSortState'> & Pick<SelectionHookParams, 'defaultSelectedItems' | 'selectedItems'> & {
    onSortChange?: (e: React_2.MouseEvent, sortState: SortState) => void;
    onSelectionChange?: (e: React_2.MouseEvent | React_2.KeyboardEvent, data: OnSelectionChangeData) => void;
    selectionMode?: SelectionMode_2;
    columnSizingOptions?: TableColumnSizingOptions;
    onColumnResize?: (e: KeyboardEvent | TouchEvent | MouseEvent | undefined, data: {
        columnId: TableColumnId;
        width: number;
    }) => void;
    containerWidthOffset?: number;
    resizableColumnsOptions?: {
        autoFitColumns?: boolean;
    };
};

// @public
export const DataGridRow: ForwardRefComponent<DataGridRowProps> & (<TItem>(props: DataGridRowProps<TItem>) => JSXElement);

// @public (undocumented)
export const dataGridRowClassNames: SlotClassNames<DataGridRowSlots>;

// @public
export type DataGridRowProps<TItem = unknown> = Omit<TableRowProps, 'children'> & Omit<ComponentProps<DataGridRowSlots>, 'children'> & {
    children: CellRenderFunction<TItem>;
};

// @public (undocumented)
export type DataGridRowSlots = TableRowSlots & {
    selectionCell?: Slot<typeof TableSelectionCell>;
};

// @public
export type DataGridRowState = TableRowState & ComponentState<DataGridRowSlots> & {
    renderCell: CellRenderFunction;
    columnDefs: TableColumnDefinition<any>[];
    dataGridContextValue: DataGridContextValue;
};

// @public
export const DataGridSelectionCell: ForwardRefComponent<DataGridSelectionCellProps>;

// @public (undocumented)
export const dataGridSelectionCellClassNames: SlotClassNames<DataGridSelectionCellSlots>;

// @public
export type DataGridSelectionCellProps = TableSelectionCellProps;

// @public (undocumented)
export type DataGridSelectionCellSlots = TableSelectionCellSlots;

// @public
export type DataGridSelectionCellState = TableSelectionCellState;

// @public (undocumented)
export type DataGridSlots = TableSlots;

// @public
export type DataGridState = TableState & {
    tableState: TableFeaturesState<unknown>;
} & Pick<DataGridContextValue, 'focusMode' | 'selectableRows' | 'subtleSelection' | 'selectionAppearance' | 'getRowId' | 'resizableColumns' | 'compositeRowTabsterAttribute'>;

// @public
export const renderDataGrid_unstable: (state: DataGridState, contextValues: DataGridContextValues) => JSXElement;

// @public
export const renderDataGridBody_unstable: (state: DataGridBodyState) => JSXElement;

// @public
export const renderDataGridCell_unstable: (state: DataGridCellState) => JSXElement;

// @public
export const renderDataGridHeader_unstable: (state: DataGridHeaderState) => JSXElement;

// @public
export const renderDataGridHeaderCell_unstable: (state: DataGridHeaderCellState) => JSXElement;

// @public
export const renderDataGridRow_unstable: (state: DataGridRowState) => JSXElement;

// @public
export const renderDataGridSelectionCell_unstable: (state: DataGridSelectionCellState) => JSXElement;

// @public
export const renderTable_unstable: (state: TableState, contextValues: TableContextValues) => JSXElement;

// @public
export const renderTableBody_unstable: (state: TableBodyState) => JSXElement;

// @public
export const renderTableCell_unstable: (state: TableCellState) => JSXElement;

// @public
export const renderTableCellActions_unstable: (state: TableCellActionsState) => JSXElement;

// @public
export const renderTableCellLayout_unstable: (state: TableCellLayoutState, contextValues: TableCellLayoutContextValues) => JSXElement;

// @public
export const renderTableHeader_unstable: (state: TableHeaderState) => JSXElement;

// @public
export const renderTableHeaderCell_unstable: (state: TableHeaderCellState) => JSXElement;

// @public
export const renderTableResizeHandle_unstable: (state: TableResizeHandleState) => JSXElement;

// @public
export const renderTableRow_unstable: (state: TableRowState) => JSXElement;

// @public
export const renderTableSelectionCell_unstable: (state: TableSelectionCellState) => JSXElement;

// @public (undocumented)
export type RowRenderFunction<TItem = unknown> = (row: TableRowData<TItem>, ...rest: unknown[]) => React_2.ReactNode;

// @public (undocumented)
export type SortDirection = 'ascending' | 'descending';

// @public
export const Table: ForwardRefComponent<TableProps>;

// @public (undocumented)
export const TABLE_SELECTION_CELL_WIDTH = 44;

// @public
export const TableBody: ForwardRefComponent<TableBodyProps>;

// @public (undocumented)
export const tableBodyClassName = "fui-TableBody";

// @public (undocumented)
export const tableBodyClassNames: SlotClassNames<TableBodySlots>;

// @public
export type TableBodyProps = ComponentProps<TableBodySlots>;

// @public (undocumented)
export type TableBodySlots = {
    root: Slot<'tbody', 'div'>;
};

// @public
export type TableBodyState = ComponentState<TableBodySlots> & Pick<TableContextValue, 'noNativeElements'>;

// @public
export const TableCell: ForwardRefComponent<TableCellProps>;

// @public
export const TableCellActions: ForwardRefComponent<TableCellActionsProps>;

// @public (undocumented)
export const tableCellActionsClassNames: SlotClassNames<TableCellActionsSlots>;

// @public
export type TableCellActionsProps = ComponentProps<TableCellActionsSlots> & {
    visible?: boolean;
};

// @public (undocumented)
export type TableCellActionsSlots = {
    root: Slot<'div'>;
};

// @public
export type TableCellActionsState = ComponentState<TableCellActionsSlots> & Pick<Required<TableCellActionsProps>, 'visible'>;

// @public (undocumented)
export const tableCellClassName = "fui-TableCell";

// @public (undocumented)
export const tableCellClassNames: SlotClassNames<TableCellSlots>;

// @public
export const TableCellLayout: ForwardRefComponent<TableCellLayoutProps>;

// @public (undocumented)
export const tableCellLayoutClassNames: SlotClassNames<TableCellLayoutSlots>;

// @public
export type TableCellLayoutProps = Omit<ComponentProps<Partial<TableCellLayoutSlots>>, 'content'> & Pick<Partial<TableCellLayoutSlots>, 'content'> & {
    appearance?: 'primary';
    truncate?: boolean;
};

// @public (undocumented)
export type TableCellLayoutSlots = {
    root: Slot<'div'>;
    media: Slot<'span'>;
    main: Slot<'span'>;
    description: Slot<'span'>;
    content: Slot<'div'>;
};

// @public
export type TableCellLayoutState = ComponentState<TableCellLayoutSlots> & Pick<TableCellLayoutProps, 'appearance' | 'truncate'> & {
    avatarSize: AvatarSize | undefined;
} & Pick<TableContextValue, 'size'>;

// @public
export type TableCellProps = ComponentProps<TableCellSlots> & {};

// @public (undocumented)
export type TableCellSlots = {
    root: Slot<'td', 'div'>;
};

// @public
export type TableCellState = ComponentState<TableCellSlots> & Pick<TableContextValue, 'noNativeElements' | 'size'>;

// @public (undocumented)
export const tableClassName = "fui-Table";

// @public (undocumented)
export const tableClassNames: SlotClassNames<TableSlots>;

// @public (undocumented)
export interface TableColumnDefinition<TItem> {
    // (undocumented)
    columnId: TableColumnId;
    // (undocumented)
    compare: (a: TItem, b: TItem) => number;
    // (undocumented)
    renderCell: (item: TItem) => React_2.ReactNode;
    // (undocumented)
    renderHeaderCell: (data?: unknown) => React_2.ReactNode;
}

// @public (undocumented)
export type TableColumnId = string | number;

// @public (undocumented)
export type TableColumnSizingOptions = Record<TableColumnId, Partial<Pick<ColumnWidthState, 'minWidth' | 'idealWidth' | 'padding'>> & {
    defaultWidth?: number;
    autoFitColumns?: boolean;
}>;

// @public (undocumented)
export const TableContextProvider: React_2.Provider<TableContextValue | undefined>;

// @public (undocumented)
export type TableContextValue = {
    size: 'extra-small' | 'small' | 'medium';
    noNativeElements: boolean;
    sortable: boolean;
};

// @public (undocumented)
export type TableContextValues = {
    table: TableContextValue;
};

// @public (undocumented)
export type TableFeaturePlugin = <TItem>(tableState: TableFeaturesState<TItem>) => TableFeaturesState<TItem>;

// @public (undocumented)
export interface TableFeaturesState<TItem> extends Pick<UseTableFeaturesOptions<TItem>, 'items' | 'getRowId'> {
    columns: TableColumnDefinition<TItem>[];
    columnSizing_unstable: TableColumnSizingState;
    getRows: <TRowState extends TableRowData<TItem> = TableRowData<TItem>>(rowEnhancer?: RowEnhancer<TItem, TRowState>) => TRowState[];
    selection: TableSelectionState;
    sort: TableSortState<TItem>;
    tableRef: React_2.Ref<HTMLDivElement>;
}

// @public
export const TableHeader: ForwardRefComponent<TableHeaderProps>;

// @public
export const TableHeaderCell: ForwardRefComponent<TableHeaderCellProps>;

// @public (undocumented)
export const tableHeaderCellClassName = "fui-TableHeaderCell";

// @public (undocumented)
export const tableHeaderCellClassNames: SlotClassNames<TableHeaderCellSlots>;

// @public
export type TableHeaderCellProps = ComponentProps<Partial<TableHeaderCellSlots>> & {
    sortable?: boolean;
    sortDirection?: SortDirection;
};

// @public (undocumented)
export type TableHeaderCellSlots = {
    root: Slot<'th', 'div'>;
    sortIcon: Slot<'span'>;
    button: NonNullable<Slot<ARIAButtonSlotProps>>;
    aside: Slot<'span'>;
};

// @public
export type TableHeaderCellState = ComponentState<TableHeaderCellSlots> & Pick<TableContextValue, 'noNativeElements'> & Pick<TableHeaderCellProps, 'sortable'>;

// @public (undocumented)
export const tableHeaderClassName = "fui-TableHeader";

// @public (undocumented)
export const tableHeaderClassNames: SlotClassNames<TableHeaderSlots>;

// @public (undocumented)
export const TableHeaderContextProvider: React_2.Provider<string | undefined>;

// @public
export type TableHeaderProps = ComponentProps<TableHeaderSlots> & {};

// @public (undocumented)
export type TableHeaderSlots = {
    root: Slot<'thead', 'div'>;
};

// @public
export type TableHeaderState = ComponentState<TableHeaderSlots> & Pick<TableContextValue, 'noNativeElements'>;

// @public
export type TableProps = ComponentProps<TableSlots> & Partial<TableContextValue>;

// @public
export const TableResizeHandle: ForwardRefComponent<TableResizeHandleProps>;

// @public (undocumented)
export const tableResizeHandleClassNames: SlotClassNames<TableResizeHandleSlots>;

// @public
export type TableResizeHandleProps = ComponentProps<TableResizeHandleSlots> & {};

// @public (undocumented)
export type TableResizeHandleSlots = {
    root: Slot<'div'>;
};

// @public
export type TableResizeHandleState = ComponentState<TableResizeHandleSlots>;

// @public
export const TableRow: ForwardRefComponent<TableRowProps>;

// @public (undocumented)
export const tableRowClassName = "fui-TableRow";

// @public (undocumented)
export const tableRowClassNames: SlotClassNames<TableRowSlots>;

// @public (undocumented)
export interface TableRowData<TItem> {
    item: TItem;
    rowId: TableRowId;
}

// @public (undocumented)
export type TableRowId = string | number;

// @public (undocumented)
export const TableRowIdContextProvider: React_2.Provider<TableRowId | undefined>;

// @public
export type TableRowProps = ComponentProps<TableRowSlots> & {
    appearance?: 'brand' | 'neutral' | 'none';
};

// @public (undocumented)
export type TableRowSlots = {
    root: Slot<'tr', 'div'>;
};

// @public
export type TableRowState = ComponentState<TableRowSlots> & Pick<TableContextValue, 'noNativeElements' | 'size'> & Pick<Required<TableRowProps>, 'appearance'> & {
    isHeaderRow: boolean;
};

// @public
export const TableSelectionCell: ForwardRefComponent<TableSelectionCellProps>;

// @public (undocumented)
export const tableSelectionCellClassNames: SlotClassNames<TableSelectionCellSlots>;

// @public
export type TableSelectionCellProps = ComponentProps<Partial<TableSelectionCellSlots>> & {
    type?: 'checkbox' | 'radio';
    checked?: CheckboxProps['checked'];
    subtle?: boolean;
    hidden?: boolean;
    invisible?: boolean;
};

// @public (undocumented)
export type TableSelectionCellSlots = {
    checkboxIndicator: Slot<typeof Checkbox>;
    radioIndicator: Slot<typeof Radio>;
} & Pick<TableCellSlots, 'root'>;

// @public
export type TableSelectionCellState = ComponentState<TableSelectionCellSlots> & Pick<Required<TableSelectionCellProps>, 'type' | 'checked' | 'subtle'> & Pick<TableContextValue, 'noNativeElements'> & {
    hidden: boolean;
};

// @public (undocumented)
export interface TableSelectionState {
    allRowsSelected: boolean;
    clearRows: (e: React_2.SyntheticEvent) => void;
    deselectRow: (e: React_2.SyntheticEvent, rowId: TableRowId) => void;
    isRowSelected: (rowId: TableRowId) => boolean;
    selectedRows: Set<TableRowId>;
    // (undocumented)
    selectionMode: SelectionMode_2;
    selectRow: (e: React_2.SyntheticEvent, rowId: TableRowId) => void;
    someRowsSelected: boolean;
    toggleAllRows: (e: React_2.SyntheticEvent) => void;
    toggleRow: (e: React_2.SyntheticEvent, rowId: TableRowId) => void;
}

// @public (undocumented)
export type TableSlots = {
    root: Slot<'table', 'div'>;
};

// @public (undocumented)
export interface TableSortState<TItem> {
    getSortDirection: (columnId: TableColumnId) => SortDirection | undefined;
    setColumnSort: (event: React_2.SyntheticEvent, columnId: TableColumnId, sortDirection: SortDirection) => void;
    sort: <TRowState extends TableRowData<TItem>>(rows: TRowState[]) => TRowState[];
    sortColumn: TableColumnId | undefined;
    sortDirection: SortDirection;
    toggleColumnSort: (event: React_2.SyntheticEvent, columnId: TableColumnId) => void;
}

// @public
export type TableState = ComponentState<TableSlots> & Pick<Required<TableProps>, 'size' | 'noNativeElements'> & TableContextValue;

// @public (undocumented)
export const useColumnIdContext: () => TableColumnId;

// @public
export const useDataGrid_unstable: (props: DataGridProps, ref: React_2.Ref<HTMLElement>) => DataGridState;

// @public
export const useDataGridBody_unstable: (props: DataGridBodyProps, ref: React_2.Ref<HTMLElement>) => DataGridBodyState;

// @public
export const useDataGridBodyStyles_unstable: (state: DataGridBodyState) => DataGridBodyState;

// @public
export const useDataGridCell_unstable: (props: DataGridCellProps, ref: React_2.Ref<HTMLElement>) => DataGridCellState;

// @public
export const useDataGridCellStyles_unstable: (state: DataGridCellState) => DataGridCellState;

// @public (undocumented)
export const useDataGridContext_unstable: <T>(selector: ContextSelector<DataGridContextValue, T>) => T;

// @public (undocumented)
export function useDataGridContextValues_unstable(state: DataGridState): DataGridContextValues;

// @public
export const useDataGridHeader_unstable: (props: DataGridHeaderProps, ref: React_2.Ref<HTMLElement>) => DataGridHeaderState;

// @public
export const useDataGridHeaderCell_unstable: (props: DataGridHeaderCellProps, ref: React_2.Ref<HTMLElement>) => DataGridHeaderCellState;

// @public
export const useDataGridHeaderCellStyles_unstable: (state: DataGridHeaderCellState) => DataGridHeaderCellState;

// @public
export const useDataGridHeaderStyles_unstable: (state: DataGridHeaderState) => DataGridHeaderState;

// @public
export const useDataGridRow_unstable: (props: DataGridRowProps, ref: React_2.Ref<HTMLElement>) => DataGridRowState;

// @public
export const useDataGridRowStyles_unstable: (state: DataGridRowState) => DataGridRowState;

// @public
export const useDataGridSelectionCell_unstable: (props: DataGridSelectionCellProps, ref: React_2.Ref<HTMLElement>) => DataGridSelectionCellState;

// @public
export const useDataGridSelectionCellStyles_unstable: (state: DataGridSelectionCellState) => DataGridSelectionCellState;

// @public
export const useDataGridStyles_unstable: (state: DataGridState) => DataGridState;

// @public (undocumented)
export const useIsInTableHeader: () => boolean;

// @public
export const useTable_unstable: (props: TableProps, ref: React_2.Ref<HTMLElement>) => TableState;

// @public
export const useTableBody_unstable: (props: TableBodyProps, ref: React_2.Ref<HTMLElement>) => TableBodyState;

// @public
export const useTableBodyStyles_unstable: (state: TableBodyState) => TableBodyState;

// @public
export const useTableCell_unstable: (props: TableCellProps, ref: React_2.Ref<HTMLElement>) => TableCellState;

// @public
export const useTableCellActions_unstable: (props: TableCellActionsProps, ref: React_2.Ref<HTMLElement>) => TableCellActionsState;

// @public
export const useTableCellActionsStyles_unstable: (state: TableCellActionsState) => TableCellActionsState;

// @public
export const useTableCellLayout_unstable: (props: TableCellLayoutProps, ref: React_2.Ref<HTMLElement>) => TableCellLayoutState;

// @public
export const useTableCellLayoutStyles_unstable: (state: TableCellLayoutState) => TableCellLayoutState;

// @public
export const useTableCellStyles_unstable: (state: TableCellState) => TableCellState;

// @public (undocumented)
export function useTableColumnSizing_unstable<TItem>(params?: UseTableColumnSizingParams): (tableState: TableFeaturesState<TItem>) => TableFeaturesState<TItem>;

// @public (undocumented)
export function useTableCompositeNavigation(): {
    onTableKeyDown: React_2.KeyboardEventHandler;
    tableTabsterAttribute: TabsterDOMAttribute;
    tableRowTabsterAttribute: TabsterDOMAttribute;
};

// @public (undocumented)
export const useTableContext: () => TableContextValue;

// @public (undocumented)
export function useTableFeatures<TItem>(options: UseTableFeaturesOptions<TItem>, plugins?: TableFeaturePlugin[]): TableFeaturesState<TItem>;

// @public (undocumented)
export interface UseTableFeaturesOptions<TItem> {
    // (undocumented)
    columns: TableColumnDefinition<TItem>[];
    // (undocumented)
    getRowId?: (item: TItem) => TableRowId;
    // (undocumented)
    items: TItem[];
}

// @public
export const useTableHeader_unstable: (props: TableHeaderProps, ref: React_2.Ref<HTMLElement>) => TableHeaderState;

// @public
export const useTableHeaderCell_unstable: (props: TableHeaderCellProps, ref: React_2.Ref<HTMLElement>) => TableHeaderCellState;

// @public
export const useTableHeaderCellStyles_unstable: (state: TableHeaderCellState) => TableHeaderCellState;

// @public
export const useTableHeaderStyles_unstable: (state: TableHeaderState) => TableHeaderState;

// @public
export const useTableResizeHandle_unstable: (props: TableResizeHandleProps, ref: React_2.Ref<HTMLElement>) => TableResizeHandleState;

// @public
export const useTableResizeHandleStyles_unstable: (state: TableResizeHandleState) => TableResizeHandleState;

// @public
export const useTableRow_unstable: (props: TableRowProps, ref: React_2.Ref<HTMLElement>) => TableRowState;

// @public (undocumented)
export const useTableRowIdContext: () => TableRowId;

// @public
export const useTableRowStyles_unstable: (state: TableRowState) => TableRowState;

// @public (undocumented)
export function useTableSelection<TItem>(options: SelectionHookParams): (tableState: TableFeaturesState<TItem>) => TableFeaturesState<TItem>;

// @public
export const useTableSelectionCell_unstable: (props: TableSelectionCellProps, ref: React_2.Ref<HTMLElement>) => TableSelectionCellState;

// @public
export const useTableSelectionCellStyles_unstable: (state: TableSelectionCellState) => TableSelectionCellState;

// @public (undocumented)
export function useTableSort<TItem>(options: UseTableSortOptions): (tableState: TableFeaturesState<TItem>) => TableFeaturesState<TItem>;

// @public
export const useTableStyles_unstable: (state: TableState) => TableState;

// (No @packageDocumentation comment for this package)