/**
 * 比较两个数字
 * @param a 第一个数字
 * @param b 第二个数字
 * @returns 如果相等返回 0，a > b 返回 1，否则返回 -1
 */
export declare function compareNumber(a: number, b: number): 0 | 1 | -1;
/**
 * 节点视图配置类 - 定义节点的显示方式
 * @template T 节点数据的类型
 */
export declare class NodeViewOptions<T> {
    /**
     * 获取节点的唯一标识字段
     */
    keyField: keyof T;
    /**
     * 获取节点的文字
     * 可以是字段名或函数
     */
    textField: keyof T | ((data: T) => string);
    /**
     * 创建节点视图配置
     * @param options 配置选项
     */
    constructor(options: {
        /** 唯一标识字段名 */
        keyField: keyof T;
        /** 显示文字的字段名或获取函数 */
        textField: keyof T | ((data: T) => string);
    });
    /**
     * 获取节点的文字
     * @param data 节点数据
     * @returns 显示文字
     */
    getText(data: T): string;
    /**
     * 获取节点的唯一标识
     * @param data 节点数据
     * @returns 唯一标识值
     */
    getKey(data: T): any;
}
/**
 * 树节点接口
 * @template T 节点数据的类型
 */
export interface ITreeNode<T> {
    /**
     * 是否展开（显示子节点）
     */
    expand: boolean;
    /**
     * 是否正在加载（用于懒加载）
     */
    loading: boolean;
    /**
     * 获取节点层级（根节点为 0）
     */
    get level(): number;
    /**
     * 获取子节点列表（只读，不能从外部修改）
     * @returns 子节点数组，如果没有子节点返回 null
     */
    get children(): Array<ITreeNode<T>> | null;
    sort(compareFn: (a: T, b: T) => number): void;
    append(childItem: T | Array<T>): ITreeNode<T> | Array<ITreeNode<T>>;
    /**
     * 从父节点中分离（删除当前节点）
     */
    detach(): void;
    /**
     * 移动到另一个父节点下
     * @param newParent 新的父节点
     * @returns 当前节点（支持链式调用）
     */
    moveTo(newParent: ITreeNode<T>): ITreeNode<T>;
    /**
     * 替换当前节点的数据
     * @param newItem 新的数据对象
     */
    replace(newItem: T): void;
    /**
     * 获取节点的数据
     */
    get item(): T;
    /**
     * 删除所有子节点
     */
    removeChildren(): void;
    /**
     * 获取父节点
     */
    parent: TreeNode<T> | null;
}
/**
 * TreeNode 类 - 树节点，包含数据和方法（内部类）
 * @template T 节点数据的类型
 * @internal
 *
 * @description
 * TreeNode 是树结构的基本单元，每个节点包含：
 * - 节点数据（item）
 * - 父节点引用（parent）
 * - 子节点列表（children）
 * - 展开状态（expand）
 * - 加载状态（loading）
 *
 * 节点提供了丰富的操作方法，可以直接在节点上进行增删改查操作。
 *
 * 注意：此类为内部实现，外部应使用 ITreeNode 接口
 */
declare class TreeNode<T> implements ITreeNode<T> {
    /**
     * 节点数据（私有，只读）
     * @private
     */
    private _item;
    /**
     * 节点层级（私有）
     * @private
     */
    private _level;
    /**
     * 是否展开（显示子节点）
     */
    expand: boolean;
    /**
     * 是否正在加载（用于懒加载）
     */
    loading: boolean;
    /**
     * 父节点（只读）
     */
    readonly parent: TreeNode<T> | null;
    /**
     * 子节点数组（私有）
     * @private
     */
    private _children;
    private readonly nodes;
    /**
     * 创建树节点
     * @param item 节点数据
     * @param nodes
     * @param parent 父节点（可选）
     * @param children 子节点列表（可选）
     */
    constructor(item: T, nodes: TreeNodes<T>, parent?: TreeNode<T> | null, children?: Array<TreeNode<T>> | null);
    /**
     * 获取节点层级
     * @returns 层级值（根节点为 0）
     */
    get level(): number;
    /**
     * 获取子节点列表（只读）
     * @returns 子节点数组的浅拷贝，如果没有子节点返回 null
     */
    get children(): Array<TreeNode<T>> | null;
    sort(compareFn: (a: T, b: T) => number): void;
    set children(value: Array<TreeNode<T>>);
    /**
     * 添加子节点
     * @param childItem 子节点数据
     * @returns 新创建的子节点
     */
    append(childItem: T | Array<T>): ITreeNode<T> | Array<ITreeNode<T>>;
    /**
     * 从父节点中分离（删除当前节点）
     */
    detach(): void;
    /**
     * 删除指定的子节点
     * @param node 要删除的子节点
     * @private
     */
    private removeNode;
    /**
     * 移动到另一个父节点下
     * @param newParent 新的父节点
     * @returns 新创建的节点（注意：返回的是新节点，不是原节点）
     */
    moveTo(newParent: TreeNode<T>): ITreeNode<T>;
    /**
     * 替换当前节点的数据
     * @param newItem 新的数据对象
     */
    replace(newItem: T): void;
    /**
     * 获取节点数据
     * @returns 节点数据对象
     */
    get item(): T;
    /**
     * 删除所有子节点
     */
    removeChildren(): void;
    /**
     * @internal 仅供 TreeNodes 内部使用
     * 设置父节点，并将自己添加到父节点的 children 中
     * @param parent 新的父节点
     *
     * @description
     * 此方法会：
     * 1. 从原父节点的 children 中移除自己
     * 2. 更新父节点引用
     * 3. 重新计算层级
     * 4. 将自己添加到新父节点的 children 中
     */
    _setParent(parent: TreeNode<T> | null): void;
}
/**
 * 判断数据是否为根节点的函数类型
 * @template T 数据类型
 */
export type CheckIsRoot<T> = (data: T) => boolean;
/**
 * 比较函数类型
 * @template T 数据类型
 * @returns 返回 0 表示相等，正数表示 o1 > o2，负数表示 o1 < o2
 */
export type CompareFun<T> = (o1: T, o2: T) => number | undefined;
/**
 * 获取文本的函数类型
 * @template T 数据类型
 */
export type GetText<T> = (data: T) => string;
/**
 * 判断节点是否为分支（有子节点）的函数类型
 * @template T 数据类型
 */
export type CheckIsDirectory<T> = (node: ITreeNode<T>) => boolean;
type StringKeys<T> = {
    [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];
/**
 * TreeNodes 配置选项
 * @template T 节点数据的类型
 */
export interface TreeNodeOptions<T> {
    /**
     * 唯一标识字段名（默认：'id'）
     */
    keyField?: StringKeys<T>;
    /**
     * 显示文字的字段名或获取函数（默认：'text'）
     */
    textField?: keyof T | GetText<T>;
    /**
     * 父节点引用字段名（默认：'parentId'）
     */
    parentKeyField?: StringKeys<T>;
    /**
     * 判断数据是否为根节点的函数（必需）
     */
    checkIsRoot: CheckIsRoot<T>;
    /**
     * 判断节点是否为分支的函数（可选）
     */
    checkIsDirectory?: CheckIsDirectory<T>;
    /**
     * 排序比较函数（可选）
     */
    compareFun?: CompareFun<T>;
    /**
     * 默认展开深度（默认：1）
     */
    expendDepth?: number;
}
/**
 * TreeNodes 类 - 树节点管理器
 * @template T 节点数据的类型
 *
 * @description
 * TreeNodes 负责管理树结构的数据，包括：
 * - 树的构建和初始化
 * - 节点的映射和查找
 * - 版本管理（用于响应式更新）
 * - 层级展开控制
 */
export default class TreeNodes<T> {
    protected readonly checkIsRoot: CheckIsRoot<T>;
    protected readonly keyField: StringKeys<T>;
    protected readonly parentKeyField: StringKeys<T>;
    protected readonly textField: keyof T | GetText<T>;
    protected readonly checkIsDirectory: CheckIsDirectory<T> | undefined;
    protected nodeMap: Map<any, TreeNode<T>>;
    protected compareFun: any | undefined;
    protected expendDepth: number;
    protected _nodes: Array<TreeNode<T>>;
    protected _version: number;
    /**
     * 创建 TreeNodes 实例
     * @param options 配置选项
     */
    constructor(options: TreeNodeOptions<T>);
    /**
     * 设置树数据
     * @param list 扁平化的节点数据数组
     *
     * @description
     * 此方法会：
     * 1. 清空现有树结构
     * 2. 创建所有节点
     * 3. 根据 parentKeyField 建立父子关系
     * 4. 应用展开深度设置
     * 5. 触发版本更新
     */
    setData(list: Array<T>): void;
    /**
     * 获取节点
     */
    get nodes(): Array<ITreeNode<T>>;
    /**
     * 获取版本号，用于触发 Svelte 响应式更新
     */
    get version(): number;
    /**
     * 设置展开层级
     * @param nodes
     * @param currentLevel
     * @protected
     */
    protected setExpandForDepth(nodes: TreeNode<T>[], currentLevel: number): void;
    /**
     * 获取展开的展示列表
     * @returns 展开的所有节点（按层级顺序）
     */
    getHierarchyList(): Array<ITreeNode<T>>;
    /**
     * 将展开的节点添加到列表
     * @param nodes 节点数组
     * @param list 结果列表
     * @private
     */
    private addExpandNodesToList;
    /**
     * 增加一个新节点（便捷方法，会自动根据 parentKeyField 找到父节点）
     * @param item 要添加的节点数据
     */
    append(item: T): ITreeNode<T>;
    replace(item: T): ITreeNode<T> | null;
    remove(item: T): ITreeNode<T> | null;
    /**
     * 从节点列表中查找节点
     * @param nodes 节点数组
     * @param item 要查找的数据项
     * @param matchedKey 匹配的字段名
     * @returns 找到的节点或 null
     * @private
     */
    private _findNodeFromList;
}
export declare class MenuNodes<T> extends TreeNodes<T> {
    /**
     * 删除所有属于分支但没有子节点的节点
     */
    protected cleanEmptyDirectories(): void;
    private pruneEmptyDirs;
}
export {};