import { CloneFn } from '../utils/types.js';
import { TreeCellMapI, TreeNode, TreeNodeMetadata, TreeServiceI } from './types.js';
declare type TreeCellMapCache = {
    [key: string]: TreeCellMapI;
};
declare type TreeNodeMetadataCache = {
    [key: string]: TreeNodeMetadata;
};
declare type FillMapState = {
    parentRowIndex: number;
    parentColIndex: number;
    prevChildren: number;
    parentKey: string;
};
/**
 * AbstractTreeService required as parent class to solve circular dependencies
 * TreeService converts tree structure into grid structure, also it keeps inner grid structure
 * to update cache system (via setCellCache) and receive merged cells (via updateMainCellMargins)
 */
export declare class AbstractTreeService implements TreeServiceI {
    tree?: TreeNode;
    hasGrandTotals: boolean;
    /**
     * Defines if tree will be converted to vertical or horizontal grid
     *
     *
     * @private
     */
    isVertical: boolean;
    deep?: number;
    /**
     * Cache tree nodes by deep levels
     *
     *
     * @private
     */
    columns: Array<Array<TreeNode>>;
    /**
     * Cache last levels tree nodes
     *
     *
     * @private
     */
    lastLevel: Array<any>;
    /**
     * Mapping object between tree<>grid
     *
     *
     * @private
     */
    map: TreeCellMapCache;
    /**
     * Metadata cache object
     *
     *
     * @private
     */
    metadataCache: TreeNodeMetadataCache;
    /**
     * Keep value node if it only one
     *
     *
     * @private
     */
    valueNode?: TreeNode;
    /**
     * Final 2D array
     *
     *
     * @private
     */
    grid?: Array<Array<any>>;
    constructor(tree?: TreeNode, isVertical?: boolean, deep?: number);
    destroy(): void;
    getMainCellWidth(rowIndex: number, columnIndex: number, columnWidth: Function, borderWidth: number, options?: {
        offsetTop?: number;
        columnsOffset?: number;
    }): number;
    /**
     * Adds additional tree node to current state
     *
     * @param {TreeNode} tree - new treeNode
     * @returns {void}
     */
    extend(tree?: TreeNode): void;
    /**
     * Returns grid (2d list) of tree structure
     *
     * @returns {Array<Array<TreeNode | string>>} - 2d list
     */
    getGrid(): Array<Array<TreeNode | string>>;
    /**
     * Returns part of current grid according to "from" - "to" position
     *
     * @param {number} from - start rows index for partial grid
     * @param {number} to - stop rows index for partial grid
     * @returns {Array<Array<TreeNode | string>>} - partial grid
     */
    getPartialGrid(from: number, to: number): Array<Array<TreeNode | string>>;
    /**
     * Returns part of current tree with possible cut nodes according to "from" - "to" position
     *
     * @param {number} from - start rows index for partial grid
     * @param {number} [to] - stop rows index for partial grid
     * @param {object} [options] - additional options
     * @param {Function} [options.cloneFn] - replace default clone function with specific one
     * @returns {Array<TreeNode>} - partial tree
     */
    getPartialTree(from: number, to?: number, options?: {
        cloneFn?: CloneFn;
    }): Array<TreeNode>;
    /**
     * Returns TreeNode item if exist for appropriate coordinates (rowIndex, columnIndex)
     *
     * @param {number} rowIndex - row index
     * @param {number} columnIndex - column index
     * @returns {TreeNode|undefined} - TreeNode item
     */
    getTreeNode(rowIndex: number, columnIndex: number): TreeNode | undefined;
    /**
     * Defines if cell with (rowIndex, columnIndex) coordinate is children cell or main one
     *
     * @param {number} rowIndex - row index of the cell
     * @param {number} columnIndex - column index of the cell
     * @returns {boolean} - true - if children, false if main one
     */
    isChildren(rowIndex: number, columnIndex: number): boolean;
    /**
     * Defines if cell with (rowIndex, columnIndex) coordinate has children column/row cells or not
     *
     * @param {number} rowIndex - row index of the cell
     * @param {number} columnIndex - column index of the cell
     * @returns {boolean} - true - has children column/row cells, false - does not have
     */
    hasChildren(rowIndex: number, columnIndex: number): boolean;
    /**
     * Updates merge object for the cell if it has children cells
     *
     * @param {number} rowIndex - cell row index
     * @param {number} columnIndex - cell column index
     * @returns {object} - new merge object
     */
    getMainCellSpans(rowIndex: number, columnIndex: number): {
        colSpan?: number;
        rowSpan?: number;
    };
    /**
     * Align start index in case of long merged cell
     *
     * @param {number} startIndex - initial start index
     * @param {boolean} isVertical - defines if it is vertical grid or not
     * @returns {number} - new start index
     */
    alignStartIndex(startIndex: number, isVertical?: boolean): number;
    /**
     * Align stop index in case of long merged cell
     *
     * @param {number} stopIndex - initial stop index
     * @param {boolean} isVertical - defines if it is vertical grid or not
     * @returns {number} - new stop index
     */
    alignStopIndex(stopIndex: number, isVertical?: boolean): number;
    /**
     * Returns number of last children for the tree
     *
     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
     * @param {{ callCount: number, clearCache: boolean }} options - options for state
     * @returns {number} - count of last children
     */
    getTreeChildLength(item?: TreeNode[] | TreeNode | undefined, options?: {
        callCount?: number;
        clearCache?: boolean;
    }): number;
    /**
     * Returns deep level of the tree
     *
     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
     * @param {{ callCount: number, clearCache: boolean }} options - options for inner state
     * @returns {number} - count of last children
     */
    getTreeDeepsLength(item?: TreeNode[] | TreeNode | undefined, options?: {
        callCount?: number;
        clearCache?: boolean;
    }): number;
    /**
     * Returns array of last tree nodes
     *
     * @returns {Array<TreeNode>} - list of tree nodes
     */
    getLastLevelNodes(): Array<TreeNode>;
    /**
     * Extract 2D array of data base on columnsTreeService
     *
     * @param {TreeServiceI} columnsTreeService - tree service according to which align the data
     * @returns {Array<Array<any>>} - 2D array of data
     */
    extractData(columnsTreeService?: TreeServiceI): Array<Array<any>>;
    /**
     * Returns cell meta information
     *
     * @param {number} rowIndex - cell row index
     * @param {number} columnIndex - cell column index
     * @param {{ to: number }} [options] - additional configuration options
     * @returns {{levels: Array<string>, siblings: Array<string>}} - meta information
     */
    getMetadata(rowIndex: number, columnIndex: number, options?: {
        from: number;
        to: number;
    }): TreeNodeMetadata | undefined;
    /**
     * Sets value node when it's single
     *
     * @param {TreeNode} valueNode - values measure node
     * @returns {void}
     */
    setValueNode(valueNode: TreeNode): void;
    /**
     * Fills cache object with nodes by appropriate deep level
     *
     * @param {Array<TreeNode>} list - list of nodes to cache
     * @param {Array<Array<TreeNode>>} cache - cache object
     * @param {{level: number }} options - internal recursive state
     * @returns {Array<Array<TreeNode>>} - cache object
     *
     * @private
     */
    cacheLevels(list: Array<TreeNode>, cache?: Array<Array<TreeNode>>, options?: {
        level: number;
    }): TreeNode[][];
    /**
     * Fill horizontal grid map according to tree structure
     *
     * @param {Array<TreeNode>} children - list of tree nodes
     * @param {number} rows - deep level rows
     * @param {object} map - map object to fill
     * @param {{parentColIndex: number, prevChildren: number}} initState - state object for
     * recursive calls
     * @returns {object} - map object
     *
     * @private
     */
    fillMap(children: Array<TreeNode>, rows: number, map?: TreeCellMapCache, initState?: FillMapState): TreeCellMapCache;
    /**
     * Fill vertical grid map according to tree structure
     *
     * @param {Array<TreeNode>} children - list of tree nodes
     * @param {number} cols - deep level columns
     * @param {TreeCellMapCache} map - map object to fill
     * @param {FillMapState} initState - state object for
     * recursive calls
     * @returns {object} - map object
     *
     * @private
     */
    fillMapVertical(children: Array<TreeNode>, cols: number, map?: TreeCellMapCache, initState?: FillMapState): TreeCellMapCache;
    /**
     * Fill child items in map according to main cell merged row and col
     *
     * @param {object} map - map object to fill
     * @param {string} mainKey - main cell key in map
     * @param {number} rowStart - main cell row index
     * @param {number} colStart - main cell column index
     * @param {number} row - merged rows count
     * @param {number} col - merged columns count
     * @returns {void}
     *
     * @private
     */
    fillChildMap(map: TreeCellMapCache, mainKey: string, rowStart: number, colStart: number, row: number, col: number): void;
    /**
     * Creates TreeCellMap instance
     *
     * @param {object} options - instance options
     * @param {number} options.rowIndex - row index of cell map instance
     * @param {number} options.colIndex - row index of cell map instance
     * @param {TreeNode} [options.node] - TreeNode for main cell
     * @param {string} [options.parent] - parent key for child item
     * @returns {TreeCellMap} - TreeCellMap instance
     *
     * @private
     */
    createTreeCellMap({ rowIndex, colIndex, node, parent, }: {
        rowIndex: number;
        colIndex: number;
        node?: TreeNode;
        parent?: string;
    }): TreeCellMapI;
    /**
     * Returns TreeCellMapI item by key string
     *
     * @param {string} key - map key string
     * @returns {TreeCellMapI|undefined} - TreeCellMapI instance or undefined
     *
     * @private
     */
    getItemByKey(key: string): TreeCellMapI | undefined;
    /**
     * Returns TreeCellMapI item by (row, col) coordinate
     *
     * @param {number} row - cell row index
     * @param {number} col - cell column index
     * @returns {TreeCellMapI|undefined} - TreeCellMapI instance or undefined
     *
     * @private
     */
    getItem(row: number, col: number): TreeCellMapI | undefined;
}
export default AbstractTreeService;