import { Seq } from '../Utils/IterableUtils';
export declare type Node<T> = T & {
    children: Array<Node<T>>;
};
export interface ChildrenGetter<T> {
    (t: T): T[];
}
/** top-down tree node iterator */
export declare function preorder<T>(root: T, getChildren: ChildrenGetter<T>): Iterable<T>;
/** bottom-up tree node iterator */
export declare function postorder<T>(root: T, getChildren: ChildrenGetter<T>): Iterable<T>;
/**
 * Create a Seq of tree nodes in preorder sequence.
 *
 *              1
 *             / \
 *            /   \
 *           /     \
 *          2       3
 *         / \     /
 *        4   5   6
 *       /       / \
 *      7       8   9
 *
 *     preorder:    1 2 4 7 5 3 6 8 9
 *
 * @param {Object} root
 * @return {Seq}
 */
export declare function preorderSeq<T>(root: Node<T>): Seq<Node<T>>;
/**
 * Create a Seq of tree nodes in postorder sequence.
 *
 *              1
 *             / \
 *            /   \
 *           /     \
 *          2       3
 *         / \     /
 *        4   5   6
 *       /       / \
 *      7       8   9
 *
 *     postorder:   7 4 5 2 8 9 6 3 1
 *
 * @param {Object} root
 * @return {Seq}
 */
export declare function postorderSeq<T>(root: Node<T>): Seq<Node<T>>;
/**
 * Convert a tree into a new tree-like structure. The tree is traversed bottom-
 * up, and for each node, its mapped children are passed to the mapping
 * function. This allows the mapping function to integrate the mapped children
 * however it needs to.
 *
 * @param {mapFn} mapFn Mapping function to apply to each node.
 * @param {Function} getChildren A function that returns an iterable object over a node's children.
 * @param {any} root The root node of the tree whose structure is being mapped.
 */
export declare function mapStructure<T, U>(mapFn: (node: T, mappedChildren: U[]) => U, getChildren: ChildrenGetter<T>, root: T): U;
/**
 * Convert a tree into a new structure, much like array.reduce. The tree is
 * traversed bottom-up.
 */
export declare const foldStructure: <T, U>(reducer: (value: U, node: Node<T>) => U, seed: U, root: Node<T>) => U;
/**
 * For any node in a tree that does not pass `nodePredicate`, replace it with
 * its children. A new tree will be returned.
 *
 * @param {Function} fn Predicate function to determine if a node
 * will be kept.
 * @param {Object} root Root node of a tree.
 * @return {Object}
 */
export declare function pruneDescendantNodes<T>(fn: (node: Node<T>) => boolean, root: Node<T>): Node<T>;
/**
 * Recursively replace any node that does not pass `nodePredicate` with its
 * children. A new array of nodes will be returned.
 *
 * @param {Function} fn Predicate function to determine if a node
 * will be kept.
 * @param {Array} nodes An array of nodes. This will typically be the children
 * of a node in a tree.
 * @return {Array}
 */
export declare function pruneNodes<T>(fn: (node: Node<T>) => boolean, nodes: Node<T>[]): Node<T>[];
/**
 * If the root node has only one child, replace the root node with it's child.
 *
 * @param {Object} root Root node of a tree
 * @return {Object} Tree
 */
export declare function compactRootNodes<T>(root: Node<T>): Node<T>;
export declare function mapNodes<T>(nodeTransform: (root: Node<T>) => Node<T>, root: Node<T>): Node<T>;
/**
 * Get an array of nodes that satisfy nodePredicate
 */
export declare function filterNodes<T>(nodePredicate: (node: Node<T>) => boolean, node: Node<T>): Node<T>[];
/**
 * Simple convenience method to identify nodes that are leaves
 * @param {Object} node representing root of subtree (possibly a leaf)
 * @return {Boolean} indicates true if the node is a leaf and false otherwise
 */
export declare function isLeaf<T>(node: T, getNodeChildren: ChildrenGetter<T>): boolean;
/**
 * Determine if a node is a branch
 * @param node
 * @param getNodeChildren
 */
export declare function isBranch<T>(node: T, getNodeChildren: ChildrenGetter<T>): boolean;
/**
 * Using recursion to return all the leaf nodes for the given node.
 * @param {Object} node representing root of subtree
 * @param {Array} initial list of leaf nodes (optional)
 * @return {Array} updated list of leaf nodes
 */
export declare function getLeaves<T>(node: T, getNodeChildren: ChildrenGetter<T>): T[];
/**
 * Using recursion to return all the branch nodes for a given node
 * @param {Object} node representing root of subtree
 * @param {Array} initial list of branch nodes (optional)
 * @return {Array} updated list of branch nodes
 */
export declare function getBranches<T>(node: T, getNodeChildren: ChildrenGetter<T>, branches?: T[]): T[];
//# sourceMappingURL=TreeUtils.d.ts.map