@esengine/behavior-tree 1.0.0 → 1.0.2

package/index.d.ts

@@ -1,2875 +0,0 @@
-/**
- * @esengine/behavior-tree v1.0.0
- * TypeScript definitions
- */
-import { IService, Component, Entity, EntitySystem, IPlugin, Core, ServiceContainer, IScene } from '@esengine/ecs-framework';
-
-/**
- * 任务执行状态
- */
-declare enum TaskStatus {
-    /** 无效状态 - 节点未初始化或已被重置 */
-    Invalid = 0,
-    /** 成功 - 节点执行成功完成 */
-    Success = 1,
-    /** 失败 - 节点执行失败 */
-    Failure = 2,
-    /** 运行中 - 节点正在执行，需要在后续帧继续 */
-    Running = 3
-}
-/**
- * 节点类型
- */
-declare enum NodeType {
-    /** 复合节点 - 有多个子节点 */
-    Composite = "composite",
-    /** 装饰器节点 - 有一个子节点 */
-    Decorator = "decorator",
-    /** 动作节点 - 叶子节点 */
-    Action = "action",
-    /** 条件节点 - 叶子节点 */
-    Condition = "condition"
-}
-/**
- * 复合节点类型
- */
-declare enum CompositeType {
-    /** 序列 - 按顺序执行，全部成功才成功 */
-    Sequence = "sequence",
-    /** 选择 - 按顺序执行，任一成功则成功 */
-    Selector = "selector",
-    /** 并行 - 同时执行所有子节点 */
-    Parallel = "parallel",
-    /** 并行选择 - 并行执行，任一成功则成功 */
-    ParallelSelector = "parallel-selector",
-    /** 随机序列 - 随机顺序执行序列 */
-    RandomSequence = "random-sequence",
-    /** 随机选择 - 随机顺序执行选择 */
-    RandomSelector = "random-selector"
-}
-/**
- * 装饰器节点类型
- */
-declare enum DecoratorType {
-    /** 反转 - 反转子节点结果 */
-    Inverter = "inverter",
-    /** 重复 - 重复执行子节点 */
-    Repeater = "repeater",
-    /** 直到成功 - 重复直到成功 */
-    UntilSuccess = "until-success",
-    /** 直到失败 - 重复直到失败 */
-    UntilFail = "until-fail",
-    /** 总是成功 - 无论子节点结果都返回成功 */
-    AlwaysSucceed = "always-succeed",
-    /** 总是失败 - 无论子节点结果都返回失败 */
-    AlwaysFail = "always-fail",
-    /** 条件装饰器 - 基于条件执行子节点 */
-    Conditional = "conditional",
-    /** 冷却 - 冷却时间内阻止执行 */
-    Cooldown = "cooldown",
-    /** 超时 - 超时则返回失败 */
-    Timeout = "timeout"
-}
-/**
- * 中止类型
- *
- * 用于动态优先级和条件重新评估
- */
-declare enum AbortType {
-    /** 无 - 不中止任何节点 */
-    None = "none",
-    /** 自身 - 条件变化时可以中止自身的执行 */
-    Self = "self",
-    /** 低优先级 - 条件满足时可以中止低优先级的兄弟节点 */
-    LowerPriority = "lower-priority",
-    /** 两者 - 可以中止自身和低优先级节点 */
-    Both = "both"
-}
-/**
- * 黑板变量类型
- */
-declare enum BlackboardValueType {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    Vector2 = "vector2",
-    Vector3 = "vector3",
-    Object = "object",
-    Array = "array"
-}
-
-/**
- * 全局黑板配置
- */
-interface GlobalBlackboardConfig {
-    version: string;
-    variables: BlackboardVariable[];
-}
-/**
- * 全局黑板服务
- *
- * 提供所有行为树共享的全局变量存储
- *
- * 使用方式：
- * ```typescript
- * // 注册服务（在 BehaviorTreePlugin.install 中自动完成）
- * core.services.registerSingleton(GlobalBlackboardService);
- *
- * // 获取服务
- * const blackboard = core.services.resolve(GlobalBlackboardService);
- * ```
- */
-declare class GlobalBlackboardService implements IService {
-    private variables;
-    dispose(): void;
-    /**
-     * 定义全局变量
-     */
-    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
-        readonly?: boolean;
-        description?: string;
-    }): void;
-    /**
-     * 获取全局变量值
-     */
-    getValue<T = any>(name: string): T | undefined;
-    /**
-     * 设置全局变量值
-     */
-    setValue(name: string, value: any, force?: boolean): boolean;
-    /**
-     * 检查全局变量是否存在
-     */
-    hasVariable(name: string): boolean;
-    /**
-     * 删除全局变量
-     */
-    removeVariable(name: string): boolean;
-    /**
-     * 获取所有变量名
-     */
-    getVariableNames(): string[];
-    /**
-     * 获取所有变量
-     */
-    getAllVariables(): BlackboardVariable[];
-    /**
-     * 清空所有全局变量
-     */
-    clear(): void;
-    /**
-     * 批量设置变量
-     */
-    setVariables(values: Record<string, any>): void;
-    /**
-     * 批量获取变量
-     */
-    getVariables(names: string[]): Record<string, any>;
-    /**
-     * 导出配置
-     */
-    exportConfig(): GlobalBlackboardConfig;
-    /**
-     * 导入配置
-     */
-    importConfig(config: GlobalBlackboardConfig): void;
-    /**
-     * 序列化为 JSON
-     */
-    toJSON(): string;
-    /**
-     * 从 JSON 反序列化
-     */
-    static fromJSON(json: string): GlobalBlackboardConfig;
-}
-
-/**
- * 黑板变量定义
- */
-interface BlackboardVariable {
-    name: string;
-    type: BlackboardValueType;
-    value: any;
-    readonly?: boolean;
-    description?: string;
-}
-/**
- * 黑板组件 - 用于节点间共享数据
- *
- * 支持分层查找：
- * 1. 先查找本地变量
- * 2. 如果找不到，自动查找全局 Blackboard
- *
- * 通常附加到行为树的根节点上
- */
-declare class BlackboardComponent extends Component {
-    /** 存储的本地变量 */
-    private variables;
-    /** 是否启用全局 Blackboard 查找 */
-    private useGlobalBlackboard;
-    /**
-     * 定义一个新变量
-     */
-    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
-        readonly?: boolean;
-        description?: string;
-    }): void;
-    /**
-     * 获取变量值
-     * 先查找本地变量，找不到则查找全局变量
-     */
-    getValue<T = any>(name: string): T | undefined;
-    /**
-     * 获取本地变量值（不查找全局）
-     */
-    getLocalValue<T = any>(name: string): T | undefined;
-    /**
-     * 设置变量值
-     * 优先设置本地变量，如果本地不存在且全局存在，则设置全局变量
-     */
-    setValue(name: string, value: any, force?: boolean): boolean;
-    /**
-     * 设置本地变量值（不影响全局）
-     */
-    setLocalValue(name: string, value: any, force?: boolean): boolean;
-    /**
-     * 检查变量是否存在（包括本地和全局）
-     */
-    hasVariable(name: string): boolean;
-    /**
-     * 检查本地变量是否存在
-     */
-    hasLocalVariable(name: string): boolean;
-    /**
-     * 删除变量
-     */
-    removeVariable(name: string): boolean;
-    /**
-     * 获取所有变量名
-     */
-    getVariableNames(): string[];
-    /**
-     * 清空所有本地变量
-     */
-    clear(): void;
-    /**
-     * 启用/禁用全局 Blackboard 查找
-     */
-    setUseGlobalBlackboard(enabled: boolean): void;
-    /**
-     * 是否启用全局 Blackboard 查找
-     */
-    isUsingGlobalBlackboard(): boolean;
-    /**
-     * 获取所有变量（包括本地和全局）
-     */
-    getAllVariables(): BlackboardVariable[];
-    /**
-     * 获取全局 Blackboard 服务的引用
-     */
-    static getGlobalBlackboard(): GlobalBlackboardService;
-}
-
-/**
- * 自定义动作函数类型
- */
-type CustomActionFunction = (entity: Entity, blackboard?: BlackboardComponent, deltaTime?: number) => TaskStatus;
-/**
- * 执行自定义函数动作组件
- *
- * 允许用户提供自定义的动作执行函数
- */
-declare class ExecuteAction extends Component {
-    actionCode?: string;
-    parameters: Record<string, any>;
-    /** 编译后的函数（不序列化） */
-    private compiledFunction?;
-    /**
-     * 获取或编译执行函数
-     */
-    getFunction(): CustomActionFunction | undefined;
-    /**
-     * 设置自定义函数（运行时使用）
-     */
-    setFunction(func: CustomActionFunction): void;
-}
-
-/**
- * 等待动作组件
- *
- * 等待指定时间后返回成功
- */
-declare class WaitAction extends Component {
-    waitTime: number;
-    /** 已等待时间（秒） */
-    elapsedTime: number;
-    /**
-     * 重置等待状态
-     */
-    reset(): void;
-}
-
-/**
- * 日志动作组件
- *
- * 输出日志信息
- */
-declare class LogAction extends Component {
-    message: string;
-    level: 'log' | 'info' | 'warn' | 'error';
-    includeEntityInfo: boolean;
-}
-
-/**
- * 设置黑板变量值动作组件
- *
- * 将指定值或另一个黑板变量的值设置到目标变量
- */
-declare class SetBlackboardValueAction extends Component {
-    variableName: string;
-    value: any;
-    sourceVariable?: string;
-    force: boolean;
-}
-
-/**
- * 修改操作类型
- */
-declare enum ModifyOperation {
-    /** 加法 */
-    Add = "add",
-    /** 减法 */
-    Subtract = "subtract",
-    /** 乘法 */
-    Multiply = "multiply",
-    /** 除法 */
-    Divide = "divide",
-    /** 取模 */
-    Modulo = "modulo",
-    /** 追加（数组/字符串） */
-    Append = "append",
-    /** 移除（数组） */
-    Remove = "remove"
-}
-/**
- * 修改黑板变量值动作组件
- *
- * 对黑板变量执行数学或逻辑操作
- */
-declare class ModifyBlackboardValueAction extends Component {
-    variableName: string;
-    operation: ModifyOperation;
-    operand: any;
-    force: boolean;
-}
-
-/**
- * 比较运算符
- */
-declare enum CompareOperator {
-    /** 等于 */
-    Equal = "equal",
-    /** 不等于 */
-    NotEqual = "notEqual",
-    /** 大于 */
-    Greater = "greater",
-    /** 大于等于 */
-    GreaterOrEqual = "greaterOrEqual",
-    /** 小于 */
-    Less = "less",
-    /** 小于等于 */
-    LessOrEqual = "lessOrEqual",
-    /** 包含（字符串/数组） */
-    Contains = "contains",
-    /** 正则匹配 */
-    Matches = "matches"
-}
-/**
- * 黑板变量比较条件组件
- *
- * 比较黑板变量与指定值或另一个变量
- */
-declare class BlackboardCompareCondition extends Component {
-    variableName: string;
-    operator: CompareOperator;
-    compareValue: any;
-    invertResult: boolean;
-}
-
-/**
- * 黑板变量存在性检查条件组件
- *
- * 检查黑板变量是否存在
- */
-declare class BlackboardExistsCondition extends Component {
-    variableName: string;
-    checkNotNull: boolean;
-    invertResult: boolean;
-}
-
-/**
- * 随机概率条件组件
- *
- * 根据概率返回成功或失败
- */
-declare class RandomProbabilityCondition extends Component {
-    probability: number;
-    alwaysRandomize: boolean;
-    /** 缓存的随机结果（不序列化） */
-    private cachedResult?;
-    /**
-     * 评估随机概率
-     */
-    evaluate(): boolean;
-    /**
-     * 重置缓存
-     */
-    reset(): void;
-}
-
-/**
- * 自定义条件函数类型
- */
-type CustomConditionFunction = (entity: Entity, blackboard?: BlackboardComponent, deltaTime?: number) => boolean;
-/**
- * 执行自定义条件组件
- *
- * 允许用户提供自定义的条件检查函数
- */
-declare class ExecuteCondition extends Component {
-    conditionCode?: string;
-    parameters: Record<string, any>;
-    invertResult: boolean;
-    /** 编译后的函数（不序列化） */
-    private compiledFunction?;
-    /**
-     * 获取或编译条件函数
-     */
-    getFunction(): CustomConditionFunction | undefined;
-    /**
-     * 设置自定义函数（运行时使用）
-     */
-    setFunction(func: CustomConditionFunction): void;
-}
-
-/**
- * 复合节点组件
- *
- * 用于标识复合节点类型（Sequence, Selector, Parallel等）
- */
-declare class CompositeNodeComponent extends Component {
-    /** 复合节点类型 */
-    compositeType: CompositeType;
-    /** 随机化的子节点索引顺序 */
-    protected shuffledIndices: number[];
-    /** 是否在重启时重新洗牌（子类可选） */
-    protected reshuffleOnRestart: boolean;
-    /**
-     * 获取下一个子节点索引
-     */
-    getNextChildIndex(currentIndex: number, totalChildren: number): number;
-    /**
-     * 洗牌子节点索引
-     */
-    private shuffleIndices;
-    /**
-     * 重置洗牌状态
-     */
-    resetShuffle(): void;
-}
-
-/**
- * 序列节点
- *
- * 按顺序执行所有子节点，全部成功才成功
- */
-declare class SequenceNode extends CompositeNodeComponent {
-    abortType: AbortType;
-    constructor();
-}
-
-/**
- * 选择节点
- *
- * 按顺序执行子节点，任一成功则成功
- */
-declare class SelectorNode extends CompositeNodeComponent {
-    abortType: AbortType;
-    constructor();
-}
-
-/**
- * 并行节点
- *
- * 同时执行所有子节点
- */
-declare class ParallelNode extends CompositeNodeComponent {
-    successPolicy: 'all' | 'one';
-    failurePolicy: 'one' | 'all';
-    constructor();
-}
-
-/**
- * 并行选择节点
- *
- * 并行执行子节点，任一成功则成功
- */
-declare class ParallelSelectorNode extends CompositeNodeComponent {
-    failurePolicy: 'one' | 'all';
-    constructor();
-}
-
-/**
- * 随机序列节点
- *
- * 随机顺序执行子节点序列
- */
-declare class RandomSequenceNode extends CompositeNodeComponent {
-    reshuffleOnRestart: boolean;
-    constructor();
-}
-
-/**
- * 随机选择节点
- *
- * 随机顺序执行子节点选择
- */
-declare class RandomSelectorNode extends CompositeNodeComponent {
-    reshuffleOnRestart: boolean;
-    constructor();
-}
-
-/**
- * SubTree 节点 - 引用其他行为树作为子树
- *
- * 允许将其他行为树嵌入到当前树中，实现行为树的复用和模块化。
- *
- * 注意：SubTreeNode 是一个特殊的叶子节点，它不会执行编辑器中静态连接的子节点，
- * 只会执行从 assetId 动态加载的外部行为树文件。
- *
- * @example
- * ```typescript
- * const subTree = entity.addComponent(SubTreeNode);
- * subTree.assetId = 'patrol';
- * subTree.inheritParentBlackboard = true;
- * ```
- */
-declare class SubTreeNode extends CompositeNodeComponent {
-    /**
-     * 引用的子树资产ID
-     * 逻辑标识符，例如 'patrol' 或 'ai/patrol'
-     * 实际的文件路径由 AssetLoader 决定
-     */
-    assetId: string;
-    /**
-     * 是否将父黑板传递给子树
-     *
-     * - true: 子树可以访问和修改父树的黑板变量
-     * - false: 子树使用独立的黑板实例
-     */
-    inheritParentBlackboard: boolean;
-    /**
-     * 子树执行失败时是否传播失败状态
-     *
-     * - true: 子树失败时，SubTree 节点返回 Failure
-     * - false: 子树失败时，SubTree 节点返回 Success（忽略失败）
-     */
-    propagateFailure: boolean;
-    /**
-     * 是否在行为树启动时预加载子树
-     *
-     * - true: 在根节点开始执行前预加载此子树，确保执行时子树已就绪
-     * - false: 运行时异步加载，执行到此节点时才开始加载（可能会有延迟）
-     */
-    preload: boolean;
-    /**
-     * 子树的根实体（运行时）
-     * 在执行时动态创建，执行结束后销毁
-     */
-    private subTreeRoot?;
-    /**
-     * 子树是否已完成
-     */
-    private subTreeCompleted;
-    /**
-     * 子树的最终状态
-     */
-    private subTreeResult;
-    /**
-     * 获取子树根实体
-     */
-    getSubTreeRoot(): Entity | undefined;
-    /**
-     * 设置子树根实体（由执行系统调用）
-     */
-    setSubTreeRoot(root: Entity | undefined): void;
-    /**
-     * 标记子树完成（由执行系统调用）
-     */
-    markSubTreeCompleted(result: TaskStatus): void;
-    /**
-     * 检查子树是否已完成
-     */
-    isSubTreeCompleted(): boolean;
-    /**
-     * 获取子树执行结果
-     */
-    getSubTreeResult(): TaskStatus;
-    /**
-     * 重置子树状态
-     */
-    reset(): void;
-    /**
-     * 重置完成状态（用于复用预加载的子树）
-     * 保留子树根引用，只重置完成标记
-     */
-    resetCompletionState(): void;
-    /**
-     * 验证配置
-     */
-    validate(): string[];
-}
-
-/**
- * 装饰器节点组件基类
- *
- * 只包含通用的装饰器类型标识
- * 具体的属性由各个子类自己定义
- */
-declare class DecoratorNodeComponent extends Component {
-    /** 装饰器类型 */
-    decoratorType: DecoratorType;
-}
-
-/**
- * 反转节点
- *
- * 反转子节点的执行结果
- */
-declare class InverterNode extends DecoratorNodeComponent {
-    constructor();
-}
-
-/**
- * 重复节点
- *
- * 重复执行子节点指定次数
- */
-declare class RepeaterNode extends DecoratorNodeComponent {
-    constructor();
-    repeatCount: number;
-    endOnFailure: boolean;
-    /** 当前已重复次数 */
-    currentRepeatCount: number;
-    /**
-     * 增加重复计数
-     */
-    incrementRepeat(): void;
-    /**
-     * 检查是否应该继续重复
-     */
-    shouldContinueRepeat(): boolean;
-    /**
-     * 重置状态
-     */
-    reset(): void;
-}
-
-/**
- * 直到成功节点
- *
- * 重复执行子节点直到成功
- */
-declare class UntilSuccessNode extends DecoratorNodeComponent {
-    constructor();
-}
-
-/**
- * 直到失败节点
- *
- * 重复执行子节点直到失败
- */
-declare class UntilFailNode extends DecoratorNodeComponent {
-    constructor();
-}
-
-/**
- * 总是成功节点
- *
- * 无论子节点结果如何都返回成功
- */
-declare class AlwaysSucceedNode extends DecoratorNodeComponent {
-    constructor();
-}
-
-/**
- * 总是失败节点
- *
- * 无论子节点结果如何都返回失败
- */
-declare class AlwaysFailNode extends DecoratorNodeComponent {
-    constructor();
-}
-
-/**
- * 条件装饰器节点
- *
- * 基于条件判断是否执行子节点
- */
-declare class ConditionalNode extends DecoratorNodeComponent {
-    constructor();
-    conditionCode?: string;
-    shouldReevaluate: boolean;
-    /** 编译后的条件函数（不序列化） */
-    private compiledCondition?;
-    /**
-     * 评估条件
-     */
-    evaluateCondition(entity: Entity, blackboard?: BlackboardComponent): boolean;
-    /**
-     * 设置条件函数（运行时使用）
-     */
-    setConditionFunction(func: (entity: Entity, blackboard?: BlackboardComponent) => boolean): void;
-}
-
-/**
- * 冷却节点
- *
- * 在冷却时间内阻止子节点执行
- */
-declare class CooldownNode extends DecoratorNodeComponent {
-    constructor();
-    cooldownTime: number;
-    /** 上次执行时间 */
-    lastExecutionTime: number;
-    /**
-     * 检查是否可以执行
-     */
-    canExecute(currentTime: number): boolean;
-    /**
-     * 记录执行时间
-     */
-    recordExecution(currentTime: number): void;
-    /**
-     * 重置状态
-     */
-    reset(): void;
-}
-
-/**
- * 超时节点
- *
- * 子节点执行超时则返回失败
- */
-declare class TimeoutNode extends DecoratorNodeComponent {
-    constructor();
-    timeoutDuration: number;
-    /** 开始执行时间 */
-    startTime: number;
-    /**
-     * 记录开始时间
-     */
-    recordStartTime(currentTime: number): void;
-    /**
-     * 检查是否超时
-     */
-    isTimeout(currentTime: number): boolean;
-    /**
-     * 重置状态
-     */
-    reset(): void;
-}
-
-/**
- * 行为树节点基础组件
- *
- * 所有行为树节点都必须包含此组件
- */
-declare class BehaviorTreeNode extends Component {
-    /** 节点类型 */
-    nodeType: NodeType;
-    /** 节点名称（用于调试） */
-    nodeName: string;
-    /** 当前执行状态 */
-    status: TaskStatus;
-    /** 当前执行的子节点索引（用于复合节点） */
-    currentChildIndex: number;
-    /**
-     * 重置节点状态
-     */
-    reset(): void;
-    /**
-     * 标记节点为失效（递归重置子节点）
-     * 注意：此方法只重置当前节点，子节点需要在 System 中处理
-     */
-    invalidate(): void;
-}
-
-/**
- * 活跃节点标记组件
- *
- * 标记当前应该被执行的节点。
- * 只有带有此组件的节点才会被各个执行系统处理。
- *
- * 这是一个标记组件（Tag Component），不包含数据，只用于标识。
- *
- * 执行流程：
- * 1. 初始时只有根节点带有 ActiveNode
- * 2. 父节点决定激活哪个子节点时，为子节点添加 ActiveNode
- * 3. 节点执行完成后移除 ActiveNode
- * 4. 通过这种方式实现按需执行，避免每帧遍历整棵树
- */
-declare class ActiveNode extends Component {
-}
-
-/**
- * 属性绑定组件
- * 记录节点属性到黑板变量的绑定关系
- */
-declare class PropertyBindings extends Component {
-    /**
-     * 属性绑定映射
-     * key: 属性名称 (如 'message')
-     * value: 黑板变量名 (如 'test1')
-     */
-    bindings: Map<string, string>;
-    /**
-     * 添加属性绑定
-     */
-    addBinding(propertyName: string, blackboardKey: string): void;
-    /**
-     * 获取属性绑定的黑板变量名
-     */
-    getBinding(propertyName: string): string | undefined;
-    /**
-     * 检查属性是否绑定到黑板变量
-     */
-    hasBinding(propertyName: string): boolean;
-    /**
-     * 清除所有绑定
-     */
-    clearBindings(): void;
-}
-
-/**
- * 日志输出组件
- *
- * 存储运行时输出的日志信息，用于在UI中显示
- */
-declare class LogOutput extends Component {
-    /**
-     * 日志消息列表
-     */
-    messages: Array<{
-        timestamp: number;
-        message: string;
-        level: 'log' | 'info' | 'warn' | 'error';
-    }>;
-    /**
-     * 添加日志消息
-     */
-    addMessage(message: string, level?: 'log' | 'info' | 'warn' | 'error'): void;
-    /**
-     * 清空日志
-     */
-    clear(): void;
-}
-
-/**
- * 资产元数据组件
- *
- * 附加到从资产实例化的行为树根节点上，
- * 用于标记资产ID和版本信息，便于循环引用检测和调试。
- *
- * @example
- * ```typescript
- * const rootEntity = BehaviorTreeAssetLoader.instantiate(asset, scene);
- *
- * // 添加元数据
- * const metadata = rootEntity.addComponent(new BehaviorTreeAssetMetadata());
- * metadata.assetId = 'patrol';
- * metadata.assetVersion = '1.0.0';
- * ```
- */
-declare class BehaviorTreeAssetMetadata extends Component {
-    /**
-     * 资产ID
-     */
-    assetId: string;
-    /**
-     * 资产版本
-     */
-    assetVersion: string;
-    /**
-     * 资产名称
-     */
-    assetName: string;
-    /**
-     * 加载时间
-     */
-    loadedAt: number;
-    /**
-     * 资产描述
-     */
-    description: string;
-    /**
-     * 初始化
-     */
-    initialize(assetId: string, assetVersion: string, assetName?: string): void;
-}
-
-/**
- * 根节点
- *
- * 行为树的根节点，简单地激活第一个子节点
- */
-declare class RootNode extends CompositeNodeComponent {
-    constructor();
-}
-
-/**
- * 根节点执行系统
- *
- * 专门处理根节点的执行逻辑
- * 根节点的职责：
- * 1. 扫描并预加载所有标记为 preload=true 的子树
- * 2. 激活第一个子节点，并根据子节点的状态来设置自己的状态
- *
- * updateOrder: 350 (在所有其他执行系统之后)
- */
-declare class RootExecutionSystem extends EntitySystem {
-    /** 跟踪每个根节点的预加载状态 */
-    private preloadStates;
-    /** 跟踪预加载任务 */
-    private preloadTasks;
-    /** AssetLoader 实例 */
-    private assetLoader?;
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行根节点逻辑
-     */
-    private executeRoot;
-    /**
-     * 开始预加载子树
-     */
-    private startPreload;
-    /**
-     * 扫描所有需要预加载的子树节点
-     */
-    private scanSubTreeNodes;
-    /**
-     * 预加载所有子树
-     */
-    private preloadAllSubTrees;
-    /**
-     * 预加载单个子树
-     */
-    private preloadSingleSubTree;
-    /**
-     * 设置黑板继承
-     */
-    private setupBlackboardInheritance;
-    /**
-     * 查找黑板组件
-     */
-    private findBlackboard;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 统一的日志输出方法
-     */
-    private outputLog;
-    /**
-     * 递归打印子树结构（用于调试）
-     */
-    private logSubTreeStructure;
-    /**
-     * 清理资源
-     */
-    protected onDestroy(): void;
-    protected getLoggerName(): string;
-}
-
-/**
- * 叶子节点执行系统
- *
- * 负责执行所有活跃的叶子节点（Action 和 Condition）
- * 只处理带有 ActiveNode 标记的节点
- *
- * updateOrder: 100 (最先执行)
- */
-declare class LeafExecutionSystem extends EntitySystem {
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行动作节点
-     */
-    private executeAction;
-    /**
-     * 执行等待动作
-     */
-    private executeWaitAction;
-    /**
-     * 执行日志动作
-     */
-    private executeLogAction;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 执行设置黑板变量值
-     */
-    private executeSetBlackboardValue;
-    /**
-     * 执行修改黑板变量值
-     */
-    private executeModifyBlackboardValue;
-    /**
-     * 执行自定义动作
-     */
-    private executeCustomAction;
-    /**
-     * 执行条件节点
-     */
-    private executeCondition;
-    /**
-     * 评估黑板比较条件
-     */
-    private evaluateBlackboardCompare;
-    /**
-     * 评估黑板变量存在性
-     */
-    private evaluateBlackboardExists;
-    /**
-     * 评估随机概率
-     */
-    private evaluateRandomProbability;
-    /**
-     * 评估自定义条件
-     */
-    private evaluateCustomCondition;
-    /**
-     * 解析属性值
-     * 如果属性绑定到黑板变量，从黑板读取最新值
-     */
-    private resolvePropertyValue;
-    /**
-     * 移除节点的活跃标记
-     */
-    private deactivateNode;
-    /**
-     * 通知父节点子节点已完成
-     */
-    private notifyParent;
-    /**
-     * 查找黑板组件（向上遍历父节点）
-     */
-    private findBlackboard;
-    /**
-     * 从Entity提取节点显示名称和ID
-     */
-    private getNodeInfo;
-    /**
-     * 统一的日志输出方法
-     * 同时输出到控制台和LogOutput组件，确保用户在UI中能看到
-     */
-    private outputLog;
-    protected getLoggerName(): string;
-}
-
-/**
- * 装饰器节点执行系统
- *
- * 负责处理所有活跃的装饰器节点
- * 读取子节点状态，根据装饰器规则决定自己的状态
- *
- * updateOrder: 200 (在叶子节点之后执行)
- */
-declare class DecoratorExecutionSystem extends EntitySystem {
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行装饰器逻辑
-     */
-    private executeDecorator;
-    /**
-     * 反转装饰器
-     */
-    private handleInverter;
-    /**
-     * 重复装饰器
-     */
-    private handleRepeater;
-    /**
-     * 直到成功装饰器
-     */
-    private handleUntilSuccess;
-    /**
-     * 直到失败装饰器
-     */
-    private handleUntilFail;
-    /**
-     * 总是成功装饰器
-     */
-    private handleAlwaysSucceed;
-    /**
-     * 总是失败装饰器
-     */
-    private handleAlwaysFail;
-    /**
-     * 条件装饰器
-     */
-    private handleConditional;
-    /**
-     * 冷却装饰器
-     */
-    private handleCooldown;
-    /**
-     * 超时装饰器
-     */
-    private handleTimeout;
-    /**
-     * 完成节点执行
-     */
-    private completeNode;
-    /**
-     * 查找黑板组件（向上遍历父节点）
-     */
-    private findBlackboard;
-    /**
-     * 解析属性值
-     * 如果属性绑定到黑板变量，从黑板读取最新值
-     */
-    private resolvePropertyValue;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 统一的日志输出方法
-     * 同时输出到控制台和LogOutput组件，确保用户在UI中能看到
-     */
-    private outputLog;
-    protected getLoggerName(): string;
-}
-
-/**
- * 复合节点执行系统
- *
- * 负责处理所有活跃的复合节点
- * 读取子节点状态，根据复合规则决定自己的状态和激活哪些子节点
- *
- * updateOrder: 300 (在叶子节点和装饰器之后执行)
- */
-declare class CompositeExecutionSystem extends EntitySystem {
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行复合节点逻辑
-     */
-    private executeComposite;
-    /**
-     * 序列节点：所有子节点都成功才成功
-     */
-    private handleSequence;
-    /**
-     * 选择器节点：任一子节点成功就成功
-     */
-    private handleSelector;
-    /**
-     * 并行节点：所有子节点都执行，全部成功才成功
-     */
-    private handleParallel;
-    /**
-     * 并行选择器：任一成功则成功
-     */
-    private handleParallelSelector;
-    /**
-     * 随机序列
-     */
-    private handleRandomSequence;
-    /**
-     * 随机选择器
-     */
-    private handleRandomSelector;
-    /**
-     * 检查是否应该中止当前执行
-     */
-    private shouldAbort;
-    /**
-     * 评估条件节点
-     */
-    private evaluateCondition;
-    /**
-     * 评估黑板比较条件
-     */
-    private evaluateBlackboardCompare;
-    /**
-     * 评估黑板变量存在性
-     */
-    private evaluateBlackboardExists;
-    /**
-     * 评估随机概率
-     */
-    private evaluateRandomProbability;
-    /**
-     * 评估自定义条件
-     */
-    private evaluateCustomCondition;
-    /**
-     * 解析字符串中的变量引用
-     */
-    private resolveVariableReferences;
-    /**
-     * 查找黑板组件
-     */
-    private findBlackboard;
-    /**
-     * 中止当前执行
-     */
-    private abortExecution;
-    /**
-     * 递归停用节点及其所有子节点
-     */
-    private deactivateNode;
-    /**
-     * 递归重置所有子节点的状态
-     */
-    private resetAllChildren;
-    /**
-     * 完成节点执行
-     */
-    private completeNode;
-    protected getLoggerName(): string;
-}
-
-/**
- * 资产加载状态
- */
-declare enum LoadingState {
-    /** 未开始 */
-    Idle = "idle",
-    /** 即将开始 */
-    Pending = "pending",
-    /** 加载中 */
-    Loading = "loading",
-    /** 加载成功 */
-    Loaded = "loaded",
-    /** 加载失败 */
-    Failed = "failed",
-    /** 加载超时 */
-    Timeout = "timeout",
-    /** 已取消 */
-    Cancelled = "cancelled"
-}
-/**
- * 加载任务
- */
-interface LoadingTask {
-    /** 资产ID */
-    assetId: string;
-    /** 加载Promise */
-    promise: Promise<Entity>;
-    /** 开始时间 */
-    startTime: number;
-    /** 上次重试时间 */
-    lastRetryTime: number;
-    /** 当前重试次数 */
-    retryCount: number;
-    /** 最大重试次数 */
-    maxRetries: number;
-    /** 超时时间（毫秒） */
-    timeoutMs: number;
-    /** 当前状态 */
-    state: LoadingState;
-    /** 错误信息 */
-    error?: Error;
-    /** 父实体ID */
-    parentEntityId: number;
-    /** 父实体引用（需要在使用前检查isDestroyed） */
-    parentEntity: Entity;
-    /** 父资产ID（用于循环检测） */
-    parentAssetId?: string;
-    /** 加载结果（缓存） */
-    result?: Entity;
-}
-/**
- * 加载任务句柄
- */
-interface LoadingTaskHandle {
-    /** 资产ID */
-    assetId: string;
-    /** 获取当前状态 */
-    getState(): LoadingState;
-    /** 获取错误信息 */
-    getError(): Error | undefined;
-    /** 获取加载进度信息 */
-    getProgress(): LoadingProgress;
-    /** 取消加载 */
-    cancel(): void;
-    /** 加载Promise */
-    promise: Promise<Entity>;
-}
-/**
- * 加载进度信息
- */
-interface LoadingProgress {
-    /** 当前状态 */
-    state: LoadingState;
-    /** 已耗时（毫秒） */
-    elapsedMs: number;
-    /** 剩余超时时间（毫秒） */
-    remainingTimeoutMs: number;
-    /** 当前重试次数 */
-    retryCount: number;
-    /** 最大重试次数 */
-    maxRetries: number;
-}
-/**
- * 加载选项
- */
-interface LoadingOptions {
-    /** 超时时间（毫秒），默认5000 */
-    timeoutMs?: number;
-    /** 最大重试次数，默认3 */
-    maxRetries?: number;
-    /** 父资产ID（用于循环检测） */
-    parentAssetId?: string;
-    /** 重试延迟基数（毫秒），默认100 */
-    retryDelayBase?: number;
-    /** 最大重试延迟（毫秒），默认2000 */
-    maxRetryDelay?: number;
-}
-/**
- * 超时错误
- */
-declare class TimeoutError extends Error {
-    constructor(message: string);
-}
-/**
- * 循环依赖错误
- */
-declare class CircularDependencyError extends Error {
-    constructor(message: string);
-}
-/**
- * 实体已销毁错误
- */
-declare class EntityDestroyedError extends Error {
-    constructor(message: string);
-}
-
-/**
- * 资产加载管理器
- *
- * 统一管理行为树资产的异步加载，提供：
- * - 超时检测和自动重试
- * - 循环引用检测
- * - 实体生命周期安全
- * - 加载状态追踪
- *
- * @example
- * ```typescript
- * const manager = new AssetLoadingManager();
- *
- * const handle = manager.startLoading(
- *     'patrol',
- *     parentEntity,
- *     () => assetLoader.loadBehaviorTree('patrol'),
- *     { timeoutMs: 5000, maxRetries: 3 }
- * );
- *
- * // 在系统的 process() 中轮询检查
- * const state = handle.getState();
- * if (state === LoadingState.Loaded) {
- *     const entity = await handle.promise;
- *     // 使用加载的实体
- * }
- * ```
- */
-declare class AssetLoadingManager implements IService {
-    /** 正在进行的加载任务 */
-    private tasks;
-    /** 加载栈（用于循环检测） */
-    private loadingStack;
-    /** 默认配置 */
-    private defaultOptions;
-    /**
-     * 开始加载资产
-     *
-     * @param assetId 资产ID
-     * @param parentEntity 父实体（用于生命周期检查）
-     * @param loader 加载函数
-     * @param options 加载选项
-     * @returns 加载任务句柄
-     */
-    startLoading(assetId: string, parentEntity: Entity, loader: () => Promise<Entity>, options?: LoadingOptions): LoadingTaskHandle;
-    /**
-     * 带超时和重试的加载
-     */
-    private loadWithTimeoutAndRetry;
-    /**
-     * Promise 超时包装
-     */
-    private withTimeout;
-    /**
-     * 循环依赖检测
-     */
-    private detectCircularDependency;
-    /**
-     * 获取任务状态
-     */
-    getTaskState(assetId: string): LoadingState;
-    /**
-     * 获取任务
-     */
-    getTask(assetId: string): LoadingTask | undefined;
-    /**
-     * 取消加载
-     */
-    cancelLoading(assetId: string): void;
-    /**
-     * 清理任务
-     */
-    private cleanup;
-    /**
-     * 延迟
-     */
-    private delay;
-    /**
-     * 创建任务句柄
-     */
-    private createHandle;
-    /**
-     * 获取所有正在加载的资产
-     */
-    getLoadingAssets(): string[];
-    /**
-     * 获取加载统计信息
-     */
-    getStats(): {
-        totalTasks: number;
-        loadingTasks: number;
-        failedTasks: number;
-        timeoutTasks: number;
-    };
-    /**
-     * 清空所有任务
-     */
-    clear(): void;
-    /**
-     * 释放资源
-     */
-    dispose(): void;
-}
-
-/**
- * SubTree 执行系统
- *
- * 处理 SubTree 节点的执行，包括：
- * - 子树资产加载
- * - 子树实例化
- * - 黑板继承
- * - 子树执行和状态管理
- *
- * updateOrder: 300 (与 CompositeExecutionSystem 同级)
- */
-declare class SubTreeExecutionSystem extends EntitySystem {
-    private assetLoader?;
-    private assetLoaderInitialized;
-    private hasLoggedMissingAssetLoader;
-    private loadingManager;
-    private loadingTasks;
-    constructor(loadingManager?: AssetLoadingManager);
-    protected onInitialize(): void;
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行子树节点
-     */
-    private executeSubTree;
-    /**
-     * 延迟初始化 AssetLoader
-     */
-    private ensureAssetLoaderInitialized;
-    /**
-     * 加载并实例化子树（使用加载管理器）
-     */
-    private loadAndInstantiateSubTree;
-    /**
-     * 开始新的加载任务
-     */
-    private startNewLoading;
-    /**
-     * 加载完成时的处理
-     */
-    private onLoadingComplete;
-    /**
-     * 加载资产
-     */
-    private loadAsset;
-    /**
-     * 设置黑板继承
-     */
-    private setupBlackboardInheritance;
-    /**
-     * 查找黑板
-     */
-    private findBlackboard;
-    /**
-     * 开始子树执行
-     */
-    private startSubTreeExecution;
-    /**
-     * 更新子树状态
-     */
-    private updateSubTree;
-    /**
-     * 子树完成时的处理
-     */
-    private onSubTreeCompleted;
-    /**
-     * 清理子树
-     */
-    private cleanupSubTree;
-    /**
-     * 递归重置子树的所有节点
-     */
-    private resetSubTreeRecursively;
-    /**
-     * 完成节点执行
-     */
-    private completeNode;
-    /**
-     * 获取父树的资产ID（用于循环检测）
-     */
-    private getParentTreeAssetId;
-    /**
-     * 系统销毁时清理
-     */
-    protected onDestroy(): void;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 统一的日志输出方法
-     * 同时输出到控制台和LogOutput组件，确保用户在UI中能看到
-     */
-    private outputLog;
-    /**
-     * 递归打印子树结构（用于调试）
-     */
-    private logSubTreeStructure;
-    protected getLoggerName(): string;
-}
-
-/**
- * 资产类型
- */
-declare enum AssetType {
-    BehaviorTree = "behavior-tree",
-    Blackboard = "blackboard",
-    Unknown = "unknown"
-}
-/**
- * 资产注册信息
- */
-interface AssetRegistry {
-    /** 资产唯一ID */
-    id: string;
-    /** 资产名称 */
-    name: string;
-    /** 资产相对路径（相对于工作区根目录） */
-    path: string;
-    /** 资产类型 */
-    type: AssetType;
-    /** 依赖的其他资产ID列表 */
-    dependencies: string[];
-    /** 最后修改时间 */
-    lastModified?: number;
-    /** 资产元数据 */
-    metadata?: Record<string, any>;
-}
-/**
- * 工作区配置
- */
-interface WorkspaceConfig {
-    /** 工作区名称 */
-    name: string;
-    /** 工作区版本 */
-    version: string;
-    /** 工作区根目录（绝对路径） */
-    rootPath: string;
-    /** 资产目录配置 */
-    assetPaths: {
-        /** 行为树目录 */
-        behaviorTrees: string;
-        /** 黑板目录 */
-        blackboards: string;
-    };
-    /** 资产注册表 */
-    assets: AssetRegistry[];
-}
-/**
- * 工作区服务
- *
- * 管理项目的工作区配置和资产注册表，提供：
- * - 工作区配置的加载和保存
- * - 资产注册和查询
- * - 依赖关系追踪
- * - 循环依赖检测
- */
-declare class WorkspaceService implements IService {
-    private config;
-    private assetMap;
-    private assetPathMap;
-    /**
-     * 初始化工作区
-     */
-    initialize(config: WorkspaceConfig): void;
-    /**
-     * 重建资产映射表
-     */
-    private rebuildAssetMaps;
-    /**
-     * 获取工作区配置
-     */
-    getConfig(): WorkspaceConfig | null;
-    /**
-     * 更新工作区配置
-     */
-    updateConfig(config: WorkspaceConfig): void;
-    /**
-     * 注册资产
-     */
-    registerAsset(asset: AssetRegistry): void;
-    /**
-     * 取消注册资产
-     */
-    unregisterAsset(assetId: string): void;
-    /**
-     * 通过ID获取资产
-     */
-    getAssetById(assetId: string): AssetRegistry | undefined;
-    /**
-     * 通过路径获取资产
-     */
-    getAssetByPath(path: string): AssetRegistry | undefined;
-    /**
-     * 获取所有资产
-     */
-    getAllAssets(): AssetRegistry[];
-    /**
-     * 按类型获取资产
-     */
-    getAssetsByType(type: AssetType): AssetRegistry[];
-    /**
-     * 获取行为树资产列表
-     */
-    getBehaviorTreeAssets(): AssetRegistry[];
-    /**
-     * 获取黑板资产列表
-     */
-    getBlackboardAssets(): AssetRegistry[];
-    /**
-     * 获取资产的所有依赖（递归）
-     */
-    getAssetDependencies(assetId: string, visited?: Set<string>): AssetRegistry[];
-    /**
-     * 检测循环依赖
-     *
-     * @param assetId 要检查的资产ID
-     * @returns 如果存在循环依赖，返回循环路径；否则返回 null
-     */
-    detectCircularDependency(assetId: string): string[] | null;
-    /**
-     * 检查是否可以添加依赖（不会造成循环依赖）
-     *
-     * @param assetId 资产ID
-     * @param dependencyId 要添加的依赖ID
-     * @returns 是否可以安全添加
-     */
-    canAddDependency(assetId: string, dependencyId: string): boolean;
-    /**
-     * 添加资产依赖
-     */
-    addAssetDependency(assetId: string, dependencyId: string): boolean;
-    /**
-     * 移除资产依赖
-     */
-    removeAssetDependency(assetId: string, dependencyId: string): void;
-    /**
-     * 解析资产路径（支持相对路径和绝对路径）
-     */
-    resolveAssetPath(path: string): string;
-    /**
-     * 获取资产的相对路径
-     */
-    getRelativePath(absolutePath: string): string;
-    /**
-     * 清理资源
-     */
-    dispose(): void;
-}
-
-/**
- * 行为树资产元数据
- */
-interface AssetMetadata {
-    name: string;
-    description?: string;
-    version: string;
-    createdAt?: string;
-    modifiedAt?: string;
-}
-/**
- * 黑板变量定义
- */
-interface BlackboardVariableDefinition {
-    name: string;
-    type: BlackboardValueType;
-    defaultValue: any;
-    readonly?: boolean;
-    description?: string;
-}
-/**
- * 行为树节点数据（运行时格式）
- */
-interface BehaviorTreeNodeData {
-    id: string;
-    name: string;
-    nodeType: NodeType;
-    data: Record<string, any>;
-    children: string[];
-}
-/**
- * 属性绑定定义
- */
-interface PropertyBinding {
-    nodeId: string;
-    propertyName: string;
-    variableName: string;
-}
-/**
- * 行为树资产（运行时格式）
- *
- * 这是用于游戏运行时的优化格式，不包含编辑器UI信息
- */
-interface BehaviorTreeAsset {
-    /**
-     * 资产格式版本
-     */
-    version: string;
-    /**
-     * 元数据
-     */
-    metadata: AssetMetadata;
-    /**
-     * 根节点ID
-     */
-    rootNodeId: string;
-    /**
-     * 所有节点数据（扁平化存储，通过children建立层级）
-     */
-    nodes: BehaviorTreeNodeData[];
-    /**
-     * 黑板变量定义
-     */
-    blackboard: BlackboardVariableDefinition[];
-    /**
-     * 属性绑定
-     */
-    propertyBindings?: PropertyBinding[];
-}
-/**
- * 资产验证结果
- */
-interface AssetValidationResult {
-    valid: boolean;
-    errors?: string[];
-    warnings?: string[];
-}
-/**
- * 资产验证器
- */
-declare class BehaviorTreeAssetValidator {
-    /**
-     * 验证资产数据的完整性和正确性
-     */
-    static validate(asset: BehaviorTreeAsset): AssetValidationResult;
-    /**
-     * 获取资产统计信息
-     */
-    static getStats(asset: BehaviorTreeAsset): {
-        nodeCount: number;
-        actionCount: number;
-        conditionCount: number;
-        compositeCount: number;
-        decoratorCount: number;
-        blackboardVariableCount: number;
-        propertyBindingCount: number;
-        maxDepth: number;
-    };
-}
-
-/**
- * 资产加载器接口
- *
- * 提供可扩展的资产加载机制，允许用户自定义资产加载逻辑。
- * 支持从文件系统、网络、数据库、自定义打包格式等加载资产。
- *
- * @example
- * ```typescript
- * // 使用默认的文件系统加载器
- * const loader = new FileSystemAssetLoader({
- *     basePath: 'assets/behavior-trees',
- *     format: 'json'
- * });
- * core.services.registerInstance(FileSystemAssetLoader, loader);
- *
- * // 或实现自定义加载器
- * class NetworkAssetLoader implements IAssetLoader {
- *     async loadBehaviorTree(assetId: string): Promise<BehaviorTreeAsset> {
- *         const response = await fetch(`/api/assets/${assetId}`);
- *         return response.json();
- *     }
- *
- *     async exists(assetId: string): Promise<boolean> {
- *         const response = await fetch(`/api/assets/${assetId}/exists`);
- *         return response.json();
- *     }
- * }
- * core.services.registerInstance(FileSystemAssetLoader, new NetworkAssetLoader());
- * ```
- */
-interface IAssetLoader {
-    /**
-     * 加载行为树资产
-     *
-     * @param assetId 资产逻辑ID，例如 'patrol' 或 'ai/patrol'
-     * @returns 行为树资产对象
-     * @throws 如果资产不存在或加载失败
-     */
-    loadBehaviorTree(assetId: string): Promise<BehaviorTreeAsset>;
-    /**
-     * 检查资产是否存在
-     *
-     * @param assetId 资产逻辑ID
-     * @returns 资产是否存在
-     */
-    exists(assetId: string): Promise<boolean>;
-    /**
-     * 预加载资产（可选）
-     *
-     * 用于提前加载资产到缓存，减少运行时延迟
-     *
-     * @param assetIds 要预加载的资产ID列表
-     */
-    preload?(assetIds: string[]): Promise<void>;
-    /**
-     * 卸载资产（可选）
-     *
-     * 释放资产占用的内存
-     *
-     * @param assetId 资产ID
-     */
-    unload?(assetId: string): void;
-}
-
-/**
- * 文件系统资产加载器配置
- */
-interface FileSystemAssetLoaderConfig {
-    /** 资产基础路径 */
-    basePath: string;
-    /** 资产格式 */
-    format: 'json' | 'binary';
-    /** 文件扩展名（可选，默认根据格式自动设置） */
-    extension?: string;
-    /** 是否启用缓存 */
-    enableCache?: boolean;
-    /** 自定义文件读取函数（可选） */
-    readFile?: (path: string) => Promise<string | Uint8Array>;
-}
-/**
- * 文件系统资产加载器
- *
- * 从文件系统加载行为树资产，支持 JSON 和 Binary 格式。
- * 提供资产缓存和预加载功能。
- *
- * @example
- * ```typescript
- * // 创建加载器
- * const loader = new FileSystemAssetLoader({
- *     basePath: 'assets/behavior-trees',
- *     format: 'json',
- *     enableCache: true
- * });
- *
- * // 加载资产
- * const asset = await loader.loadBehaviorTree('patrol');
- * ```
- */
-declare class FileSystemAssetLoader implements IAssetLoader, IService {
-    private config;
-    private cache;
-    constructor(config: FileSystemAssetLoaderConfig);
-    /**
-     * 加载行为树资产
-     */
-    loadBehaviorTree(assetId: string): Promise<BehaviorTreeAsset>;
-    /**
-     * 检查资产是否存在
-     */
-    exists(assetId: string): Promise<boolean>;
-    /**
-     * 预加载资产
-     */
-    preload(assetIds: string[]): Promise<void>;
-    /**
-     * 卸载资产
-     */
-    unload(assetId: string): void;
-    /**
-     * 清空缓存
-     */
-    clearCache(): void;
-    /**
-     * 获取缓存的资产数量
-     */
-    getCacheSize(): number;
-    /**
-     * 释放资源
-     */
-    dispose(): void;
-    /**
-     * 解析资产路径
-     */
-    private resolveAssetPath;
-    /**
-     * 默认文件读取实现
-     *
-     * 注意：此实现依赖运行环境
-     * - 浏览器：需要通过 fetch 或 XMLHttpRequest
-     * - Node.js：需要使用 fs
-     * - 游戏引擎：需要使用引擎的文件 API
-     *
-     * 用户应该提供自己的 readFile 实现
-     */
-    private defaultReadFile;
-}
-
-/**
- * 行为树插件
- *
- * 提供便捷方法向场景添加行为树系统
- *
- * @example
- * ```typescript
- * const core = Core.create();
- * const plugin = new BehaviorTreePlugin();
- * await core.pluginManager.install(plugin);
- *
- * // 为场景添加行为树系统
- * const scene = new Scene();
- * plugin.setupScene(scene);
- * ```
- */
-declare class BehaviorTreePlugin implements IPlugin {
-    readonly name = "@esengine/behavior-tree";
-    readonly version = "1.0.0";
-    private worldManager;
-    private services;
-    /**
-     * 安装插件
-     */
-    install(core: Core, services: ServiceContainer): Promise<void>;
-    /**
-     * 卸载插件
-     */
-    uninstall(): Promise<void>;
-    /**
-     * 为场景设置行为树系统
-     *
-     * 向场景添加所有必需的行为树系统：
-     * - LeafExecutionSystem (updateOrder: 100)
-     * - DecoratorExecutionSystem (updateOrder: 200)
-     * - CompositeExecutionSystem (updateOrder: 300)
-     * - SubTreeExecutionSystem (updateOrder: 300)
-     *
-     * @param scene 目标场景
-     *
-     * @example
-     * ```typescript
-     * const scene = new Scene();
-     * behaviorTreePlugin.setupScene(scene);
-     * ```
-     */
-    setupScene(scene: IScene): void;
-    /**
-     * 为所有现有场景设置行为树系统
-     */
-    setupAllScenes(): void;
-}
-
-/**
- * 行为树启动/停止辅助类
- *
- * 提供便捷方法来启动、停止和暂停行为树
- */
-declare class BehaviorTreeStarter {
-    /**
-     * 启动行为树
-     *
-     * 给根节点添加 ActiveNode 组件，使行为树开始执行
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * const aiRoot = scene.createEntity('aiRoot');
-     * // ... 构建行为树结构
-     * BehaviorTreeStarter.start(aiRoot);
-     * ```
-     */
-    static start(rootEntity: Entity): void;
-    /**
-     * 停止行为树
-     *
-     * 移除所有节点的 ActiveNode 组件，停止执行
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * BehaviorTreeStarter.stop(aiRoot);
-     * ```
-     */
-    static stop(rootEntity: Entity): void;
-    /**
-     * 递归停止所有子节点
-     */
-    private static stopRecursive;
-    /**
-     * 暂停行为树
-     *
-     * 移除 ActiveNode 但保留节点状态，可以恢复执行
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * // 暂停
-     * BehaviorTreeStarter.pause(aiRoot);
-     *
-     * // 恢复
-     * BehaviorTreeStarter.resume(aiRoot);
-     * ```
-     */
-    static pause(rootEntity: Entity): void;
-    /**
-     * 递归暂停所有子节点
-     */
-    private static pauseRecursive;
-    /**
-     * 恢复行为树执行
-     *
-     * 从暂停状态恢复，重新添加 ActiveNode 到之前正在执行的节点
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * BehaviorTreeStarter.resume(aiRoot);
-     * ```
-     */
-    static resume(rootEntity: Entity): void;
-    /**
-     * 递归恢复所有正在执行的节点
-     */
-    private static resumeRecursive;
-    /**
-     * 重启行为树
-     *
-     * 停止并重置所有节点，然后重新启动
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * BehaviorTreeStarter.restart(aiRoot);
-     * ```
-     */
-    static restart(rootEntity: Entity): void;
-    /**
-     * 检查行为树是否正在运行
-     *
-     * @param rootEntity 行为树根节点实体
-     * @returns 是否正在运行
-     *
-     * @example
-     * ```typescript
-     * if (BehaviorTreeStarter.isRunning(aiRoot)) {
-     *     console.log('AI is active');
-     * }
-     * ```
-     */
-    static isRunning(rootEntity: Entity): boolean;
-}
-
-/**
- * 行为树构建器
- *
- * 提供流式 API 来构建行为树结构
- *
- * @example
- * ```typescript
- * const aiRoot = BehaviorTreeBuilder.create(scene, 'AI')
- *     .blackboard()
- *         .defineVariable('health', BlackboardValueType.Number, 100)
- *         .defineVariable('target', BlackboardValueType.Object, null)
- *     .endBlackboard()
- *     .selector('MainSelector')
- *         .sequence('AttackSequence')
- *             .condition((entity, blackboard) => {
- *                 return blackboard?.getValue('health') > 50;
- *             })
- *             .action('Attack', (entity) => TaskStatus.Success)
- *         .end()
- *         .action('Flee', (entity) => TaskStatus.Success)
- *     .end()
- *     .build();
- * ```
- */
-declare class BehaviorTreeBuilder {
-    private scene;
-    private currentEntity;
-    private entityStack;
-    private blackboardEntity?;
-    private constructor();
-    /**
-     * 创建行为树构建器
-     *
-     * @param scene 场景实例
-     * @param rootName 根节点名称
-     * @returns 构建器实例
-     */
-    static create(scene: IScene, rootName?: string): BehaviorTreeBuilder;
-    /**
-     * 添加黑板组件到根节点
-     */
-    blackboard(): BehaviorTreeBuilder;
-    /**
-     * 定义黑板变量
-     */
-    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
-        readonly?: boolean;
-        description?: string;
-    }): BehaviorTreeBuilder;
-    /**
-     * 结束黑板定义
-     */
-    endBlackboard(): BehaviorTreeBuilder;
-    /**
-     * 创建序列节点
-     */
-    sequence(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建选择器节点
-     */
-    selector(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建并行节点
-     */
-    parallel(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建并行选择器节点
-     */
-    parallelSelector(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建随机序列节点
-     */
-    randomSequence(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建随机选择器节点
-     */
-    randomSelector(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建复合节点
-     */
-    private composite;
-    /**
-     * 创建反转装饰器
-     */
-    inverter(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建重复装饰器
-     */
-    repeater(name?: string, count?: number, endOnFailure?: boolean): BehaviorTreeBuilder;
-    /**
-     * 创建直到成功装饰器
-     */
-    untilSuccess(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建直到失败装饰器
-     */
-    untilFail(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建总是成功装饰器
-     */
-    alwaysSucceed(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建总是失败装饰器
-     */
-    alwaysFail(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建条件装饰器
-     */
-    conditional(name: string, conditionCode: string): BehaviorTreeBuilder;
-    /**
-     * 创建冷却装饰器
-     */
-    cooldown(name?: string, cooldownTime?: number): BehaviorTreeBuilder;
-    /**
-     * 创建超时装饰器
-     */
-    timeout(name?: string, timeoutDuration?: number): BehaviorTreeBuilder;
-    /**
-     * 创建等待动作
-     */
-    wait(waitTime: number, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建日志动作
-     */
-    log(message: string, level?: 'log' | 'info' | 'warn' | 'error', name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建设置黑板值动作
-     */
-    setBlackboardValue(variableName: string, value: any, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建修改黑板值动作
-     */
-    modifyBlackboardValue(variableName: string, operation: ModifyOperation, operand: any, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建自定义动作
-     */
-    action(name: string, func: CustomActionFunction): BehaviorTreeBuilder;
-    /**
-     * 创建黑板比较条件
-     */
-    compareBlackboardValue(variableName: string, operator: CompareOperator, compareValue: any, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建黑板变量存在条件
-     */
-    checkBlackboardExists(variableName: string, checkNotNull?: boolean, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建随机概率条件
-     */
-    randomProbability(probability: number, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建自定义条件
-     */
-    condition(func: CustomConditionFunction, name?: string): BehaviorTreeBuilder;
-    /**
-     * 结束当前节点，返回父节点
-     */
-    end(): BehaviorTreeBuilder;
-    /**
-     * 构建并返回根节点实体
-     */
-    build(): Entity;
-}
-
-/**
- * 行为树持久化工具
- *
- * 使用框架的序列化系统进行二进制/JSON序列化
- */
-declare class BehaviorTreePersistence {
-    /**
-     * 序列化行为树（JSON格式）
-     *
-     * @param rootEntity 行为树根实体
-     * @param pretty 是否格式化
-     * @returns 序列化数据（JSON字符串或二进制）
-     *
-     * @example
-     * ```typescript
-     * const data = BehaviorTreePersistence.serialize(aiRoot);
-     * ```
-     */
-    static serialize(rootEntity: Entity, pretty?: boolean): string | Uint8Array;
-    /**
-     * 从序列化数据加载行为树
-     *
-     * @param scene 场景实例
-     * @param data 序列化数据（JSON字符串或二进制）
-     *
-     * @example
-     * ```typescript
-     * // 从文件读取
-     * const json = await readFile('behavior-tree.json');
-     *
-     * // 恢复行为树到场景
-     * BehaviorTreePersistence.deserialize(scene, json);
-     * ```
-     */
-    static deserialize(scene: IScene, data: string | Uint8Array): void;
-    /**
-     * 序列化为 JSON 字符串
-     *
-     * @param rootEntity 行为树根实体
-     * @param pretty 是否格式化
-     * @returns JSON 字符串
-     */
-    static toJSON(rootEntity: Entity, pretty?: boolean): string;
-    /**
-     * 从 JSON 字符串加载
-     *
-     * @param scene 场景实例
-     * @param json JSON 字符串
-     */
-    static fromJSON(scene: IScene, json: string): void;
-    /**
-     * 保存到文件（需要 Tauri 环境）
-     *
-     * @param rootEntity 行为树根实体
-     * @param filePath 文件路径
-     *
-     * @example
-     * ```typescript
-     * await BehaviorTreePersistence.saveToFile(aiRoot, 'ai-behavior.json');
-     * ```
-     */
-    static saveToFile(rootEntity: Entity, filePath: string): Promise<void>;
-    /**
-     * 从文件加载（需要 Tauri 环境）
-     *
-     * @param scene 场景实例
-     * @param filePath 文件路径
-     * @returns 恢复的根实体
-     *
-     * @example
-     * ```typescript
-     * const aiRoot = await BehaviorTreePersistence.loadFromFile(scene, 'ai-behavior.json');
-     * ```
-     */
-    static loadFromFile(scene: IScene, filePath: string): Promise<Entity>;
-    /**
-     * 验证是否为有效的行为树数据
-     *
-     * @param data 序列化数据（字符串格式）
-     * @returns 是否有效
-     */
-    static validate(data: string): boolean;
-    /**
-     * 克隆行为树
-     *
-     * @param scene 场景实例
-     * @param rootEntity 要克隆的行为树根实体
-     * @returns 克隆的新实体
-     *
-     * @example
-     * ```typescript
-     * const clonedAI = BehaviorTreePersistence.clone(scene, originalAI);
-     * ```
-     */
-    static clone(scene: IScene, rootEntity: Entity): Entity;
-}
-
-/**
- * 节点数据JSON格式（用于编辑器）
- */
-interface NodeDataJSON {
-    nodeType: string;
-    compositeType?: string;
-    decoratorType?: string;
-    [key: string]: any;
-}
-/**
- * 属性定义（用于编辑器）
- */
-interface PropertyDefinition {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'select' | 'blackboard' | 'code' | 'variable' | 'asset';
-    label: string;
-    description?: string;
-    defaultValue?: any;
-    options?: Array<{
-        label: string;
-        value: any;
-    }>;
-    min?: number;
-    max?: number;
-    step?: number;
-    required?: boolean;
-}
-/**
- * 节点模板（用于编辑器）
- */
-interface NodeTemplate {
-    type: NodeType;
-    displayName: string;
-    category: string;
-    icon?: string;
-    description: string;
-    color?: string;
-    className?: string;
-    requiresChildren?: boolean;
-    defaultConfig: Partial<NodeDataJSON>;
-    properties: PropertyDefinition[];
-}
-/**
- * 编辑器节点模板库
- *
- * 使用装饰器系统管理所有节点
- */
-declare class NodeTemplates {
-    /**
-     * 获取所有节点模板（通过装饰器注册）
-     */
-    static getAllTemplates(): NodeTemplate[];
-    /**
-     * 根据类型和子类型获取模板
-     */
-    static getTemplate(type: NodeType, subType: string): NodeTemplate | undefined;
-}
-
-/**
- * 序列化格式
- */
-type SerializationFormat = 'json' | 'binary';
-/**
- * 序列化选项
- */
-interface SerializationOptions {
-    /**
-     * 序列化格式
-     */
-    format: SerializationFormat;
-    /**
-     * 是否美化JSON输出（仅format='json'时有效）
-     */
-    pretty?: boolean;
-    /**
-     * 是否在序列化前验证资产
-     */
-    validate?: boolean;
-}
-/**
- * 反序列化选项
- */
-interface DeserializationOptions {
-    /**
-     * 是否在反序列化后验证资产
-     */
-    validate?: boolean;
-    /**
-     * 是否严格模式（验证失败抛出异常）
-     */
-    strict?: boolean;
-}
-/**
- * 行为树资产序列化器
- *
- * 支持JSON和二进制（MessagePack）两种格式
- */
-declare class BehaviorTreeAssetSerializer {
-    /**
-     * 序列化资产
-     *
-     * @param asset 行为树资产
-     * @param options 序列化选项
-     * @returns 序列化后的数据（字符串或Uint8Array）
-     *
-     * @example
-     * ```typescript
-     * // JSON格式
-     * const jsonData = BehaviorTreeAssetSerializer.serialize(asset, { format: 'json', pretty: true });
-     *
-     * // 二进制格式
-     * const binaryData = BehaviorTreeAssetSerializer.serialize(asset, { format: 'binary' });
-     * ```
-     */
-    static serialize(asset: BehaviorTreeAsset, options?: SerializationOptions): string | Uint8Array;
-    /**
-     * 序列化为JSON格式
-     */
-    private static serializeToJSON;
-    /**
-     * 序列化为二进制格式（MessagePack）
-     */
-    private static serializeToBinary;
-    /**
-     * 反序列化资产
-     *
-     * @param data 序列化的数据（字符串或Uint8Array）
-     * @param options 反序列化选项
-     * @returns 行为树资产
-     *
-     * @example
-     * ```typescript
-     * // 从JSON加载
-     * const asset = BehaviorTreeAssetSerializer.deserialize(jsonString);
-     *
-     * // 从二进制加载
-     * const asset = BehaviorTreeAssetSerializer.deserialize(binaryData);
-     * ```
-     */
-    static deserialize(data: string | Uint8Array, options?: DeserializationOptions): BehaviorTreeAsset;
-    /**
-     * 从JSON反序列化
-     */
-    private static deserializeFromJSON;
-    /**
-     * 从二进制反序列化
-     */
-    private static deserializeFromBinary;
-    /**
-     * 检测数据格式
-     *
-     * @param data 序列化的数据
-     * @returns 格式类型
-     */
-    static detectFormat(data: string | Uint8Array): SerializationFormat;
-    /**
-     * 获取序列化数据的信息（不完全反序列化）
-     *
-     * @param data 序列化的数据
-     * @returns 资产元信息
-     */
-    static getInfo(data: string | Uint8Array): {
-        format: SerializationFormat;
-        name: string;
-        version: string;
-        nodeCount: number;
-        blackboardVariableCount: number;
-        size: number;
-    } | null;
-    /**
-     * 转换格式
-     *
-     * @param data 源数据
-     * @param targetFormat 目标格式
-     * @param pretty 是否美化JSON（仅当目标格式为json时有效）
-     * @returns 转换后的数据
-     *
-     * @example
-     * ```typescript
-     * // JSON转二进制
-     * const binary = BehaviorTreeAssetSerializer.convert(jsonString, 'binary');
-     *
-     * // 二进制转JSON
-     * const json = BehaviorTreeAssetSerializer.convert(binaryData, 'json', true);
-     * ```
-     */
-    static convert(data: string | Uint8Array, targetFormat: SerializationFormat, pretty?: boolean): string | Uint8Array;
-    /**
-     * 比较两个资产数据的大小
-     *
-     * @param jsonData JSON格式数据
-     * @param binaryData 二进制格式数据
-     * @returns 压缩率（百分比）
-     */
-    static compareSize(jsonData: string, binaryData: Uint8Array): {
-        jsonSize: number;
-        binarySize: number;
-        compressionRatio: number;
-        savedBytes: number;
-    };
-}
-
-/**
- * 实例化选项
- */
-interface InstantiateOptions {
-    /**
-     * 实体名称前缀
-     */
-    namePrefix?: string;
-    /**
-     * 是否共享黑板（如果为true，将使用全局黑板服务）
-     */
-    sharedBlackboard?: boolean;
-    /**
-     * 黑板变量覆盖（用于运行时动态设置初始值）
-     */
-    blackboardOverrides?: Record<string, any>;
-    /**
-     * 是否作为子树实例化
-     * 如果为 true，根节点不会添加 RootNode 组件，避免触发预加载逻辑
-     */
-    asSubTree?: boolean;
-}
-/**
- * 行为树资产加载器
- *
- * 将BehaviorTreeAsset实例化为可运行的Entity树
- */
-declare class BehaviorTreeAssetLoader {
-    /**
-     * 从资产实例化行为树
-     *
-     * @param asset 行为树资产
-     * @param scene 目标场景
-     * @param options 实例化选项
-     * @returns 根实体
-     *
-     * @example
-     * ```typescript
-     * const asset = await loadAssetFromFile('enemy-ai.btree.bin');
-     * const aiRoot = BehaviorTreeAssetLoader.instantiate(asset, scene);
-     * BehaviorTreeStarter.start(aiRoot);
-     * ```
-     */
-    static instantiate(asset: BehaviorTreeAsset, scene: IScene, options?: InstantiateOptions): Entity;
-    /**
-     * 递归创建实体树
-     */
-    private static createEntityTree;
-    /**
-     * 添加节点特定组件
-     * @param skipRootNode 是否跳过添加 RootNode 组件（用于子树）
-     */
-    private static addNodeComponents;
-    /**
-     * 添加组合节点组件
-     */
-    private static addCompositeComponent;
-    /**
-     * 添加装饰器组件
-     */
-    private static addDecoratorComponent;
-    /**
-     * 添加动作组件
-     */
-    private static addActionComponent;
-    /**
-     * 添加条件组件
-     */
-    private static addConditionComponent;
-    /**
-     * 设置黑板
-     */
-    private static setupBlackboard;
-    /**
-     * 设置属性绑定
-     */
-    private static setupPropertyBindings;
-}
-
-/**
- * 编辑器节点格式
- */
-interface EditorNode {
-    id: string;
-    template: {
-        displayName: string;
-        category: string;
-        type: NodeType;
-        [key: string]: any;
-    };
-    data: Record<string, any>;
-    position: {
-        x: number;
-        y: number;
-    };
-    children: string[];
-}
-/**
- * 编辑器连接格式
- */
-interface EditorConnection {
-    from: string;
-    to: string;
-    fromProperty?: string;
-    toProperty?: string;
-    connectionType: 'node' | 'property';
-}
-/**
- * 编辑器格式
- */
-interface EditorFormat {
-    version?: string;
-    metadata?: {
-        name: string;
-        description?: string;
-        createdAt?: string;
-        modifiedAt?: string;
-    };
-    nodes: EditorNode[];
-    connections: EditorConnection[];
-    blackboard: Record<string, any>;
-    canvasState?: {
-        offset: {
-            x: number;
-            y: number;
-        };
-        scale: number;
-    };
-}
-/**
- * 编辑器格式转换器
- *
- * 将编辑器格式转换为运行时资产格式
- */
-declare class EditorFormatConverter {
-    /**
-     * 转换编辑器格式为资产格式
-     *
-     * @param editorData 编辑器数据
-     * @param metadata 可选的元数据覆盖
-     * @returns 行为树资产
-     */
-    static toAsset(editorData: EditorFormat, metadata?: Partial<AssetMetadata>): BehaviorTreeAsset;
-    /**
-     * 查找根节点
-     */
-    private static findRootNode;
-    /**
-     * 转换节点列表
-     */
-    private static convertNodes;
-    /**
-     * 转换单个节点
-     */
-    private static convertNode;
-    /**
-     * 转换黑板变量
-     */
-    private static convertBlackboard;
-    /**
-     * 推断黑板变量类型
-     */
-    private static inferBlackboardType;
-    /**
-     * 转换属性绑定
-     */
-    private static convertPropertyBindings;
-    /**
-     * 从资产格式转换回编辑器格式（用于加载）
-     *
-     * @param asset 行为树资产
-     * @returns 编辑器格式数据
-     */
-    static fromAsset(asset: BehaviorTreeAsset): EditorFormat;
-    /**
-     * 从资产格式转换节点
-     */
-    private static convertNodesFromAsset;
-    /**
-     * 推断节点分类
-     */
-    private static inferCategory;
-    /**
-     * 将属性绑定转换为连接
-     */
-    private static convertPropertyBindingsToConnections;
-    /**
-     * 根据children关系构建节点连接
-     */
-    private static buildNodeConnections;
-}
-
-/**
- * 行为树节点元数据
- */
-interface BehaviorNodeMetadata {
-    displayName: string;
-    category: string;
-    type: NodeType;
-    icon?: string;
-    description: string;
-    color?: string;
-    className?: string;
-    /**
-     * 是否需要子节点
-     * - true: 节点需要子节点（如 SequenceNode、DecoratorNode）
-     * - false: 节点不需要子节点（如 ActionNode、SubTreeNode）
-     * - undefined: 根据节点类型自动判断
-     */
-    requiresChildren?: boolean;
-}
-/**
- * 节点类注册表
- */
-declare class NodeClassRegistry {
-    private static nodeClasses;
-    static registerNodeClass(constructor: any, metadata: BehaviorNodeMetadata): void;
-    static getAllNodeClasses(): Array<{
-        metadata: BehaviorNodeMetadata;
-        constructor: any;
-    }>;
-    static getNodeClass(category: string, displayName: string): any;
-    static clear(): void;
-}
-/**
- * 行为树节点装饰器
- *
- * 用于标注一个类是可在编辑器中使用的行为树节点
- *
- * @example
- * ```typescript
- * @BehaviorNode({
- *   displayName: '等待',
- *   category: '动作',
- *   type: NodeType.Action,
- *   icon: 'Clock',
- *   description: '等待指定时间',
- *   color: '#9E9E9E'
- * })
- * class WaitNode extends Component {
- *   @BehaviorProperty({
- *     label: '持续时间',
- *     type: 'number',
- *     min: 0,
- *     step: 0.1,
- *     description: '等待时间（秒）'
- *   })
- *   duration: number = 1.0;
- * }
- * ```
- */
-declare function BehaviorNode(metadata: BehaviorNodeMetadata): <T extends {
-    new (...args: any[]): any;
-}>(constructor: T) => T;
-/**
- * 行为树属性装饰器
- *
- * 用于标注节点的可配置属性，这些属性会在编辑器中显示
- *
- * @example
- * ```typescript
- * @BehaviorNode({ ... })
- * class MyNode {
- *   @BehaviorProperty({
- *     label: '速度',
- *     type: 'number',
- *     min: 0,
- *     max: 100,
- *     description: '移动速度'
- *   })
- *   speed: number = 10;
- * }
- * ```
- */
-declare function BehaviorProperty(config: Omit<PropertyDefinition, 'name' | 'defaultValue'>): (target: any, propertyKey: string) => void;
-/**
- * @deprecated 使用 BehaviorProperty 代替
- */
-declare const NodeProperty: typeof BehaviorProperty;
-/**
- * 获取所有注册的节点模板
- */
-declare function getRegisteredNodeTemplates(): NodeTemplate[];
-/**
- * 清空所有注册的节点类
- */
-declare function clearRegisteredNodes(): void;
-
-export { AbortType, ActiveNode, AlwaysFailNode, AlwaysSucceedNode, AssetLoadingManager, AssetType, BehaviorNode, BehaviorProperty, BehaviorTreeAssetLoader, BehaviorTreeAssetMetadata, BehaviorTreeAssetSerializer, BehaviorTreeAssetValidator, BehaviorTreeBuilder, BehaviorTreeNode, BehaviorTreePersistence, BehaviorTreePlugin, BehaviorTreeStarter, BlackboardCompareCondition, BlackboardComponent, BlackboardExistsCondition, BlackboardValueType, CircularDependencyError, CompareOperator, CompositeExecutionSystem, CompositeNodeComponent, CompositeType, ConditionalNode, CooldownNode, DecoratorExecutionSystem, DecoratorNodeComponent, DecoratorType, EditorFormatConverter, EntityDestroyedError, ExecuteAction, ExecuteCondition, FileSystemAssetLoader, GlobalBlackboardService, InverterNode, LeafExecutionSystem, LoadingState, LogAction, LogOutput, ModifyBlackboardValueAction, ModifyOperation, NodeClassRegistry, NodeProperty, NodeTemplates, NodeType, ParallelNode, ParallelSelectorNode, PropertyBindings, RandomProbabilityCondition, RandomSelectorNode, RandomSequenceNode, RepeaterNode, RootExecutionSystem, RootNode, SelectorNode, SequenceNode, SetBlackboardValueAction, SubTreeExecutionSystem, SubTreeNode, TaskStatus, TimeoutError, TimeoutNode, UntilFailNode, UntilSuccessNode, WaitAction, WorkspaceService, clearRegisteredNodes, getRegisteredNodeTemplates };
-export type { AssetMetadata, AssetRegistry, AssetValidationResult, BehaviorNodeMetadata, BehaviorTreeAsset, BehaviorTreeNodeData, BlackboardVariable, BlackboardVariableDefinition, CustomActionFunction, CustomConditionFunction, DeserializationOptions, EditorConnection, EditorFormat, EditorNode, FileSystemAssetLoaderConfig, GlobalBlackboardConfig, IAssetLoader, InstantiateOptions, LoadingOptions, LoadingProgress, LoadingTask, LoadingTaskHandle, NodeDataJSON, NodeTemplate, PropertyBinding, PropertyDefinition, SerializationFormat, SerializationOptions, WorkspaceConfig };