/** @packageDocumentation
 * @module Table
 */
import "./Table.scss";
import "../columnfiltering/ColumnFiltering.scss";
import * as React from "react";
import { CommonProps, UiSettings, UiSettingsStorage } from "@bentley/ui-core";
import { SelectionMode } from "../../common/selection/SelectionModes";
import { PropertyUpdatedArgs } from "../../editors/EditorContainer";
import { PropertyDialogState, PropertyValueRendererManager } from "../../properties/ValueRendererManager";
import { CompositeFilterDescriptorCollection } from "../columnfiltering/ColumnFiltering";
import { CellItem, RowItem, TableDataProvider } from "../TableDataProvider";
import { TableColumn } from "./TableColumn";
/**
 * Specifies table selection target.
 * @public
 */
export declare enum TableSelectionTarget {
    Row = 0,
    Cell = 1
}
/** Properties for the Table React component
 * @public
 */
export interface TableProps extends CommonProps {
    /** Data provider for the Table */
    dataProvider: TableDataProvider;
    /** Amount of rows per page. The default is 100. */
    pageAmount?: number;
    /** Called when rows are loaded */
    onRowsLoaded?: (firstRowIndex: number, lastRowIndex: number) => void;
    /** Callback for determining if row is selected */
    isRowSelected?: (row: RowItem) => boolean;
    /** Callback for when rows are selected */
    onRowsSelected?: (rowIterator: AsyncIterableIterator<RowItem>, replace: boolean) => Promise<boolean>;
    /** Callback for when rows are deselected */
    onRowsDeselected?: (rowIterator: AsyncIterableIterator<RowItem>) => Promise<boolean>;
    /** Callback for determining if cell is selected */
    isCellSelected?: (rowIndex: number, cell: CellItem) => boolean;
    /** Callback for when cells are selected */
    onCellsSelected?: (cellIterator: AsyncIterableIterator<[RowItem, CellItem]>, replace: boolean) => Promise<boolean>;
    /** Callback for when cells are deselected */
    onCellsDeselected?: (cellIterator: AsyncIterableIterator<[RowItem, CellItem]>) => Promise<boolean>;
    /** Specifies the selection target. The default is Row. */
    tableSelectionTarget?: TableSelectionTarget;
    /** Specifies the selection mode. The default is Single. */
    selectionMode?: SelectionMode;
    /** Callback for when properties are being edited @beta */
    onPropertyEditing?: (args: TableCellEditorState) => void;
    /** Callback for when properties are updated @beta */
    onPropertyUpdated?: (propertyArgs: PropertyUpdatedArgs, cellArgs: TableCellUpdatedArgs) => Promise<boolean>;
    /** @internal */
    renderRow?: (item: RowItem, props: TableRowProps) => React.ReactNode;
    /** Enables context menu to show/hide columns */
    showHideColumns?: boolean;
    /** Indicates whether the Table columns are reorderable */
    reorderableColumns?: boolean;
    /** Optional parameter for persistent UI settings. Used for column reordering and show persistency. */
    settingsStorage?: UiSettingsStorage;
    /** Optional parameter for persistent UI settings. Used for column reordering and show persistency.
     * @deprecated use settingsStorage property */
    uiSettings?: UiSettings;
    /** Identifying string used for persistent state. */
    settingsIdentifier?: string;
    /** Custom property value renderer manager */
    propertyValueRendererManager?: PropertyValueRendererManager;
    /**
     * Gets called when rendering is finished. Should be used while testing to know when asynchronous rendering has finished.
     * @internal
     */
    onRender?: () => void;
    /** Hide the header */
    hideHeader?: boolean;
    /** Alternate the background of odd and even rows */
    stripedRows?: boolean;
    /** Specifies a row index to scroll to */
    scrollToRow?: number;
    /** @internal */
    onScrollToRow?: (rowIndex: number) => void;
    /** @internal */
    onApplyFilter?: () => void;
    /** Called to show a context menu when a cell is right-clicked. @beta */
    onCellContextMenu?: (args: TableCellContextMenuArgs) => void;
    /** Maximum number of distinct values for filtering */
    maximumDistinctValues?: number;
}
/** Properties for a Table cell
 * @public
 */
export interface CellProps {
    item: CellItem;
    displayValue: string;
    render: React.ComponentType<{
        isSelected: boolean;
    }>;
}
/** Properties for a Table row
 * @public
 */
export interface RowProps {
    index: number;
    item: RowItem;
    cells: {
        [key: string]: CellProps;
    };
    render?: () => React.ReactNode;
    style?: React.CSSProperties;
}
/** Cell/Property Editor state
 * @public
 */
export interface TableCellEditorState {
    active: boolean;
    rowIndex?: number;
    colIndex?: number;
    cellKey?: string;
}
/** Cell/Property Updated Args
 * @public
 */
export interface TableCellUpdatedArgs {
    rowIndex: number;
    colIndex: number;
    cellKey: string;
}
/** Arguments for `TableProps.onCellContextMenu` callback
 * @beta
 */
export interface TableCellContextMenuArgs {
    /** Index of the row clicked */
    rowIndex: number;
    /** Index of the column clicked */
    colIndex: number;
    /** Key of the cell clicked */
    cellKey: string;
    /** An event which caused the context menu callback */
    event: React.MouseEvent;
    /** CellItem of the cell clicked */
    cellItem?: CellItem;
}
/** @internal */
interface TableState {
    columns: TableColumn[];
    hiddenColumns: string[];
    rows: RowProps[];
    rowsCount: number;
    menuVisible: boolean;
    menuX: number;
    menuY: number;
    cellEditorState: TableCellEditorState;
    dialog?: PropertyDialogState;
    keyboardEditorCellKey?: string;
    gridContainer: HTMLDivElement | null;
}
declare const enum UpdateStatus {
    Continue = 0,
    Abort = 1
}
/**
 * Table React component that displays rows and columns in a grid along with a header
 * @public
 */
export declare class Table extends React.Component<TableProps, TableState> {
    private _pageAmount;
    private _disposableListeners;
    private _isMounted;
    private _currentUpdate;
    private _pendingUpdate;
    private _rowLoadGuid;
    private _rowSelectionHandler;
    private _cellSelectionHandler;
    private _selectedRowIndices;
    private _selectedCellKeys;
    private _rowItemSelectionHandlers?;
    private _cellItemSelectionHandlers?;
    private _pressedItemSelected;
    private _tableRef;
    private _gridRef;
    private _gridContainerRef;
    private _filterDescriptors?;
    private _filterRowShown;
    private _topRowIndex;
    private _pokeScrollTimer;
    /** @internal */
    readonly state: TableState;
    /** @internal */
    constructor(props: TableProps);
    private get rowItemSelectionHandlers();
    private get cellItemSelectionHandlers();
    private createRowIterator;
    private createCellIterator;
    private _onRowsSelected;
    private _onRowsDeselected;
    private _onCellsSelected;
    private _onCellsDeselected;
    private get _tableSelectionTarget();
    /** @internal */
    componentDidUpdate(previousProps: TableProps, previousState: TableState): void;
    /** @internal */
    componentDidMount(): void;
    /** @internal */
    componentWillUnmount(): void;
    private scrollToRow;
    private setFocusToSelected;
    private handlePendingUpdate;
    private updateColumns;
    private _onColumnsChanged;
    private updateRows;
    private _pokeScrollAfterUpdate;
    private _queuePokeScroll;
    private _unsetPokeScrollTimeout;
    private _onRowsChanged;
    /** @internal */
    update(): Promise<UpdateStatus>;
    /** @internal */
    updateSelectedRows(): void;
    /** @internal */
    updateSelectedCells(): void;
    private _columnDescriptionToReactDataGridColumn;
    private _getCellItem;
    private isCellSelected;
    private selectCells;
    private deselectCells;
    private createRowItemSelectionHandler;
    private _rowComponentSelectionHandler;
    private createCellItemSelectionHandler;
    private _cellComponentSelectionHandler;
    private _rowGetter;
    private _rowGetterAsync;
    private renderCellContent;
    private getCellDisplayValue;
    private createPropsForRowItem;
    private loadRows;
    private _handleGridSort;
    private getColumnIndexFromKey;
    private gridSortAsync;
    private createRowCells;
    private getCellBorderStyle;
    private _createRowRenderer;
    private renderRow;
    private _onMouseUp;
    private _onMouseDown;
    private _onHeaderDrop;
    private cellEditOnClick;
    private cellContextMenu;
    private activateCellEditor;
    private _deactivateCellEditor;
    /** @internal */
    shouldComponentUpdate(_props: TableProps): boolean;
    private _onCellCommit;
    private _getVisibleColumns;
    private _handleShowHideContextMenu;
    private _hideContextMenu;
    private _handleShowHideChange;
    private _onDialogOpen;
    private _onDialogClose;
    private _isShowFilterRow;
    /** Turn on/off filter row */
    private toggleFilterRow;
    /** Gets the filter descriptors for the table.
     * @internal
     */
    get filterDescriptors(): CompositeFilterDescriptorCollection;
    /** Gets ECExpression to get property display value.
     * @internal
     */
    getPropertyDisplayValueExpression(property: string): string;
    private _handleFilterChange;
    private _handleOnClearFilters;
    private _applyFilter;
    private _getValidFilterValues;
    private _onScroll;
    /** Determines if focus is in an input element - for filter checking */
    private isFocusOnInputElement;
    private _onKeyboardEvent;
    private _onKeyDown;
    private _onKeyUp;
    /** @internal */
    render(): JSX.Element;
}
/**
 * Props for the [[TableRow]] component
 * @internal
 */
export interface TableRowProps extends CommonProps {
    cells: {
        [key: string]: React.ReactNode;
    };
    isSelected?: boolean;
}
/**
 * Default component for rendering a row for the Table
 * @internal
 */
export declare class TableRow extends React.Component<TableRowProps> {
    /** @internal */
    render(): JSX.Element;
}
export {};
//# sourceMappingURL=Table.d.ts.map