import { DiagramOptions } from './diagram.js';
import { FindOptions, FindOptionsTyped } from './find.js';
import { IndexPath } from './indexPath.js';
import { InsertOptions, InsertWithPathTrackingOptions } from './insert.js';
import { FlatMapOptions, MapOptions } from './map.js';
import { MoveOptions } from './move.js';
import { BaseOptions, MutationBaseOptions, TraversalContext } from './options.js';
import { ReduceOptions } from './reduce.js';
import { RemoveOptions, RemoveWithPathTrackingOptions } from './remove.js';
import { ReplaceOptions } from './replace.js';
import { SpliceOptions, SpliceWithPathTrackingOptions } from './splice.js';
import { OptionCheck, Prettify } from './types.js';
import { VisitOptions } from './visit.js';
type WithoutBase<T> = Omit<T, keyof BaseOptions<T>>;
type MutationOptions<T> = WithoutBase<MutationBaseOptions<T>>;
type DiagramOptionsWB<T> = WithoutBase<DiagramOptions<T>>;
type DiagramRequiredOptions<T> = {
    getLabel: DiagramOptionsWB<T>['getLabel'];
};
type DiagramOptionalOptions<T> = Omit<DiagramOptionsWB<T>, keyof DiagramRequiredOptions<T>>;
type FindOptionsWB<T> = WithoutBase<FindOptions<T>>;
type VisitOptionsWB<T> = WithoutBase<VisitOptions<T>>;
type InsertOptionsWB<T> = WithoutBase<InsertOptions<T>>;
type InsertWithPathTrackingOptionsWB<T> = WithoutBase<InsertWithPathTrackingOptions<T>>;
type RemoveOptionsWB<T> = WithoutBase<RemoveOptions<T>>;
type RemoveWithPathTrackingOptionsWB<T> = WithoutBase<RemoveWithPathTrackingOptions<T>>;
type MoveOptionsWB<T> = WithoutBase<MoveOptions<T>>;
type ReplaceOptionsWB<T> = WithoutBase<ReplaceOptions<T>>;
type SpliceOptionsWB<T> = WithoutBase<SpliceOptions<T>>;
type SpliceWithPathTrackingOptionsWB<T> = WithoutBase<SpliceWithPathTrackingOptions<T>>;
type ApplyableOptions<T> = DiagramRequiredOptions<T> & MutationOptions<T>;
interface Overloads<T> {
    /**
     * Find a node matching a predicate function.
     */
    find(node: T, predicate: FindOptions<T>['predicate']): T | undefined;
    find(node: T, options: FindOptionsWB<T>): T | undefined;
    find<S extends T>(node: T, predicate: FindOptionsTyped<T, S>['predicate']): S | undefined;
    find<S extends T>(node: T, options: WithoutBase<FindOptionsTyped<T, S>>): S | undefined;
    /**
     * Find all nodes matching a predicate function.
     */
    findAll(node: T, predicate: FindOptions<T>['predicate']): T[];
    findAll(node: T, options: FindOptionsWB<T>): T[];
    findAll<S extends T>(node: T, predicate: FindOptionsTyped<T, S>['predicate']): S[];
    findAll<S extends T>(node: T, options: WithoutBase<FindOptionsTyped<T, S>>): S[];
    /**
     * Find the `IndexPath` of a node matching a predicate function.
     */
    findPath(node: T, predicate: FindOptions<T>['predicate']): IndexPath | undefined;
    findPath(node: T, options: FindOptionsWB<T>): IndexPath | undefined;
    /**
     * Find the `IndexPath` of all nodes matching a predicate function.
     */
    findAllPaths(node: T, predicate: FindOptions<T>['predicate']): IndexPath[];
    findAllPaths(node: T, options: FindOptionsWB<T>): IndexPath[];
    /**
     * Visit each node using preorder DFS traversal.
     */
    visit(node: T, onEnter: NonNullable<VisitOptions<T>>['onEnter']): void;
    /**
     * Visit each node using DFS traversal.
     */
    visit(node: T, options: VisitOptionsWB<T>): void;
}
declare class Tree<T, AppliedOptions extends Partial<ApplyableOptions<T>>> {
    appliedOptions: AppliedOptions;
    constructor(getChildrenOrBaseOptions: BaseOptions<T> | BaseOptions<T>['getChildren'], appliedOptions: AppliedOptions);
    _getChildren: BaseOptions<T>['getChildren'];
    /**
     * Returns the node's children.
     *
     * This is the same as the `getChildren` option passed to `defineTree`, included here for convenience.
     */
    getChildren: (node: T, indexPath: IndexPath, context?: TraversalContext<T>) => T[];
    baseOptions: BaseOptions<T>;
    mergeOptions: <O extends Record<string, any>>(options: O) => BaseOptions<T> & AppliedOptions & O;
    withOptions: <NewOptions extends Partial<ApplyableOptions<T>>>(newOptions: NewOptions) => Tree<T, AppliedOptions & NewOptions>;
    /**
     * Returns a node by its `IndexPath`.
     *
     * The first node is implicitly included in the `IndexPath` (i.e. no need to pass a `0` first in every `IndexPath`).
     */
    access: (node: T, indexPath: IndexPath) => T;
    /**
     * Returns an array of each node in an `IndexPath`.
     *
     * The first node is implicitly included in the `IndexPath` (i.e. no need to pass a `0` first in every `IndexPath`).
     */
    accessPath: (node: T, indexPath: IndexPath) => T[];
    /**
     * Returns a node by its `IndexPath`.
     *
     * The first node is implicitly included in the `IndexPath` (i.e. no need to pass a `0` first in every `IndexPath`).
     */
    get: (node: T, indexPath: IndexPath) => T | undefined;
    /**
     * Returns the ancestors of a node.
     */
    ancestors: (node: T, indexPath: IndexPath) => T[];
    /**
     * Generate a diagram of the tree, as a string.
     */
    diagram: (node: T, options: DiagramRequiredOptions<T>["getLabel"] | Prettify<AppliedOptions extends DiagramRequiredOptions<T> ? DiagramOptionalOptions<T> | void : OptionCheck<AppliedOptions, "getLabel", DiagramRequiredOptions<T>> & DiagramOptionalOptions<T>>) => string;
    find: Overloads<T>['find'];
    findAll: Overloads<T>['findAll'];
    findPath: Overloads<T>['findPath'];
    findAllPaths: Overloads<T>['findAllPaths'];
    /**
     * Returns an array of every [IndexPath, Node] pair in the tree.
     */
    entries: (node: T) => [IndexPath, T][];
    /**
     * Returns an array containing the root node and all of its descendants.
     *
     * This is analogous to `Array.prototype.flat` for flattening arrays.
     */
    flat: (node: T) => T[];
    reduce: <R>(node: T, nextResult: ReduceOptions<T, R>["nextResult"], initialResult: R) => R;
    map: <R>(node: T, transform: MapOptions<T, R>["transform"]) => R;
    flatMap: <R>(node: T, transform: FlatMapOptions<T, R>["transform"]) => R;
    visit: Overloads<T>['visit'];
    /**
     * Insert nodes at a given `IndexPath`.
     */
    insert: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", InsertOptionsWB<T>> & Omit<InsertOptionsWB<T>, "create">>) => T;
    /**
     * Insert nodes at a given `IndexPath`.
     */
    insertWithPathTracking: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", InsertWithPathTrackingOptionsWB<T>> & Omit<InsertWithPathTrackingOptionsWB<T>, "create">>) => {
        node: T;
        paths: (IndexPath | undefined)[];
    };
    /**
     * Remove nodes at the given `IndexPath`s.
     */
    remove: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", RemoveOptionsWB<T>> & Omit<RemoveOptionsWB<T>, "create">>) => T;
    /**
     * Remove nodes at the given `IndexPath`s.
     */
    removeWithPathTracking: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", RemoveWithPathTrackingOptionsWB<T>> & Omit<RemoveWithPathTrackingOptionsWB<T>, "create">>) => {
        node: T;
        paths: (IndexPath | undefined)[];
    };
    /**
     * Move nodes from one `IndexPath` to another.
     */
    move: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", MoveOptionsWB<T>> & Omit<MoveOptionsWB<T>, "create">>) => T;
    /**
     * Replace nodes at the given `IndexPath`s with another node.
     */
    splice: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", SpliceOptionsWB<T>> & Omit<SpliceOptionsWB<T>, "create">>) => T;
    /**
     * Replace nodes at the given `IndexPath`s with another node.
     */
    spliceWithPathTracking: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", SpliceWithPathTrackingOptionsWB<T>> & Omit<SpliceWithPathTrackingOptionsWB<T>, "create">>) => {
        node: T;
        paths: (IndexPath | undefined)[];
    };
    /**
     * Replace the node at the given `IndexPath` with another
     */
    replace: (node: T, options: Prettify<OptionCheck<AppliedOptions, "create", ReplaceOptionsWB<T>> & Omit<ReplaceOptionsWB<T>, "create">>) => T;
}
export declare function defineTree<T>(getChildren: BaseOptions<T> | BaseOptions<T>['getChildren']): Tree<T, {}>;
export {};