import { ComponentsAndVariants } from '../../../types';
import { ColumnFilters, DataGridProps, FilterValue, Key, PaginationState, PinPosition } from '../contracts/dataGridContract';
import { default as ColumnModel } from './columnModel';
import { default as ColumnVisibilityModel } from './columnVisibilityModel';
import { default as DetailRowModel } from './detailRowModel';
import { default as FilterModel } from './filterModel';
import { default as GroupRowModel } from './groupRowModel';
import { default as PaginationModel } from './paginationModel';
import { default as RowModel } from './rowModel';
import { default as ViewportModel } from './viewportModel';
export declare const ROW_NUMBER_CELL_KEY: Key;
export declare const DEFAULT_ROW_NUMBER_COLUMN_WIDTH = 70;
export declare const ROW_SELECTION_CELL_KEY: Key;
export declare const GROUPING_CELL_KEY: Key;
export declare const ROW_DETAIL_CELL_KEY: Key;
export default class GridModel<TRow> {
    props: DataGridProps<TRow>;
    constructor(props: DataGridProps<TRow>, onChange?: () => void);
    private _version;
    private readonly listeners;
    /** Subscribe to changes; returns an unsubscribe function. */
    subscribe: (listener: () => void) => (() => void);
    /** Monotonic snapshot version — stable between changes, increments on notify(). */
    getSnapshot: () => number;
    /** Signal subscribers that state changed and a re-render is needed. */
    notify: () => void;
    /**
     * Sync incoming props. Called during render by the framework adapter — clears
     * the affected memos but does NOT notify (no extra render cycle; memos recompute
     * lazily on next access).
     */
    setProps(props: DataGridProps<TRow>): void;
    get componentName(): keyof ComponentsAndVariants;
    get resizerStyle(): 'visible' | 'hover' | 'hidden';
    readonly sourceColumns: import('../../../utils/memo').Memo<ColumnModel<TRow>[]>;
    readonly columns: import('../../../utils/memo').Memo<{
        left: ColumnModel<TRow>[];
        middle: ColumnModel<TRow>[];
        right: ColumnModel<TRow>[];
        flat: ColumnModel<TRow>[];
        leafs: ColumnModel<TRow>[];
        visibleLeafs: ColumnModel<TRow>[];
        userVisibleLeafs: ColumnModel<TRow>[];
        maxDeath: number;
    }>;
    readonly headerRows: import('../../../utils/memo').Memo<ColumnModel<TRow>[][]>;
    readonly gridTemplateColumns: import('../../../utils/memo').Memo<string>;
    private _globalFilterValue;
    get globalFilterValue(): string;
    private _columnFilters;
    get columnFilters(): ColumnFilters<TRow>;
    /**
     * Apply global filter (fuzzy search across all or specified columns)
     */
    private applyGlobalFilter;
    /**
     * Apply column-level filters
     */
    private applyColumnFilters;
    /**
     * Check if a cell value matches a filter
     */
    private matchesFilter;
    /**
     * Apply external predicate filters from the filters prop
     */
    private applyExternalFilters;
    /**
     * Get filtered data (applies external, global, then column filters)
     */
    get filteredData(): TRow[];
    private fireServerStateChange;
    /**
     * Set global filter value
     */
    setGlobalFilter: (value: string) => void;
    /**
     * Set a single column filter
     */
    setColumnFilter: (columnKey: Key, filter: FilterValue | undefined) => void;
    /**
     * Clear all column filters
     */
    clearColumnFilters: () => void;
    /**
     * Clear all filters (global + column)
     */
    clearAllFilters: () => void;
    /**
     * Get unique values for a column (used for multiselect filter options)
     */
    getColumnUniqueValues: (columnKey: Key) => (string | number | boolean | null)[];
    /**
     * Check if any filter is active
     */
    get hasActiveFilters(): boolean;
    /**
     * Get count of filtered rows vs total rows
     */
    get filterStats(): {
        filtered: number;
        total: number;
    };
    readonly rows: import('../../../utils/memo').Memo<GroupRowModel<TRow>[] | RowModel<TRow>[]>;
    readonly flatRows: import('../../../utils/memo').Memo<(GroupRowModel<TRow> | RowModel<TRow> | DetailRowModel<TRow>)[]>;
    get rowHeight(): number;
    readonly sizes: import('../../../utils/memo').Memo<Record<string, string>>;
    private _containerWidth;
    get containerWidth(): number;
    setContainerWidth: (width: number) => void;
    readonly flexWidths: import('../../../utils/memo').Memo<Record<Key, number>>;
    getFlexWidth(key: Key): number | undefined;
    readonly DEFAULT_ROW_HEIGHT_PX = 48;
    readonly MIN_COLUMN_WIDTH_PX = 48;
    readonly DEFAULT_COLUMN_WIDTH_PX = 200;
    expandedGroupRow: Set<Key>;
    private _expandedDetailRows;
    get expandedDetailRows(): Set<Key>;
    toggleDetailRow: (rowKey: Key) => void;
    private _page;
    private _pageSize?;
    get page(): number;
    get pageSize(): number;
    get pageSizeOptions(): number[] | undefined;
    get isPaginated(): boolean;
    get paginationState(): PaginationState | undefined;
    changePage: (page: number) => void;
    changePageSize: (size: number) => void;
    readonly rowOffsets: import('../../../utils/memo').Memo<{
        offsets: number[];
        totalHeight: number;
    }>;
    /** Headless virtualization (windowing math; scrollTop is owned by the adapter). */
    readonly viewport: ViewportModel<TRow>;
    /** Backs the top-bar column-visibility menu. */
    readonly columnVisibility: ColumnVisibilityModel<TRow>;
    /** Filtering concern (grid-level state + derived flags). */
    readonly filter: FilterModel<TRow>;
    /** Pagination concern (navigation + row-range derivations). */
    readonly pagination: PaginationModel<TRow>;
    /** Whether any user-facing column is currently visible (else the empty-columns state shows). */
    get hasVisibleColumns(): boolean;
    get isEmpty(): boolean;
    /** Header select-all checkbox state. */
    get allRowsSelected(): boolean;
    get someRowsSelected(): boolean;
    /** The columns currently grouped, resolved from groupColumns keys (backs the top-bar group chips). */
    get groupedColumns(): ColumnModel<TRow>[];
    selectedRows: Set<Key>;
    get leftEdge(): number;
    get rightEdge(): number;
    readonly leftEdgeVarName = "--left-edge";
    readonly rowHeightVarName = "--row-height";
    readonly viewportWidthVarName = "--viewport-width";
    private readonly _idMap;
    private _autoId;
    private readonly _idFactory;
    getRowKey(row: TRow): Key;
    setSortColumn: (columnKey: Key, sortDirection?: SortDirection) => void;
    pinColumn: (uniqueKey: string, pin?: PinPosition) => void;
    toggleGrouping: (columnKey: Key) => void;
    unGroupAll: () => void;
    toggleGroupRow: (groupRowKey: Key) => void;
    toggleRowSelection: (rowKey: Key) => void;
    toggleRowsSelection: (rowKeys: Key[]) => void;
    toggleSelectAllRows: () => void;
    toggleColumnVisibility: (columnKey: Key) => void;
    setWidth: (columnKey: Key, width: number) => void;
    groupColumns: Set<Key>;
    hiddenColumns: Set<Key>;
    columnWidths: Map<Key, number>;
    private _sortColumn?;
    get sortColumn(): Key | undefined;
    private _sortDirection?;
    get sortDirection(): SortDirection | undefined;
}