import { CloneFn } from '../../utils/types.js';
import { TreeNode } from '../types.js';
export declare const ROOT = "$*$root$*$";
export declare function create(value?: string, children?: Array<TreeNode>, data?: Array<any>, index?: number): TreeNode;
/**
 * Defines if node has child nodes or not
 *
 * @param {TreeNode} node - tree node object
 * @returns {boolean} - true - has children, false - last child
 */
export declare function hasChildren(node?: TreeNode): boolean;
/**
 * Returns list of child nodes
 *
 * @param {TreeNode} node - tree node object
 * @returns {Array<TreeNode>|Array} - list of child nodes or empty array
 */
export declare function getChildren(node?: TreeNode): Array<TreeNode>;
/**
 * Set new list of child nodes
 *
 * @param {TreeNode} node - tree node object
 * @param {Array<TreeNode>} list - new list of child nodes
 * @returns {void}
 */
export declare function setChildren(node?: TreeNode, list?: Array<TreeNode>): void;
/**
 * Set node deep level in tree hierarchy
 *
 * @param {TreeNode} node - tree node object
 * @param {number} level - hierarchy level
 * @returns {void}
 */
export declare function setLevel(node: TreeNode | undefined, level: number): void;
/**
 * Returns node deep level in tree hierarchy
 *
 * @param {TreeNode} node - tree node object
 * @returns {number} hierarchy level
 */
export declare function getLevel(node?: TreeNode): number;
export declare function wrapInRootNode(data?: TreeNode | Array<TreeNode>): TreeNode | undefined;
declare function findNode(rootNode?: TreeNode, checkCb?: Function, level?: number): TreeNode | undefined;
/**
 * Merge two root trees into one
 *
 * @param {TreeNode} [firstNode] - first tree
 * @param {TreeNode} [secondNode] - second tree
 * @returns {TreeNode} - merged tree
 */
export declare function merge(firstNode?: TreeNode, secondNode?: TreeNode): TreeNode | undefined;
/**
 * Merging two partial pivot trees into one (mutate first argument).
 *
 * @param {TreeNode} targetTree - main part of pivot table model (looks like 'tree' data structure)
 * @param {TreeNode} sourceTree - part of pivot table model (looks like 'tree' data structure) which
 *  we want merge in main part
 * @returns {TreeNode} - merged tree
 */
export declare function deepMerge(targetTree?: TreeNode, sourceTree?: TreeNode): TreeNode | undefined;
export declare function iterateThroughTree(nodes?: Array<TreeNode>, callback?: (item: Record<string, any>, parent?: Record<string, any>) => void, parent?: Record<string, any>): void;
export declare function getLastLevelNodes(nodes: Array<TreeNode>, lastLevelNodes?: Array<TreeNode>, level?: number, options?: {
    maxLevel: number;
}): Array<TreeNode>;
/**
 * Returns number of last children for the tree
 *
 * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
 * @param {object} options - additional options
 * @param {number} options.callCount - inner state for recursive calls count
 * @param {boolean} options.clearCache - define if use cached value or recalculate new one
 * @returns {number} - count of last children
 */
export declare function getChildLength(item?: TreeNode[] | TreeNode, options?: {
    callCount?: number;
    clearCache?: boolean;
}): number;
/**
 * Returns deep level of the tree
 *
 * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
 * @param {object} options - additional options
 * @param {number} options.callCount - inner state for recursive calls count
 * @param {boolean} options.clearCache - define if use cached value or recalculate new one
 * @returns {number} - count of last children
 */
export declare function getDeepLength(item?: TreeNode[] | TreeNode, options?: {
    callCount?: number;
    clearCache?: boolean;
}): number;
/**
 * Returns part of tree nodes list according to children indexes "from" - "to"
 * return result is not strict, and start/stop in returns object show returned node position
 *
 * @param {Array<TreeNode>} rootNodes - list of nodes
 * @param {number} [from=0] - start index to for partial tree
 * @param {number} [to] - end index for partial tree
 * @returns {{nodes: Array<TreeNode>, start: number, stop: number}} - partial tree nodes and
 * start/stop indexes of it in scope of initial list
 */
export declare function getNodesByChildCount(rootNodes?: Array<TreeNode>, from?: number, to?: number): {
    nodes: Array<TreeNode>;
    start: number;
    stop: number;
};
/**
 * Clear tree node internal cache
 *
 * @param {TreeNode} node - node to clear
 * @returns {void}
 */
export declare function clearNodeCache(node: TreeNode): void;
/**
 * Returns cut cloned part of tree nodes list according to children indexes "from" - "to"
 *
 * @param {Array<TreeNode>} rootNodes - list of nodes
 * @param {number} [from=0] - start index to for cut tree
 * @param {number} [to] - end index for cut tree
 * @param {object} [options] - additional options
 * @param {Array<string>} [options.cloneIncludeKeys] - clone node include keys
 * @param {Array<string>} [options.cloneExcludeKeys] - clone node exclude keys
 * @returns {Array<TreeNode>} - cut cloned list of nodes
 */
export declare function getCutNodesByChildCount(rootNodes?: Array<TreeNode>, from?: number, to?: number, options?: {
    cloneFn?: CloneFn;
}): Array<TreeNode>;
declare const _default: {
    ROOT: string;
    create: typeof create;
    hasChildren: typeof hasChildren;
    getChildren: typeof getChildren;
    setChildren: typeof setChildren;
    setLevel: typeof setLevel;
    getLevel: typeof getLevel;
    getLastLevelNodes: typeof getLastLevelNodes;
    iterateThroughTree: typeof iterateThroughTree;
    wrapInRootNode: typeof wrapInRootNode;
    findNode: typeof findNode;
    merge: typeof merge;
    deepMerge: typeof deepMerge;
    getChildLength: typeof getChildLength;
    getDeepLength: typeof getDeepLength;
    getNodesByChildCount: typeof getNodesByChildCount;
    getCutNodesByChildCount: typeof getCutNodesByChildCount;
    clearNodeCache: typeof clearNodeCache;
};
export default _default;