import * as columnSelectors from './reducer/column';
import * as focusSelectors from './reducer/focus';
import * as selectionSelectors from './reducer/selection';
import * as rangeSelectionSelectors from './reducer/range-selection';
import * as sortSelectors from './reducer/sort';
import * as rowSelectors from './reducer/row';
import * as editSelectors from './reducer/edit';
import * as viewSelectors from './reducer/view';
import * as filterSelectors from './reducer/filter';
import * as dragSelectors from './reducer/drag';
declare const selectors: {
    selectFilterMode: (state: filterSelectors.GridFilterState) => "default" | "highlight";
    selectFilterFn: (state: filterSelectors.GridFilterState) => ((row: unknown) => boolean) | undefined;
    selectLoading: (state: viewSelectors.GridViewState) => number | boolean;
    selectNumberOfRowsInView: (state: viewSelectors.GridViewState) => number;
    selectRowHeight: (state: viewSelectors.GridViewState) => number;
    selectActionsMenuEnabled: (state: viewSelectors.GridViewState) => boolean;
    selectActionsMenuDetails: (state: viewSelectors.GridViewState) => {
        visible: false;
        rowId: null;
        coordinates: null;
    } | {
        visible: true;
        rowId: string | number;
        coordinates: {
            top: number;
            left: number;
        };
    };
    selectAggregationEnabled: (state: viewSelectors.GridViewState) => boolean;
    selectColumnMenuDetails: (state: viewSelectors.GridViewState) => {
        visible: false;
        coordinates: null;
    } | {
        visible: true;
        coordinates: {
            top: number;
            left: number;
        };
    };
    selectColumnMenuEnabled: (state: viewSelectors.GridViewState) => boolean;
    selectEdit: (state: editSelectors.GridEditState) => editSelectors.GridEditState;
    selectIsEditing: (state: editSelectors.GridEditState) => state is {
        columnId: string;
        rowId: import("..").GridRowId;
    };
    selectIsEditingCell: (state: editSelectors.GridEditState, { rowId, columnId }: {
        rowId: import("..").GridRowId;
        columnId: string;
    }) => boolean;
    selectIsEditingCellInColumn: (state: editSelectors.GridEditState, columnId: string) => boolean;
    selectNavigationEnabled: (state: {
        enabled: boolean;
    }) => boolean;
    selectRow: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => any;
    selectRowMeta: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => import("..").GridRowMeta;
    selectRowCollection: (state: rowSelectors.GridRowState) => import("../data-tools/types").Collection;
    selectRowLevel: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => number;
    selectRowLevelMap: (state: rowSelectors.GridRowState) => Map<import("..").GridRowId, number> | undefined;
    selectIsRowExpandable: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectIsRowLoaded: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectAreExpandedRowsControlled: (state: rowSelectors.GridRowState) => boolean;
    selectExpandedRows: (state: rowSelectors.GridRowState) => Set<import("..").GridRowId>;
    selectIsRowExpanded: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectRowsExpanded: (state: rowSelectors.GridRowState) => Set<import("..").GridRowId>;
    selectCanDragRow: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectSortMode: (state: sortSelectors.GridSortState) => "internal" | "external";
    selectSortLocale: (state: sortSelectors.GridSortState) => string;
    selectSortColumns: (state: sortSelectors.GridSortState) => import("..").GridColumnSort[];
    selectColumnSort: (state: sortSelectors.GridSortState, columnId: string) => import("..").GridColumnSort | undefined;
    selectSort: (state: sortSelectors.GridSortState) => import("..").GridColumnSort[];
    selectDefaultSort: (state: sortSelectors.GridSortState) => import("..").GridColumnSort[] | undefined;
    selectIsMultiColumnSortingEnabled: (state: sortSelectors.GridSortState) => boolean;
    selectIsMultiColumnSorting: (state: sortSelectors.GridSortState) => boolean;
    selectColumnSortNumber: (state: sortSelectors.GridSortState, columnId: string) => number;
    selectRangeSelection: (state: rangeSelectionSelectors.GridRangeSelectionState) => import("..").GridRangeSelection | null;
    selectRangeSelectionPreview: (state: rangeSelectionSelectors.GridRangeSelectionState) => import("..").GridRangeSelection | null;
    selectIsSpreadsheet: (state: rangeSelectionSelectors.GridRangeSelectionState) => boolean;
    selectIsRangeSelectionControlled: (state: rangeSelectionSelectors.GridRangeSelectionState) => boolean;
    selectSelection: (state: selectionSelectors.GridSelectionState) => Set<import("..").GridRowId>;
    selectSelectionMode: (state: selectionSelectors.GridSelectionState) => "single" | "multi" | "none";
    selectSelectionAnchor: (state: selectionSelectors.GridSelectionState) => import("..").GridRowId | null;
    selectDragNeedsFinalRowOffset: (state: dragSelectors.GridDragState) => boolean;
    selectDragIsActive: (state: dragSelectors.GridDragState) => boolean;
    selectDragMoveReceived: (state: dragSelectors.GridDragState) => boolean;
    selectIsRowDragging: (state: dragSelectors.GridDragState, rowId: import("..").GridRowId) => boolean;
    selectDropIsAllowed: (state: dragSelectors.GridDragState) => boolean;
    selectDragMessage: (state: dragSelectors.GridDragState) => string;
    selectDragCollisionDetails: (state: dragSelectors.GridDragState) => import("../functional/grid-drag-controller/collision").CollisionDetails;
    selectDraggingRowIds: (state: dragSelectors.GridDragState) => Set<import("..").GridRowId>;
    selectRecentlyDroppedRowIds: (state: dragSelectors.GridDragState) => Set<import("..").GridRowId>;
    selectIsDraggingEnabled: (state: dragSelectors.GridDragState) => boolean;
    selectCanDragMultiple: (state: dragSelectors.GridDragState) => boolean;
    selectCanConvertLeaf: (state: dragSelectors.GridDragState) => boolean;
    selectDragMode: (state: dragSelectors.GridDragState) => import("..").GridRowDragMode;
    selectDropPredicate: (state: dragSelectors.GridDragState) => (info: import("..").GridRowDropInfo<any, any>) => import("..").GridDragResponse;
    selectConfiguredPreviewColumnId: (state: dragSelectors.GridDragState) => string | null;
    selectRawCurrentFocus: (state: focusSelectors.GridFocusState) => {
        columnId: string;
        rowId: import("..").GridRowId;
        area: focusSelectors.GridFocusArea;
        subFocus: number | "first" | "last";
    };
    selectSubFocus: (state: focusSelectors.GridFocusState) => number | "first" | "last";
    selectCanLoopHorizontally: (state: focusSelectors.GridFocusState) => boolean | undefined;
    selectTreeIndentSize: (state: columnSelectors.GridColumnState) => import("..").GridTreeIndentSize;
    selectAreHeadersHidden: (state: columnSelectors.GridColumnState) => boolean;
    selectColumn: (state: columnSelectors.GridColumnState, columnId: string) => import("./types").ColumnState;
    selectColumnSortEntities: (state: columnSelectors.GridColumnState) => import("./types").ColumnSortInfo;
    selectColumnPreference: (state: columnSelectors.GridColumnState, columnId: string) => import("./types").ColumnPreference;
    selectColumnCount: (state: columnSelectors.GridColumnState) => number;
    selectUnsortedColumnIds: (state: columnSelectors.GridColumnState) => string[];
    selectColumnIdsWithHidden: (state: columnSelectors.GridColumnState) => string[];
    selectHiddenIds: (state: columnSelectors.GridColumnState) => string[];
    selectGroupIds: (state: columnSelectors.GridColumnState) => string[];
    selectHeaderHierarchy: (state: columnSelectors.GridColumnState) => import("./types").HeaderHierarchy;
    selectHeaderHeight: (state: columnSelectors.GridColumnState) => number;
    selectIsTreeGrid: (state: columnSelectors.GridColumnState) => boolean;
    selectColumnStickyOffset: (state: columnSelectors.GridColumnState, columnId: string) => number;
    selectColumnGroupStickyOffset: (state: columnSelectors.GridColumnState, columnId: string) => number;
    selectTotalColumnWidth: (state: columnSelectors.GridColumnState) => number;
    selectAggregationConfigurations: (state: columnSelectors.GridColumnState) => import("./types").ColumnAggregationMapType[];
    selectColumnEntities: (state: columnSelectors.GridColumnState) => Record<string, import("./types").ColumnState>;
};
export declare function createSelectors(): {
    selectStickyColumnIds: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => {
        left: Set<string>;
        right: Set<string>;
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Record<string, import("./types").ColumnState>) => {
            left: Set<string>;
            right: Set<string>;
        };
        memoizedResultFunc: ((resultFuncArgs_0: Record<string, import("./types").ColumnState>) => {
            left: Set<string>;
            right: Set<string>;
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => {
            left: Set<string>;
            right: Set<string>;
        };
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => Record<string, import("./types").ColumnState>];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectBorderLayout: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => Map<string, {
        header: {
            left: boolean;
            right: boolean;
        };
        body: {
            left: boolean;
            right: boolean;
        };
        footer: {
            left: boolean;
            right: boolean;
        };
    }>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Record<string, import("./types").ColumnState>, resultFuncArgs_1: string[], resultFuncArgs_2: string[], resultFuncArgs_3: boolean) => Map<string, {
            header: {
                left: boolean;
                right: boolean;
            };
            body: {
                left: boolean;
                right: boolean;
            };
            footer: {
                left: boolean;
                right: boolean;
            };
        }>;
        memoizedResultFunc: ((resultFuncArgs_0: Record<string, import("./types").ColumnState>, resultFuncArgs_1: string[], resultFuncArgs_2: string[], resultFuncArgs_3: boolean) => Map<string, {
            header: {
                left: boolean;
                right: boolean;
            };
            body: {
                left: boolean;
                right: boolean;
            };
            footer: {
                left: boolean;
                right: boolean;
            };
        }>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Map<string, {
            header: {
                left: boolean;
                right: boolean;
            };
            body: {
                left: boolean;
                right: boolean;
            };
            footer: {
                left: boolean;
                right: boolean;
            };
        }>;
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => Record<string, import("./types").ColumnState>, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => boolean];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectColSpanConfig: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => {
        colSpanFunctions: {
            sourceColumn: string;
            colSpan: import("..").ColumnField<any>[] | ((props: import("..").CellColSpanParams<any, any>) => import("..").ColumnField<any>[]);
        }[];
        columnIds: string[];
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Record<string, import("./types").ColumnState>, resultFuncArgs_1: string[], resultFuncArgs_2: string[]) => {
            colSpanFunctions: {
                sourceColumn: string;
                colSpan: import("..").ColumnField<any>[] | ((props: import("..").CellColSpanParams<any, any>) => import("..").ColumnField<any>[]);
            }[];
            columnIds: string[];
        };
        memoizedResultFunc: ((resultFuncArgs_0: Record<string, import("./types").ColumnState>, resultFuncArgs_1: string[], resultFuncArgs_2: string[]) => {
            colSpanFunctions: {
                sourceColumn: string;
                colSpan: import("..").ColumnField<any>[] | ((props: import("..").CellColSpanParams<any, any>) => import("..").ColumnField<any>[]);
            }[];
            columnIds: string[];
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => {
            colSpanFunctions: {
                sourceColumn: string;
                colSpan: import("..").ColumnField<any>[] | ((props: import("..").CellColSpanParams<any, any>) => import("..").ColumnField<any>[]);
            }[];
            columnIds: string[];
        };
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => Record<string, import("./types").ColumnState>, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string[]];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectPreviewColumnId: (state: import("./reducer").GridState) => string | undefined;
    selectPreviewLeftOffset: (state: import("./reducer").GridState) => number;
    selectIsInRangeSelection: (state: import("./reducer").GridState, columnId: string, rowId: import("..").GridRowId) => boolean;
    selectCellRangeBorders: (state: import("./reducer").GridState, columnId: string, rowId: import("..").GridRowId) => number;
    selectRangeIds: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => {
        rowIds: import("..").GridRowId[];
        columnIds: string[];
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: import("../utils/range").GridRangeIds) => {
            rowIds: import("..").GridRowId[];
            columnIds: string[];
        };
        memoizedResultFunc: ((resultFuncArgs_0: import("../utils/range").GridRangeIds) => {
            rowIds: import("..").GridRowId[];
            columnIds: string[];
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => {
            rowIds: import("..").GridRowId[];
            columnIds: string[];
        };
        dependencies: [((state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("../utils/range").GridRangeIds) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: import("..").GridRangeSelection | null, resultFuncArgs_1: import("..").GridRangeSelection | null, resultFuncArgs_2: import("..").GridRowId[], resultFuncArgs_3: string[]) => import("../utils/range").GridRangeIds;
            memoizedResultFunc: ((resultFuncArgs_0: import("..").GridRangeSelection | null, resultFuncArgs_1: import("..").GridRangeSelection | null, resultFuncArgs_2: import("..").GridRowId[], resultFuncArgs_3: string[]) => import("../utils/range").GridRangeIds) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => import("../utils/range").GridRangeIds;
            dependencies: [(state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => import("..").GridRangeSelection | null, (state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => import("..").GridRangeSelection | null, ((state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => import("..").GridRowId[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: {
                    ids: import("..").GridRowId[];
                    indexes: Map<import("..").GridRowId, number>;
                    setDetails: Map<import("..").GridRowId, {
                        setSize: number;
                        posInset: number;
                    }>;
                }) => import("..").GridRowId[];
                memoizedResultFunc: ((resultFuncArgs_0: {
                    ids: import("..").GridRowId[];
                    indexes: Map<import("..").GridRowId, number>;
                    setDetails: Map<import("..").GridRowId, {
                        setSize: number;
                        posInset: number;
                    }>;
                }) => import("..").GridRowId[]) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => import("..").GridRowId[];
                dependencies: [((state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => {
                    ids: import("..").GridRowId[];
                    indexes: Map<import("..").GridRowId, number>;
                    setDetails: Map<import("..").GridRowId, {
                        setSize: number;
                        posInset: number;
                    }>;
                }) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                } & {
                    resultFunc: (resultFuncArgs_0: import("../data-tools/types").Collection, resultFuncArgs_1: Set<import("..").GridRowId>, resultFuncArgs_2: ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null, resultFuncArgs_3: Set<import("..").GridRowId> | null) => {
                        ids: import("..").GridRowId[];
                        indexes: Map<import("..").GridRowId, number>;
                        setDetails: Map<import("..").GridRowId, {
                            setSize: number;
                            posInset: number;
                        }>;
                    };
                    memoizedResultFunc: ((resultFuncArgs_0: import("../data-tools/types").Collection, resultFuncArgs_1: Set<import("..").GridRowId>, resultFuncArgs_2: ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null, resultFuncArgs_3: Set<import("..").GridRowId> | null) => {
                        ids: import("..").GridRowId[];
                        indexes: Map<import("..").GridRowId, number>;
                        setDetails: Map<import("..").GridRowId, {
                            setSize: number;
                            posInset: number;
                        }>;
                    }) & {
                        clearCache: () => void;
                        resultsCount: () => number;
                        resetResultsCount: () => void;
                    };
                    lastResult: () => {
                        ids: import("..").GridRowId[];
                        indexes: Map<import("..").GridRowId, number>;
                        setDetails: Map<import("..").GridRowId, {
                            setSize: number;
                            posInset: number;
                        }>;
                    };
                    dependencies: [(state: {
                        columns: columnSelectors.GridColumnState;
                        currentEdit: editSelectors.GridEditState;
                        currentFocus: focusSelectors.GridFocusState;
                        drag: dragSelectors.GridDragState;
                        filter: filterSelectors.GridFilterState;
                        navigation: {
                            enabled: boolean;
                        };
                        rows: rowSelectors.GridRowState;
                        selection: selectionSelectors.GridSelectionState;
                        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                        sort: sortSelectors.GridSortState;
                        view: viewSelectors.GridViewState;
                    }) => import("../data-tools/types").Collection, (state: {
                        columns: columnSelectors.GridColumnState;
                        currentEdit: editSelectors.GridEditState;
                        currentFocus: focusSelectors.GridFocusState;
                        drag: dragSelectors.GridDragState;
                        filter: filterSelectors.GridFilterState;
                        navigation: {
                            enabled: boolean;
                        };
                        rows: rowSelectors.GridRowState;
                        selection: selectionSelectors.GridSelectionState;
                        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                        sort: sortSelectors.GridSortState;
                        view: viewSelectors.GridViewState;
                    }) => Set<import("..").GridRowId>, ((state: {
                        columns: columnSelectors.GridColumnState;
                        currentEdit: editSelectors.GridEditState;
                        currentFocus: focusSelectors.GridFocusState;
                        drag: dragSelectors.GridDragState;
                        filter: filterSelectors.GridFilterState;
                        navigation: {
                            enabled: boolean;
                        };
                        rows: rowSelectors.GridRowState;
                        selection: selectionSelectors.GridSelectionState;
                        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                        sort: sortSelectors.GridSortState;
                        view: viewSelectors.GridViewState;
                    }) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null) & {
                        clearCache: () => void;
                        resultsCount: () => number;
                        resetResultsCount: () => void;
                    } & {
                        resultFunc: (resultFuncArgs_0: "internal" | "external", resultFuncArgs_1: import("..").GridColumnSort[], resultFuncArgs_2: string, resultFuncArgs_3: import("./types").ColumnSortInfo) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null;
                        memoizedResultFunc: ((resultFuncArgs_0: "internal" | "external", resultFuncArgs_1: import("..").GridColumnSort[], resultFuncArgs_2: string, resultFuncArgs_3: import("./types").ColumnSortInfo) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null) & {
                            clearCache: () => void;
                            resultsCount: () => number;
                            resetResultsCount: () => void;
                        };
                        lastResult: () => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null;
                        dependencies: [(state: {
                            columns: columnSelectors.GridColumnState;
                            currentEdit: editSelectors.GridEditState;
                            currentFocus: focusSelectors.GridFocusState;
                            drag: dragSelectors.GridDragState;
                            filter: filterSelectors.GridFilterState;
                            navigation: {
                                enabled: boolean;
                            };
                            rows: rowSelectors.GridRowState;
                            selection: selectionSelectors.GridSelectionState;
                            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                            sort: sortSelectors.GridSortState;
                            view: viewSelectors.GridViewState;
                        }) => "internal" | "external", (state: {
                            columns: columnSelectors.GridColumnState;
                            currentEdit: editSelectors.GridEditState;
                            currentFocus: focusSelectors.GridFocusState;
                            drag: dragSelectors.GridDragState;
                            filter: filterSelectors.GridFilterState;
                            navigation: {
                                enabled: boolean;
                            };
                            rows: rowSelectors.GridRowState;
                            selection: selectionSelectors.GridSelectionState;
                            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                            sort: sortSelectors.GridSortState;
                            view: viewSelectors.GridViewState;
                        }) => import("..").GridColumnSort[], (state: {
                            columns: columnSelectors.GridColumnState;
                            currentEdit: editSelectors.GridEditState;
                            currentFocus: focusSelectors.GridFocusState;
                            drag: dragSelectors.GridDragState;
                            filter: filterSelectors.GridFilterState;
                            navigation: {
                                enabled: boolean;
                            };
                            rows: rowSelectors.GridRowState;
                            selection: selectionSelectors.GridSelectionState;
                            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                            sort: sortSelectors.GridSortState;
                            view: viewSelectors.GridViewState;
                        }) => string, (state: {
                            columns: columnSelectors.GridColumnState;
                            currentEdit: editSelectors.GridEditState;
                            currentFocus: focusSelectors.GridFocusState;
                            drag: dragSelectors.GridDragState;
                            filter: filterSelectors.GridFilterState;
                            navigation: {
                                enabled: boolean;
                            };
                            rows: rowSelectors.GridRowState;
                            selection: selectionSelectors.GridSelectionState;
                            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                            sort: sortSelectors.GridSortState;
                            view: viewSelectors.GridViewState;
                        }) => import("./types").ColumnSortInfo];
                        recomputations: () => number;
                        resetRecomputations: () => void;
                        dependencyRecomputations: () => number;
                        resetDependencyRecomputations: () => void;
                    } & {
                        memoize: typeof import("reselect").weakMapMemoize;
                        argsMemoize: typeof import("reselect").weakMapMemoize;
                    }, ((state: {
                        columns: columnSelectors.GridColumnState;
                        currentEdit: editSelectors.GridEditState;
                        currentFocus: focusSelectors.GridFocusState;
                        drag: dragSelectors.GridDragState;
                        filter: filterSelectors.GridFilterState;
                        navigation: {
                            enabled: boolean;
                        };
                        rows: rowSelectors.GridRowState;
                        selection: selectionSelectors.GridSelectionState;
                        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                        sort: sortSelectors.GridSortState;
                        view: viewSelectors.GridViewState;
                    }) => Set<import("..").GridRowId> | null) & {
                        clearCache: () => void;
                        resultsCount: () => number;
                        resetResultsCount: () => void;
                    } & {
                        resultFunc: (resultFuncArgs_0: "default" | "highlight", resultFuncArgs_1: {
                            matchedIds: Set<import("..").GridRowId>;
                            necessaryMatchedIds: Set<import("..").GridRowId>;
                        } | {
                            matchedIds: null;
                            necessaryMatchedIds: null;
                        }) => Set<import("..").GridRowId> | null;
                        memoizedResultFunc: ((resultFuncArgs_0: "default" | "highlight", resultFuncArgs_1: {
                            matchedIds: Set<import("..").GridRowId>;
                            necessaryMatchedIds: Set<import("..").GridRowId>;
                        } | {
                            matchedIds: null;
                            necessaryMatchedIds: null;
                        }) => Set<import("..").GridRowId> | null) & {
                            clearCache: () => void;
                            resultsCount: () => number;
                            resetResultsCount: () => void;
                        };
                        lastResult: () => Set<import("..").GridRowId> | null;
                        dependencies: [(state: {
                            columns: columnSelectors.GridColumnState;
                            currentEdit: editSelectors.GridEditState;
                            currentFocus: focusSelectors.GridFocusState;
                            drag: dragSelectors.GridDragState;
                            filter: filterSelectors.GridFilterState;
                            navigation: {
                                enabled: boolean;
                            };
                            rows: rowSelectors.GridRowState;
                            selection: selectionSelectors.GridSelectionState;
                            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                            sort: sortSelectors.GridSortState;
                            view: viewSelectors.GridViewState;
                        }) => "default" | "highlight", ((state: {
                            columns: columnSelectors.GridColumnState;
                            currentEdit: editSelectors.GridEditState;
                            currentFocus: focusSelectors.GridFocusState;
                            drag: dragSelectors.GridDragState;
                            filter: filterSelectors.GridFilterState;
                            navigation: {
                                enabled: boolean;
                            };
                            rows: rowSelectors.GridRowState;
                            selection: selectionSelectors.GridSelectionState;
                            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                            sort: sortSelectors.GridSortState;
                            view: viewSelectors.GridViewState;
                        }) => {
                            matchedIds: Set<import("..").GridRowId>;
                            necessaryMatchedIds: Set<import("..").GridRowId>;
                        } | {
                            matchedIds: null;
                            necessaryMatchedIds: null;
                        }) & {
                            clearCache: () => void;
                            resultsCount: () => number;
                            resetResultsCount: () => void;
                        } & {
                            resultFunc: (resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
                                matchedIds: Set<import("..").GridRowId>;
                                necessaryMatchedIds: Set<import("..").GridRowId>;
                            } | {
                                matchedIds: null;
                                necessaryMatchedIds: null;
                            };
                            memoizedResultFunc: ((resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
                                matchedIds: Set<import("..").GridRowId>;
                                necessaryMatchedIds: Set<import("..").GridRowId>;
                            } | {
                                matchedIds: null;
                                necessaryMatchedIds: null;
                            }) & {
                                clearCache: () => void;
                                resultsCount: () => number;
                                resetResultsCount: () => void;
                            };
                            lastResult: () => {
                                matchedIds: Set<import("..").GridRowId>;
                                necessaryMatchedIds: Set<import("..").GridRowId>;
                            } | {
                                matchedIds: null;
                                necessaryMatchedIds: null;
                            };
                            dependencies: [(state: {
                                columns: columnSelectors.GridColumnState;
                                currentEdit: editSelectors.GridEditState;
                                currentFocus: focusSelectors.GridFocusState;
                                drag: dragSelectors.GridDragState;
                                filter: filterSelectors.GridFilterState;
                                navigation: {
                                    enabled: boolean;
                                };
                                rows: rowSelectors.GridRowState;
                                selection: selectionSelectors.GridSelectionState;
                                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                                sort: sortSelectors.GridSortState;
                                view: viewSelectors.GridViewState;
                            }) => ((row: unknown) => boolean) | undefined, (state: {
                                columns: columnSelectors.GridColumnState;
                                currentEdit: editSelectors.GridEditState;
                                currentFocus: focusSelectors.GridFocusState;
                                drag: dragSelectors.GridDragState;
                                filter: filterSelectors.GridFilterState;
                                navigation: {
                                    enabled: boolean;
                                };
                                rows: rowSelectors.GridRowState;
                                selection: selectionSelectors.GridSelectionState;
                                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                                sort: sortSelectors.GridSortState;
                                view: viewSelectors.GridViewState;
                            }) => import("../data-tools/types").Collection];
                            recomputations: () => number;
                            resetRecomputations: () => void;
                            dependencyRecomputations: () => number;
                            resetDependencyRecomputations: () => void;
                        } & {
                            memoize: typeof import("reselect").weakMapMemoize;
                            argsMemoize: typeof import("reselect").weakMapMemoize;
                        }];
                        recomputations: () => number;
                        resetRecomputations: () => void;
                        dependencyRecomputations: () => number;
                        resetDependencyRecomputations: () => void;
                    } & {
                        memoize: typeof import("reselect").weakMapMemoize;
                        argsMemoize: typeof import("reselect").weakMapMemoize;
                    }];
                    recomputations: () => number;
                    resetRecomputations: () => void;
                    dependencyRecomputations: () => number;
                    resetDependencyRecomputations: () => void;
                } & {
                    memoize: typeof import("reselect").weakMapMemoize;
                    argsMemoize: typeof import("reselect").weakMapMemoize;
                }];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                memoize: typeof import("reselect").weakMapMemoize;
                argsMemoize: typeof import("reselect").weakMapMemoize;
            }, ((state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => string[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: string[]) => string[];
                memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: string[]) => string[]) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => string[];
                dependencies: [(state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => string[], (state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => string[]];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                memoize: typeof import("reselect").weakMapMemoize;
                argsMemoize: typeof import("reselect").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("reselect").weakMapMemoize;
            argsMemoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectRowSelectionState: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => "none" | "some" | "all";
    selectIsRowSelected: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => boolean;
    selectIsRowVisuallySelected: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => boolean;
    selectSelectionStatus: (state: import("./reducer").GridState) => "none" | "some" | "all";
    selectAllSelectableIds: (state: import("./reducer").GridState) => Set<import("..").GridRowId>;
    selectRowExcluded: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => boolean;
    selectRowIds: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => import("..").GridRowId[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: {
            ids: import("..").GridRowId[];
            indexes: Map<import("..").GridRowId, number>;
            setDetails: Map<import("..").GridRowId, {
                setSize: number;
                posInset: number;
            }>;
        }) => import("..").GridRowId[];
        memoizedResultFunc: ((resultFuncArgs_0: {
            ids: import("..").GridRowId[];
            indexes: Map<import("..").GridRowId, number>;
            setDetails: Map<import("..").GridRowId, {
                setSize: number;
                posInset: number;
            }>;
        }) => import("..").GridRowId[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => import("..").GridRowId[];
        dependencies: [((state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => {
            ids: import("..").GridRowId[];
            indexes: Map<import("..").GridRowId, number>;
            setDetails: Map<import("..").GridRowId, {
                setSize: number;
                posInset: number;
            }>;
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: import("../data-tools/types").Collection, resultFuncArgs_1: Set<import("..").GridRowId>, resultFuncArgs_2: ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null, resultFuncArgs_3: Set<import("..").GridRowId> | null) => {
                ids: import("..").GridRowId[];
                indexes: Map<import("..").GridRowId, number>;
                setDetails: Map<import("..").GridRowId, {
                    setSize: number;
                    posInset: number;
                }>;
            };
            memoizedResultFunc: ((resultFuncArgs_0: import("../data-tools/types").Collection, resultFuncArgs_1: Set<import("..").GridRowId>, resultFuncArgs_2: ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null, resultFuncArgs_3: Set<import("..").GridRowId> | null) => {
                ids: import("..").GridRowId[];
                indexes: Map<import("..").GridRowId, number>;
                setDetails: Map<import("..").GridRowId, {
                    setSize: number;
                    posInset: number;
                }>;
            }) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => {
                ids: import("..").GridRowId[];
                indexes: Map<import("..").GridRowId, number>;
                setDetails: Map<import("..").GridRowId, {
                    setSize: number;
                    posInset: number;
                }>;
            };
            dependencies: [(state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => import("../data-tools/types").Collection, (state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => Set<import("..").GridRowId>, ((state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: "internal" | "external", resultFuncArgs_1: import("..").GridColumnSort[], resultFuncArgs_2: string, resultFuncArgs_3: import("./types").ColumnSortInfo) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null;
                memoizedResultFunc: ((resultFuncArgs_0: "internal" | "external", resultFuncArgs_1: import("..").GridColumnSort[], resultFuncArgs_2: string, resultFuncArgs_3: import("./types").ColumnSortInfo) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null;
                dependencies: [(state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => "internal" | "external", (state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => import("..").GridColumnSort[], (state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => string, (state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => import("./types").ColumnSortInfo];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                memoize: typeof import("reselect").weakMapMemoize;
                argsMemoize: typeof import("reselect").weakMapMemoize;
            }, ((state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => Set<import("..").GridRowId> | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: "default" | "highlight", resultFuncArgs_1: {
                    matchedIds: Set<import("..").GridRowId>;
                    necessaryMatchedIds: Set<import("..").GridRowId>;
                } | {
                    matchedIds: null;
                    necessaryMatchedIds: null;
                }) => Set<import("..").GridRowId> | null;
                memoizedResultFunc: ((resultFuncArgs_0: "default" | "highlight", resultFuncArgs_1: {
                    matchedIds: Set<import("..").GridRowId>;
                    necessaryMatchedIds: Set<import("..").GridRowId>;
                } | {
                    matchedIds: null;
                    necessaryMatchedIds: null;
                }) => Set<import("..").GridRowId> | null) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => Set<import("..").GridRowId> | null;
                dependencies: [(state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => "default" | "highlight", ((state: {
                    columns: columnSelectors.GridColumnState;
                    currentEdit: editSelectors.GridEditState;
                    currentFocus: focusSelectors.GridFocusState;
                    drag: dragSelectors.GridDragState;
                    filter: filterSelectors.GridFilterState;
                    navigation: {
                        enabled: boolean;
                    };
                    rows: rowSelectors.GridRowState;
                    selection: selectionSelectors.GridSelectionState;
                    rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                    sort: sortSelectors.GridSortState;
                    view: viewSelectors.GridViewState;
                }) => {
                    matchedIds: Set<import("..").GridRowId>;
                    necessaryMatchedIds: Set<import("..").GridRowId>;
                } | {
                    matchedIds: null;
                    necessaryMatchedIds: null;
                }) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                } & {
                    resultFunc: (resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
                        matchedIds: Set<import("..").GridRowId>;
                        necessaryMatchedIds: Set<import("..").GridRowId>;
                    } | {
                        matchedIds: null;
                        necessaryMatchedIds: null;
                    };
                    memoizedResultFunc: ((resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
                        matchedIds: Set<import("..").GridRowId>;
                        necessaryMatchedIds: Set<import("..").GridRowId>;
                    } | {
                        matchedIds: null;
                        necessaryMatchedIds: null;
                    }) & {
                        clearCache: () => void;
                        resultsCount: () => number;
                        resetResultsCount: () => void;
                    };
                    lastResult: () => {
                        matchedIds: Set<import("..").GridRowId>;
                        necessaryMatchedIds: Set<import("..").GridRowId>;
                    } | {
                        matchedIds: null;
                        necessaryMatchedIds: null;
                    };
                    dependencies: [(state: {
                        columns: columnSelectors.GridColumnState;
                        currentEdit: editSelectors.GridEditState;
                        currentFocus: focusSelectors.GridFocusState;
                        drag: dragSelectors.GridDragState;
                        filter: filterSelectors.GridFilterState;
                        navigation: {
                            enabled: boolean;
                        };
                        rows: rowSelectors.GridRowState;
                        selection: selectionSelectors.GridSelectionState;
                        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                        sort: sortSelectors.GridSortState;
                        view: viewSelectors.GridViewState;
                    }) => ((row: unknown) => boolean) | undefined, (state: {
                        columns: columnSelectors.GridColumnState;
                        currentEdit: editSelectors.GridEditState;
                        currentFocus: focusSelectors.GridFocusState;
                        drag: dragSelectors.GridDragState;
                        filter: filterSelectors.GridFilterState;
                        navigation: {
                            enabled: boolean;
                        };
                        rows: rowSelectors.GridRowState;
                        selection: selectionSelectors.GridSelectionState;
                        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                        sort: sortSelectors.GridSortState;
                        view: viewSelectors.GridViewState;
                    }) => import("../data-tools/types").Collection];
                    recomputations: () => number;
                    resetRecomputations: () => void;
                    dependencyRecomputations: () => number;
                    resetDependencyRecomputations: () => void;
                } & {
                    memoize: typeof import("reselect").weakMapMemoize;
                    argsMemoize: typeof import("reselect").weakMapMemoize;
                }];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                memoize: typeof import("reselect").weakMapMemoize;
                argsMemoize: typeof import("reselect").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("reselect").weakMapMemoize;
            argsMemoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectRowIndex: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => number;
    selectAriaRowCount: (state: import("./reducer").GridState) => number;
    selectHeaderRowCount: (state: import("./reducer").GridState) => number;
    selectHeaderRowIds: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => string[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: number) => string[];
        memoizedResultFunc: ((resultFuncArgs_0: number) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string[];
        dependencies: [(state: import("./reducer").GridState) => number];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectColumnSpanByRowId: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => import("../utils/column-span").ColSpanConfig | null;
    selectAriaSetSize: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => number;
    selectAriaPosInset: (state: import("./reducer").GridState, rowId: import("..").GridRowId) => number;
    selectCurrentFocus: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => {
        columnId: string;
        rowId: import("..").GridRowId;
        area: focusSelectors.GridFocusArea;
        subFocus: number | "first" | "last";
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: {
            columnId: string;
            rowId: import("..").GridRowId;
            area: focusSelectors.GridFocusArea;
            subFocus: number | "first" | "last";
        }, resultFuncArgs_1: string[], resultFuncArgs_2: import("..").GridRowId[], resultFuncArgs_3: import("..").GridRowId[], resultFuncArgs_4: string[], resultFuncArgs_5: boolean) => {
            columnId: string;
            rowId: import("..").GridRowId;
            area: focusSelectors.GridFocusArea;
            subFocus: number | "first" | "last";
        };
        memoizedResultFunc: ((resultFuncArgs_0: {
            columnId: string;
            rowId: import("..").GridRowId;
            area: focusSelectors.GridFocusArea;
            subFocus: number | "first" | "last";
        }, resultFuncArgs_1: string[], resultFuncArgs_2: import("..").GridRowId[], resultFuncArgs_3: import("..").GridRowId[], resultFuncArgs_4: string[], resultFuncArgs_5: boolean) => {
            columnId: string;
            rowId: import("..").GridRowId;
            area: focusSelectors.GridFocusArea;
            subFocus: number | "first" | "last";
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => {
            columnId: string;
            rowId: import("..").GridRowId;
            area: focusSelectors.GridFocusArea;
            subFocus: number | "first" | "last";
        };
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => {
            columnId: string;
            rowId: import("..").GridRowId;
            area: focusSelectors.GridFocusArea;
            subFocus: number | "first" | "last";
        }, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string[], (state: import("./reducer").GridState) => import("..").GridRowId[], (state: import("./reducer").GridState) => import("..").GridRowId[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => boolean];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectCollisionAreas: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => {
        collisions: ({
            left: number;
            top: number;
            bottom: number;
        } & import("../functional/grid-drag-controller/collision").CollisionDetails)[];
        maxTop: number;
        maxBottom: number;
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: Set<import("..").GridRowId>, resultFuncArgs_2: import("..").GridRowDragMode, resultFuncArgs_3: boolean, resultFuncArgs_4: number, resultFuncArgs_5: import("../data-tools/types").Collection, resultFuncArgs_6: number, resultFuncArgs_7: import("..").GridRowId[], resultFuncArgs_8: Map<import("..").GridRowId, number> | undefined, resultFuncArgs_9: import("..").GridTreeIndentSize) => {
            collisions: ({
                left: number;
                top: number;
                bottom: number;
            } & import("../functional/grid-drag-controller/collision").CollisionDetails)[];
            maxTop: number;
            maxBottom: number;
        };
        memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: Set<import("..").GridRowId>, resultFuncArgs_2: import("..").GridRowDragMode, resultFuncArgs_3: boolean, resultFuncArgs_4: number, resultFuncArgs_5: import("../data-tools/types").Collection, resultFuncArgs_6: number, resultFuncArgs_7: import("..").GridRowId[], resultFuncArgs_8: Map<import("..").GridRowId, number> | undefined, resultFuncArgs_9: import("..").GridTreeIndentSize) => {
            collisions: ({
                left: number;
                top: number;
                bottom: number;
            } & import("../functional/grid-drag-controller/collision").CollisionDetails)[];
            maxTop: number;
            maxBottom: number;
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => {
            collisions: ({
                left: number;
                top: number;
                bottom: number;
            } & import("../functional/grid-drag-controller/collision").CollisionDetails)[];
            maxTop: number;
            maxBottom: number;
        };
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => boolean, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => Set<import("..").GridRowId>, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("..").GridRowDragMode, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => boolean, (state: import("./reducer").GridState) => number, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("../data-tools/types").Collection, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => number, (state: import("./reducer").GridState) => import("..").GridRowId[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => Map<import("..").GridRowId, number> | undefined, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("..").GridTreeIndentSize];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectHasFocus: (state: import("./reducer").GridState, columnId: string, area: focusSelectors.GridFocusArea, rowId: import("..").GridRowId) => boolean;
    selectFilterMatches: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => {
        matchedIds: Set<import("..").GridRowId>;
        necessaryMatchedIds: Set<import("..").GridRowId>;
    } | {
        matchedIds: null;
        necessaryMatchedIds: null;
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
            matchedIds: Set<import("..").GridRowId>;
            necessaryMatchedIds: Set<import("..").GridRowId>;
        } | {
            matchedIds: null;
            necessaryMatchedIds: null;
        };
        memoizedResultFunc: ((resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
            matchedIds: Set<import("..").GridRowId>;
            necessaryMatchedIds: Set<import("..").GridRowId>;
        } | {
            matchedIds: null;
            necessaryMatchedIds: null;
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => {
            matchedIds: Set<import("..").GridRowId>;
            necessaryMatchedIds: Set<import("..").GridRowId>;
        } | {
            matchedIds: null;
            necessaryMatchedIds: null;
        };
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => ((row: unknown) => boolean) | undefined, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("../data-tools/types").Collection];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectFilterMatchesShowOnly: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => Set<import("..").GridRowId> | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: "default" | "highlight", resultFuncArgs_1: {
            matchedIds: Set<import("..").GridRowId>;
            necessaryMatchedIds: Set<import("..").GridRowId>;
        } | {
            matchedIds: null;
            necessaryMatchedIds: null;
        }) => Set<import("..").GridRowId> | null;
        memoizedResultFunc: ((resultFuncArgs_0: "default" | "highlight", resultFuncArgs_1: {
            matchedIds: Set<import("..").GridRowId>;
            necessaryMatchedIds: Set<import("..").GridRowId>;
        } | {
            matchedIds: null;
            necessaryMatchedIds: null;
        }) => Set<import("..").GridRowId> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Set<import("..").GridRowId> | null;
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => "default" | "highlight", ((state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => {
            matchedIds: Set<import("..").GridRowId>;
            necessaryMatchedIds: Set<import("..").GridRowId>;
        } | {
            matchedIds: null;
            necessaryMatchedIds: null;
        }) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
                matchedIds: Set<import("..").GridRowId>;
                necessaryMatchedIds: Set<import("..").GridRowId>;
            } | {
                matchedIds: null;
                necessaryMatchedIds: null;
            };
            memoizedResultFunc: ((resultFuncArgs_0: ((row: unknown) => boolean) | undefined, resultFuncArgs_1: import("../data-tools/types").Collection) => {
                matchedIds: Set<import("..").GridRowId>;
                necessaryMatchedIds: Set<import("..").GridRowId>;
            } | {
                matchedIds: null;
                necessaryMatchedIds: null;
            }) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => {
                matchedIds: Set<import("..").GridRowId>;
                necessaryMatchedIds: Set<import("..").GridRowId>;
            } | {
                matchedIds: null;
                necessaryMatchedIds: null;
            };
            dependencies: [(state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => ((row: unknown) => boolean) | undefined, (state: {
                columns: columnSelectors.GridColumnState;
                currentEdit: editSelectors.GridEditState;
                currentFocus: focusSelectors.GridFocusState;
                drag: dragSelectors.GridDragState;
                filter: filterSelectors.GridFilterState;
                navigation: {
                    enabled: boolean;
                };
                rows: rowSelectors.GridRowState;
                selection: selectionSelectors.GridSelectionState;
                rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
                sort: sortSelectors.GridSortState;
                view: viewSelectors.GridViewState;
            }) => import("../data-tools/types").Collection];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("reselect").weakMapMemoize;
            argsMemoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectSortFn: ((state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: "internal" | "external", resultFuncArgs_1: import("..").GridColumnSort[], resultFuncArgs_2: string, resultFuncArgs_3: import("./types").ColumnSortInfo) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null;
        memoizedResultFunc: ((resultFuncArgs_0: "internal" | "external", resultFuncArgs_1: import("..").GridColumnSort[], resultFuncArgs_2: string, resultFuncArgs_3: import("./types").ColumnSortInfo) => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ((rowIds: import("..").GridRowId[], entities: Map<import("..").GridRowId, any>, meta: Map<import("..").GridRowId, import("..").GridRowMeta>) => import("..").GridRowId[]) | null;
        dependencies: [(state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => "internal" | "external", (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("..").GridColumnSort[], (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => string, (state: {
            columns: columnSelectors.GridColumnState;
            currentEdit: editSelectors.GridEditState;
            currentFocus: focusSelectors.GridFocusState;
            drag: dragSelectors.GridDragState;
            filter: filterSelectors.GridFilterState;
            navigation: {
                enabled: boolean;
            };
            rows: rowSelectors.GridRowState;
            selection: selectionSelectors.GridSelectionState;
            rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
            sort: sortSelectors.GridSortState;
            view: viewSelectors.GridViewState;
        }) => import("./types").ColumnSortInfo];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("reselect").weakMapMemoize;
        argsMemoize: typeof import("reselect").weakMapMemoize;
    };
    selectAllExpandable: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => Set<import("..").GridRowId>;
    selectExpandedState: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => "none" | "some" | "all";
    selectAllDescendantsForIds: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }, rowIds: import("..").GridRowId[]) => Set<import("..").GridRowId>;
    selectAllExpandableDescendants: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }, rowId: import("..").GridRowId) => Set<import("..").GridRowId>;
    selectGridSupportsEdit: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => boolean;
    selectStickyColumnDetails: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => import("./types").StickyColumnDetails;
    selectColumnIdsWithoutInternal: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => string[];
    selectColumnPreferences: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => import("./types").ColumnPreference[];
    selectColumnIds: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => string[];
    selectColumnWidths: (state: {
        columns: columnSelectors.GridColumnState;
        currentEdit: editSelectors.GridEditState;
        currentFocus: focusSelectors.GridFocusState;
        drag: dragSelectors.GridDragState;
        filter: filterSelectors.GridFilterState;
        navigation: {
            enabled: boolean;
        };
        rows: rowSelectors.GridRowState;
        selection: selectionSelectors.GridSelectionState;
        rangeSelection: rangeSelectionSelectors.GridRangeSelectionState;
        sort: sortSelectors.GridSortState;
        view: viewSelectors.GridViewState;
    }) => number[];
    selectFilterMode: (state: filterSelectors.GridFilterState) => "default" | "highlight";
    selectFilterFn: (state: filterSelectors.GridFilterState) => ((row: unknown) => boolean) | undefined;
    selectLoading: (state: viewSelectors.GridViewState) => number | boolean;
    selectNumberOfRowsInView: (state: viewSelectors.GridViewState) => number;
    selectRowHeight: (state: viewSelectors.GridViewState) => number;
    selectActionsMenuEnabled: (state: viewSelectors.GridViewState) => boolean;
    selectActionsMenuDetails: (state: viewSelectors.GridViewState) => {
        visible: false;
        rowId: null;
        coordinates: null;
    } | {
        visible: true;
        rowId: string | number;
        coordinates: {
            top: number;
            left: number;
        };
    };
    selectAggregationEnabled: (state: viewSelectors.GridViewState) => boolean;
    selectColumnMenuDetails: (state: viewSelectors.GridViewState) => {
        visible: false;
        coordinates: null;
    } | {
        visible: true;
        coordinates: {
            top: number;
            left: number;
        };
    };
    selectColumnMenuEnabled: (state: viewSelectors.GridViewState) => boolean;
    selectEdit: (state: editSelectors.GridEditState) => editSelectors.GridEditState;
    selectIsEditing: (state: editSelectors.GridEditState) => state is {
        columnId: string;
        rowId: import("..").GridRowId;
    };
    selectIsEditingCell: (state: editSelectors.GridEditState, { rowId, columnId }: {
        rowId: import("..").GridRowId;
        columnId: string;
    }) => boolean;
    selectIsEditingCellInColumn: (state: editSelectors.GridEditState, columnId: string) => boolean;
    selectNavigationEnabled: (state: {
        enabled: boolean;
    }) => boolean;
    selectRow: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => any;
    selectRowMeta: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => import("..").GridRowMeta;
    selectRowCollection: (state: rowSelectors.GridRowState) => import("../data-tools/types").Collection;
    selectRowLevel: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => number;
    selectRowLevelMap: (state: rowSelectors.GridRowState) => Map<import("..").GridRowId, number> | undefined;
    selectIsRowExpandable: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectIsRowLoaded: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectAreExpandedRowsControlled: (state: rowSelectors.GridRowState) => boolean;
    selectExpandedRows: (state: rowSelectors.GridRowState) => Set<import("..").GridRowId>;
    selectIsRowExpanded: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectRowsExpanded: (state: rowSelectors.GridRowState) => Set<import("..").GridRowId>;
    selectCanDragRow: (state: rowSelectors.GridRowState, rowId: import("..").GridRowId) => boolean;
    selectSortMode: (state: sortSelectors.GridSortState) => "internal" | "external";
    selectSortLocale: (state: sortSelectors.GridSortState) => string;
    selectSortColumns: (state: sortSelectors.GridSortState) => import("..").GridColumnSort[];
    selectColumnSort: (state: sortSelectors.GridSortState, columnId: string) => import("..").GridColumnSort | undefined;
    selectSort: (state: sortSelectors.GridSortState) => import("..").GridColumnSort[];
    selectDefaultSort: (state: sortSelectors.GridSortState) => import("..").GridColumnSort[] | undefined;
    selectIsMultiColumnSortingEnabled: (state: sortSelectors.GridSortState) => boolean;
    selectIsMultiColumnSorting: (state: sortSelectors.GridSortState) => boolean;
    selectColumnSortNumber: (state: sortSelectors.GridSortState, columnId: string) => number;
    selectRangeSelection: (state: rangeSelectionSelectors.GridRangeSelectionState) => import("..").GridRangeSelection | null;
    selectRangeSelectionPreview: (state: rangeSelectionSelectors.GridRangeSelectionState) => import("..").GridRangeSelection | null;
    selectIsSpreadsheet: (state: rangeSelectionSelectors.GridRangeSelectionState) => boolean;
    selectIsRangeSelectionControlled: (state: rangeSelectionSelectors.GridRangeSelectionState) => boolean;
    selectSelection: (state: selectionSelectors.GridSelectionState) => Set<import("..").GridRowId>;
    selectSelectionMode: (state: selectionSelectors.GridSelectionState) => "single" | "multi" | "none";
    selectSelectionAnchor: (state: selectionSelectors.GridSelectionState) => import("..").GridRowId | null;
    selectDragNeedsFinalRowOffset: (state: dragSelectors.GridDragState) => boolean;
    selectDragIsActive: (state: dragSelectors.GridDragState) => boolean;
    selectDragMoveReceived: (state: dragSelectors.GridDragState) => boolean;
    selectIsRowDragging: (state: dragSelectors.GridDragState, rowId: import("..").GridRowId) => boolean;
    selectDropIsAllowed: (state: dragSelectors.GridDragState) => boolean;
    selectDragMessage: (state: dragSelectors.GridDragState) => string;
    selectDragCollisionDetails: (state: dragSelectors.GridDragState) => import("../functional/grid-drag-controller/collision").CollisionDetails;
    selectDraggingRowIds: (state: dragSelectors.GridDragState) => Set<import("..").GridRowId>;
    selectRecentlyDroppedRowIds: (state: dragSelectors.GridDragState) => Set<import("..").GridRowId>;
    selectIsDraggingEnabled: (state: dragSelectors.GridDragState) => boolean;
    selectCanDragMultiple: (state: dragSelectors.GridDragState) => boolean;
    selectCanConvertLeaf: (state: dragSelectors.GridDragState) => boolean;
    selectDragMode: (state: dragSelectors.GridDragState) => import("..").GridRowDragMode;
    selectDropPredicate: (state: dragSelectors.GridDragState) => (info: import("..").GridRowDropInfo<any, any>) => import("..").GridDragResponse;
    selectConfiguredPreviewColumnId: (state: dragSelectors.GridDragState) => string | null;
    selectRawCurrentFocus: (state: focusSelectors.GridFocusState) => {
        columnId: string;
        rowId: import("..").GridRowId;
        area: focusSelectors.GridFocusArea;
        subFocus: number | "first" | "last";
    };
    selectSubFocus: (state: focusSelectors.GridFocusState) => number | "first" | "last";
    selectCanLoopHorizontally: (state: focusSelectors.GridFocusState) => boolean | undefined;
    selectTreeIndentSize: (state: columnSelectors.GridColumnState) => import("..").GridTreeIndentSize;
    selectAreHeadersHidden: (state: columnSelectors.GridColumnState) => boolean;
    selectColumn: (state: columnSelectors.GridColumnState, columnId: string) => import("./types").ColumnState;
    selectColumnSortEntities: (state: columnSelectors.GridColumnState) => import("./types").ColumnSortInfo;
    selectColumnPreference: (state: columnSelectors.GridColumnState, columnId: string) => import("./types").ColumnPreference;
    selectColumnCount: (state: columnSelectors.GridColumnState) => number;
    selectUnsortedColumnIds: (state: columnSelectors.GridColumnState) => string[];
    selectColumnIdsWithHidden: (state: columnSelectors.GridColumnState) => string[];
    selectHiddenIds: (state: columnSelectors.GridColumnState) => string[];
    selectGroupIds: (state: columnSelectors.GridColumnState) => string[];
    selectHeaderHierarchy: (state: columnSelectors.GridColumnState) => import("./types").HeaderHierarchy;
    selectHeaderHeight: (state: columnSelectors.GridColumnState) => number;
    selectIsTreeGrid: (state: columnSelectors.GridColumnState) => boolean;
    selectColumnStickyOffset: (state: columnSelectors.GridColumnState, columnId: string) => number;
    selectColumnGroupStickyOffset: (state: columnSelectors.GridColumnState, columnId: string) => number;
    selectTotalColumnWidth: (state: columnSelectors.GridColumnState) => number;
    selectAggregationConfigurations: (state: columnSelectors.GridColumnState) => import("./types").ColumnAggregationMapType[];
    selectColumnEntities: (state: columnSelectors.GridColumnState) => Record<string, import("./types").ColumnState>;
};
export type StoreSimpleSelectors = typeof selectors;
export type StoreSelectors = ReturnType<typeof createSelectors>;
export {};
//# sourceMappingURL=selectors.d.ts.map