import type { HeaderNodeData } from './headersTree';
import type { NodeModificationResult } from './nodeModifiers';
import type { ColumnVisibility } from './columnVisibility';
import type TreeNode from '../../../utils/dataStructures/tree';
/**
 * The state manager is a source of truth for nested headers configuration.
 *
 * @class StateManager
 */
export default class StateManager {
    #private;
    /**
     * Sets a new state for the nested headers plugin based on settings passed
     * directly to the plugin.
     *
     * @param {Array[]} nestedHeadersSettings The user-defined settings.
     * @returns {boolean} Returns `true` if the settings are processed correctly, `false` otherwise.
     */
    setState(nestedHeadersSettings: unknown[][]): boolean;
    /**
     * Sets columns limit to the state will be trimmed.
     *
     * @param {number} columnsCount The number of columns to limit to.
     */
    setColumnsLimit(columnsCount: number): void;
    /**
     * Merges settings with current plugin state.
     *
     * @param {object[]} settings An array of objects to merge with the current source settings.
     */
    mergeStateWith(settings: {
        row: number;
        col: number;
        [key: string]: unknown;
    }[]): void;
    /**
     * Maps the current state with a callback.
     *
     * @param {Function} callback A function that is called for every header source settings.
     */
    mapState(callback: (headerSettings: Record<string, unknown>) => unknown): void;
    /**
     * Inserts `amount` columns into the source settings at the visual `columnIndex`, then rebuilds
     * the tree and re-derives visibility. Headers spanning the insertion point are extended; columns
     * inserted at a header boundary become standalone headers.
     *
     * @param {number} columnIndex A visual column index at which the new columns are inserted.
     * @param {number} amount The number of columns to insert.
     */
    insertColumns(columnIndex: number, amount: number): void;
    /**
     * Removes `amount` columns from the source settings starting at the visual `columnIndex`, then
     * rebuilds the tree and re-derives visibility. Headers overlapping the removed range are shrunk,
     * re-anchored, or dropped when they lose all their columns.
     *
     * @param {number} columnIndex A visual column index from which the columns are removed.
     * @param {number} amount The number of columns to remove.
     */
    removeColumns(columnIndex: number, amount: number): void;
    /**
     * Maps the current tree nodes with a callback.
     *
     * @param {Function} callback A function that is called for every tree node.
     * @returns {Array}
     */
    mapNodes(callback: Function): never[];
    /**
     * Triggers an action from the NodeModifiers module.
     *
     * @param {string} action An action name to trigger.
     * @param {number} headerLevel Header level index.
     * @param {number} columnIndex A visual column index.
     * @returns {object|undefined}
     */
    triggerNodeModification(action: string, headerLevel: number, columnIndex: number): NodeModificationResult | undefined;
    /**
     * Triggers an action from the NodeModifiers module starting from the lowest header.
     *
     * @param {string} action An action name to trigger.
     * @param {number} columnIndex A visual column index.
     * @returns {object|undefined}
     */
    triggerColumnModification(action: string, columnIndex: number): NodeModificationResult | undefined;
    /**
     * Derives tree-node visibility state (colspan, crossHiddenColumns, isHidden) from an external
     * ColumnVisibility port, then regenerates the state matrix. Call this whenever the hiding map
     * changes (HiddenColumns, CollapsibleColumns) or after column sequence changes.
     *
     * @param {ColumnVisibility} columnVisibility The visibility port.
     */
    syncVisibility(columnVisibility: ColumnVisibility): void;
    /**
     * @memberof StateManager#
     * @function rowCoordsToLevel
     *
     * Translates row coordinates into header level.
     *
     * @param {number} rowIndex A visual row index.
     * @returns {number|null} Returns unsigned number.
     */
    rowCoordsToLevel(rowIndex: number): number | null;
    /**
     * @memberof StateManager#
     * @function levelToRowCoords
     *
     * Translates header level into row coordinates.
     *
     * @param {number} headerLevel Header level index.
     * @returns {number} Returns negative number.
     */
    levelToRowCoords(headerLevel: number): number | null;
    /**
     * Gets column header settings for a specified column and header index.
     *
     * @param {number} headerLevel Header level.
     * @param {number} columnIndex A visual column index.
     * @returns {object|null}
     */
    getHeaderSettings(headerLevel: number, columnIndex: number): HeaderNodeData | null;
    /**
     * Gets tree data that is connected to the column header.
     *
     * @param {number} headerLevel Header level.
     * @param {number} columnIndex A visual column index.
     * @returns {object|null}
     */
    getHeaderTreeNodeData(headerLevel: number, columnIndex: number): {
        [key: string]: unknown;
        headerLevel: number;
        columnIndex: number;
        clonedTree?: TreeNode<HeaderNodeData> | null;
        label: string;
        colspan: number;
        origColspan: number;
        rowspan?: number;
        origRowspan?: number;
        collapsible: boolean;
        isCollapsed: boolean;
        crossHiddenColumns: number[];
        isHidden: boolean;
        isRoot: boolean;
        isPlaceholder: boolean;
        isRowspanPlaceholder?: boolean;
        headerClassNames: string[];
        visibleWhen?: import("./utils").HeaderVisibility;
    } | null;
    /**
     * Gets tree node that is connected to the column header.
     *
     * @param {number} headerLevel Header level.
     * @param {number} columnIndex A visual column index.
     * @returns {TreeNode|null}
     */
    getHeaderTreeNode(headerLevel: number, columnIndex: number): TreeNode | null;
    /**
     * Finds the most top header level of the column header.
     *
     * @param {number} columnIndexFrom A visual column index.
     * @param {number} [columnIndexTo] A visual column index.
     * @returns {number} Returns a header level in format -1 to -N.
     */
    findTopMostEntireHeaderLevel(columnIndexFrom: number, columnIndexTo?: number): number | null;
    /**
     * Finds the left-most column index where the nested header begins.
     *
     * @param {number} headerLevel Header level.
     * @param {number} columnIndex A visual column index.
     * @returns {number}
     */
    findLeftMostColumnIndex(headerLevel: number, columnIndex: number): number;
    /**
     * Finds the right-most column index where the nested header ends.
     *
     * @param {number} headerLevel Header level.
     * @param {number} columnIndex A visual column index.
     * @returns {number}
     */
    findRightMostColumnIndex(headerLevel: number, columnIndex: number): number;
    /**
     * Gets a total number of headers levels.
     *
     * @returns {number}
     */
    getLayersCount(): number;
    /**
     * Gets a total number of columns count.
     *
     * @returns {number}
     */
    getColumnsCount(): number;
    /**
     * Computes the visual column indexes that should be hidden purely by the `visibleWhen` rules of
     * declarative collapsible groups (issue #10243), given each group's current `isCollapsed` state.
     *
     * A group is "declarative" when at least one of its direct children declares an explicit
     * `visibleWhen` ('collapsed', 'expanded', or 'always'); legacy groups (no markers) are left to the
     * regular first-visible-child collapse path and are skipped here. Within a declarative group a child
     * with no marker defaults to `'expanded'` - it is hidden when the group collapses, matching the
     * default collapse behavior; `'always'` is the explicit opt-in for staying visible in both states.
     * Only `collapsible` groups are considered. At least one column per group always stays visible so the
     * group's collapse indicator survives. The result is a pure function of the tree shape, the markers,
     * and the `isCollapsed` flags, so it stays correct across tree rebuilds.
     *
     * @returns {number[]} Visual column indexes to hide.
     */
    getVisibleWhenHiddenColumns(): number[];
    /**
     * Clears the column state manager to the initial state.
     */
    clear(): void;
}