import { R as RowData, c as Table, f as Row, am as RowModel } from '../types-CwNe64f5.cjs';

interface TreeNode<TData extends RowData> {
    /** The path segments for this node */
    path: string[];
    /** The original data (may be synthetic for intermediate nodes) */
    data: TData;
    /** Child nodes */
    children: TreeNode<TData>[];
    /** Depth in the tree (0-based) */
    depth: number;
    /** Whether this node is a leaf (has no children) */
    isLeaf: boolean;
    /** Unique key derived from the full path */
    key: string;
}
interface TreeDataOptions<TData extends RowData> {
    /** Callback that returns the path array for a data item */
    getDataPath: (data: TData) => string[];
    /** Whether to auto-expand all nodes initially */
    autoExpandAll?: boolean;
    /** Maximum depth to auto-expand */
    autoExpandDepth?: number;
}
interface TreeRowModelOptions<TData extends RowData> {
    /** Filter a tree before flattening; ancestors of matching nodes are retained. */
    filterNode?: (node: TreeNode<TData>) => boolean;
    /** Sort sibling nodes recursively before flattening. */
    compareNodes?: (a: TreeNode<TData>, b: TreeNode<TData>) => number;
    /** Expanded state used for flattening. */
    expanded?: Record<string, boolean> | true;
    /** Force retained filter paths open so matching descendants are visible. */
    expandFilteredPaths?: boolean;
}
/**
 * Build a tree structure from flat data using path arrays.
 * Each data item's path defines its position in the hierarchy.
 *
 * @example
 * ```
 * const data = [
 *   { name: 'USA', value: 100 },
 *   { name: 'California', value: 50 },
 *   { name: 'San Francisco', value: 20 },
 * ]
 * // With getDataPath returning:
 * // ['USA'] for first item
 * // ['USA', 'California'] for second
 * // ['USA', 'California', 'San Francisco'] for third
 * ```
 */
declare function buildTreeFromPaths<TData extends RowData>(data: TData[], getDataPath: (item: TData) => string[]): TreeNode<TData>[];
/**
 * Flatten a tree of nodes into a row array, respecting expanded state.
 * Only includes children of expanded nodes.
 */
declare function flattenTree<TData extends RowData>(table: Table<TData>, treeNodes: TreeNode<TData>[], expanded: Record<string, boolean> | true): Row<TData>[];
/**
 * Filter tree data, keeping parent chain visible when a child matches.
 * Returns a new tree with only matching nodes and their ancestors.
 */
declare function filterTreeData<TData extends RowData>(nodes: TreeNode<TData>[], predicate: (node: TreeNode<TData>) => boolean): TreeNode<TData>[];
/**
 * Sort tree data recursively. Children are sorted independently at each level.
 */
declare function sortTreeData<TData extends RowData>(nodes: TreeNode<TData>[], compareFn: (a: TreeNode<TData>, b: TreeNode<TData>) => number): TreeNode<TData>[];
/**
 * Create a RowModel from tree data, applying the full tree processing pipeline.
 */
declare function getTreeRowModel<TData extends RowData>(table: Table<TData>, data: TData[], getDataPath: (item: TData) => string[], options?: TreeRowModelOptions<TData>): RowModel<TData>;
/**
 * Get the tree depth for a row (shortcut for row._treeDepth).
 */
declare function getTreeDepth<TData extends RowData>(row: Row<TData>): number;
/**
 * Check if a row is a leaf node (no children).
 */
declare function isLeafRow<TData extends RowData>(row: Row<TData>): boolean;
/**
 * Get the parent row by looking up parentId in the row model.
 */
declare function getParentRow<TData extends RowData>(row: Row<TData>, table: Table<TData>): Row<TData> | undefined;
/**
 * Aggregate values from leaf rows to parent nodes.
 */
declare function aggregateTreeValues<TData extends RowData>(nodes: TreeNode<TData>[], _columnId: string, aggregationFn: (values: unknown[]) => unknown, getValueFromData: (data: TData) => unknown): Map<string, unknown>;

export { type TreeDataOptions, type TreeNode, type TreeRowModelOptions, aggregateTreeValues, buildTreeFromPaths, filterTreeData, flattenTree, getParentRow, getTreeDepth, getTreeRowModel, isLeafRow, sortTreeData };