@esengine/ai/index.d.ts

用于Laya、Cocos Creator等JavaScript游戏引擎的高性能AI系统库：行为树、实用AI和有限状态机

/**
 * @esengine/ai v2.0.24
 * TypeScript definitions
 */
/**
 * 数组扩展器和高效数据结构工具
 * 提供栈、队列等数据结构的高效实现
 */
declare class ArrayExt {
    /**
     * 将数组打乱顺序（Fisher-Yates洗牌算法）
     * 时间复杂度: O(n)，空间复杂度: O(1)
     *
     * @param list 要打乱的数组
     * @throws {Error} 当数组为null或undefined时抛出错误
     */
    static shuffle<T>(list: Array<T>): void;
    /**
     * 取出数组第一个项（不移除）
     * @param list 目标数组
     * @returns 第一个元素
     * @throws {Error} 当数组为空时抛出错误
     */
    static peek<T>(list: Array<T>): T;
    /**
     * 向数组头部添加一个项
     * @param list 目标数组
     * @param item 要添加的项
     */
    static unshift<T>(list: Array<T>, item: T): void;
    /**
     * 移除数组第一个项并返回它
     * @param list 目标数组
     * @returns 移除的元素，如果数组为空则返回undefined
     */
    static pop<T>(list: Array<T>): T | undefined;
    /**
     * 向数组尾部添加一个项
     * @param list 目标数组
     * @param item 要添加的项
     */
    static append<T>(list: Array<T>, item: T): void;
    /**
     * 移除数组最后一个项并返回它
     * @param list 目标数组
     * @returns 移除的元素，如果数组为空则返回undefined
     */
    static removeLast<T>(list: Array<T>): T | undefined;
    /**
     * 检查数组是否为空
     * @param list 目标数组
     * @returns 是否为空
     */
    static isEmpty<T>(list: Array<T>): boolean;
    /**
     * 获取数组大小
     * @param list 目标数组
     * @returns 数组长度
     */
    static size<T>(list: Array<T>): number;
    /**
     * 清空数组
     * @param list 目标数组
     */
    static clear<T>(list: Array<T>): void;
}
/**
 * 高效的双端队列实现
 * 使用环形缓冲区，避免数组头部插入的性能问题
 *
 * @template T 队列中元素的类型
 *
 * @example
 * ```typescript
 * const deque = new Deque<number>(32);
 * deque.push(1);
 * deque.unshift(0);
 * console.log(deque.peekFirst()); // 0
 * console.log(deque.peekLast());  // 1
 * ```
 */
declare class Deque<T> {
    private _buffer;
    private _head;
    private _tail;
    private _size;
    private _capacity;
    /**
     * 创建双端队列
     * @param initialCapacity 初始容量，必须大于0，默认16
     */
    constructor(initialCapacity?: number);
    /**
     * 向队列头部添加元素
     * @param item 要添加的元素
     */
    unshift(item: T): void;
    /**
     * 向队列尾部添加元素
     * @param item 要添加的元素
     */
    push(item: T): void;
    /**
     * 从队列头部移除元素
     * @returns 移除的元素，如果队列为空则返回undefined
     */
    shift(): T | undefined;
    /**
     * 从队列尾部移除元素
     * @returns 移除的元素，如果队列为空则返回undefined
     */
    pop(): T | undefined;
    /**
     * 查看队列头部元素（不移除）
     * @returns 头部元素，如果队列为空则返回undefined
     */
    peekFirst(): T | undefined;
    /**
     * 查看队列尾部元素（不移除）
     * @returns 尾部元素，如果队列为空则返回undefined
     */
    peekLast(): T | undefined;
    /**
     * 获取队列大小
     */
    get size(): number;
    /**
     * 检查队列是否为空
     */
    get isEmpty(): boolean;
    /**
     * 清空队列
     */
    clear(): void;
    /**
     * 扩容队列（内部使用）
     * 当队列满时自动调用，容量翻倍
     */
    private _resize;
    /**
     * 将队列转换为数组
     * @returns 包含队列所有元素的数组（从头到尾的顺序）
     */
    toArray(): T[];
}

/**
 * 高性能伪随机数生成器
 * 使用xorshift128算法，比原生Math.random()更快且质量更好
 *
 * @example
 * ```typescript
 * // 设置种子（可选，默认使用当前时间）
 * Random.setSeed(12345);
 *
 * // 生成0-1之间的随机数
 * const value = Random.value();
 *
 * // 生成指定范围的随机数
 * const rangeValue = Random.range(10, 20);
 *
 * // 生成随机整数
 * const intValue = Random.integer(1, 100);
 *
 * // 随机布尔值
 * const bool = Random.boolean();
 *
 * // 带概率的布尔值
 * const probBool = Random.chance(0.7); // 70%概率返回true
 * ```
 */
declare class Random {
    private static _x;
    private static _y;
    private static _z;
    private static _w;
    private static _initialized;
    /**
     * 设置随机数种子
     * @param seed 种子值，如果不提供则使用当前时间
     */
    static setSeed(seed?: number): void;
    /**
     * 生成下一个32位无符号整数（内部使用）
     * 使用xorshift128算法
     */
    private static next;
    /**
     * 生成0到1之间的随机浮点数（不包括1）
     * @returns 0 <= value < 1的随机数
     */
    static value(): number;
    /**
     * 生成指定范围内的随机浮点数
     * @param min 最小值（包含）
     * @param max 最大值（不包含）
     * @returns min <= value < max的随机数
     */
    static range(min?: number, max?: number): number;
    /**
     * 生成指定范围内的随机整数
     * @param min 最小值（包含）
     * @param max 最大值（包含）
     * @returns min <= value <= max的随机整数
     */
    static integer(min: number, max: number): number;
    /**
     * 生成随机布尔值
     * @returns 随机的true或false
     */
    static boolean(): boolean;
    /**
     * 根据概率生成布尔值
     * @param probability 返回true的概率（0-1之间）
     * @returns 根据概率返回的布尔值
     */
    static chance(probability: number): boolean;
    /**
     * 从数组中随机选择一个元素
     * @param array 要选择的数组
     * @returns 随机选中的元素
     */
    static choice<T>(array: T[]): T;
    /**
     * 从数组中随机选择多个不重复的元素
     * @param array 要选择的数组
     * @param count 选择的数量
     * @returns 随机选中的元素数组
     */
    static sample<T>(array: T[], count: number): T[];
    /**
     * 生成符合正态分布的随机数（Box-Muller变换）
     * @param mean 均值
     * @param standardDeviation 标准差
     * @returns 符合正态分布的随机数
     */
    static gaussian(mean?: number, standardDeviation?: number): number;
    /**
     * 获取当前随机数生成器的状态（用于保存/恢复）
     * @returns 生成器状态对象
     */
    static getState(): {
        x: number;
        y: number;
        z: number;
        w: number;
    };
    /**
     * 恢复随机数生成器的状态
     * @param state 要恢复的状态对象
     */
    static setState(state: {
        x: number;
        y: number;
        z: number;
        w: number;
    }): void;
}

/**
 * 高性能断言工具类
 *
 * @description
 * 提供类型安全的断言方法，支持开发和生产环境的不同行为。
 * 在生产环境中可以禁用断言以提高性能。
 *
 * @example
 * ```typescript
 * // 基本断言
 * Assert.isTrue(player.health > 0, '玩家血量必须大于0');
 * Assert.isNotNull(gameObject, '游戏对象不能为空');
 *
 * // 类型安全的断言
 * const value: unknown = getData();
 * Assert.isNumber(value, '数据必须是数字');
 * // 现在 value 的类型被缩窄为 number
 *
 * // 配置断言行为
 * Assert.setEnabled(false); // 在生产环境中禁用
 * ```
 */
declare class Assert {
    /** 是否启用断言检查 */
    private static _enabled;
    /** 是否在断言失败时抛出异常而不是仅记录 */
    private static _throwOnFailure;
    /**
     * 设置是否启用断言
     * @param enabled 是否启用
     */
    static setEnabled(enabled: boolean): void;
    /**
     * 设置断言失败时的行为
     * @param throwOnFailure 是否抛出异常，false则仅记录到控制台
     */
    static setThrowOnFailure(throwOnFailure: boolean): void;
    /**
     * 断言失败处理
     * @param message 错误消息
     * @param args 附加参数
     */
    static fail(message?: string, ...args: any[]): never;
    /**
     * 断言条件为真
     * @param condition 要检查的条件
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isTrue(condition: boolean, message?: string, ...args: any[]): asserts condition;
    /**
     * 断言条件为假
     * @param condition 要检查的条件
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isFalse(condition: boolean, message?: string, ...args: any[]): asserts condition is false;
    /**
     * 断言对象不为null或undefined
     * @param obj 要检查的对象
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isNotNull<T>(obj: T | null | undefined, message?: string, ...args: any[]): asserts obj is T;
    /**
     * 断言对象为null或undefined
     * @param obj 要检查的对象
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isNull(obj: any, message?: string, ...args: any[]): asserts obj is null | undefined;
    /**
     * 断言值为数字类型
     * @param value 要检查的值
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isNumber(value: unknown, message?: string, ...args: any[]): asserts value is number;
    /**
     * 断言值为字符串类型
     * @param value 要检查的值
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isString(value: unknown, message?: string, ...args: any[]): asserts value is string;
    /**
     * 断言值为布尔类型
     * @param value 要检查的值
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isBoolean(value: unknown, message?: string, ...args: any[]): asserts value is boolean;
    /**
     * 断言值为函数类型
     * @param value 要检查的值
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isFunction(value: unknown, message?: string, ...args: any[]): asserts value is Function;
    /**
     * 断言值为对象类型（非null）
     * @param value 要检查的值
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isObject(value: unknown, message?: string, ...args: any[]): asserts value is object;
    /**
     * 断言数组不为空
     * @param array 要检查的数组
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isNotEmpty<T>(array: T[], message?: string, ...args: any[]): asserts array is [T, ...T[]];
    /**
     * 断言字符串不为空
     * @param str 要检查的字符串
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isNotEmptyString(str: string | null | undefined, message?: string, ...args: any[]): asserts str is string;
    /**
     * 断言数值在指定范围内
     * @param value 要检查的数值
     * @param min 最小值（包含）
     * @param max 最大值（包含）
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static inRange(value: number, min: number, max: number, message?: string, ...args: any[]): void;
    /**
     * 断言值是指定类型的实例
     * @param value 要检查的值
     * @param constructor 构造函数
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static isInstanceOf<T>(value: unknown, constructor: new (...args: any[]) => T, message?: string, ...args: any[]): asserts value is T;
    /**
     * 断言数组包含指定元素
     * @param array 要检查的数组
     * @param element 要查找的元素
     * @param message 失败时的错误消息
     * @param args 附加参数
     */
    static contains<T>(array: T[], element: T, message?: string, ...args: any[]): void;
    /**
     * 获取当前断言配置
     * @returns 配置对象
     */
    static getConfig(): {
        enabled: boolean;
        throwOnFailure: boolean;
    };
}

/**
 * 日志级别枚举
 */
declare enum LogLevel {
    /** 调试信息 */
    Debug = 0,
    /** 一般信息 */
    Info = 1,
    /** 警告信息 */
    Warn = 2,
    /** 错误信息 */
    Error = 3,
    /** 关闭日志 */
    None = 4
}
/**
 * 日志配置接口
 */
interface LoggerConfig {
    /** 最小日志级别 */
    minLevel: LogLevel;
    /** 是否启用时间戳 */
    enableTimestamp: boolean;
    /** 是否启用堆栈跟踪（仅错误级别） */
    enableStackTrace: boolean;
    /** 是否启用性能模式（减少字符串格式化） */
    performanceMode: boolean;
    /** 自定义前缀 */
    prefix?: string;
    /** 是否启用批量模式 */
    batchMode?: boolean;
    /** 批量大小 */
    batchSize?: number;
    /** 批量刷新间隔（毫秒） */
    batchFlushInterval?: number;
}
/**
 * 高性能日志系统
 *
 * @description
 * 提供分级日志记录功能，支持性能优化模式。
 * 在性能模式下，会跳过不必要的字符串格式化和时间戳计算。
 * 支持批量输出和延迟日志记录。
 *
 * @example
 * ```typescript
 * // 基本使用
 * Logger.info('游戏开始');
 * Logger.warn('玩家血量低', { health: 10 });
 * Logger.error('网络连接失败', error);
 *
 * // 配置日志系统
 * Logger.configure({
 *   minLevel: LogLevel.Warn,
 *   enableTimestamp: true,
 *   performanceMode: false,
 *   batchMode: true,
 *   batchSize: 50
 * });
 *
 * // 性能敏感的代码中
 * Logger.setPerformanceMode(true);
 * ```
 */
declare class Logger {
    private static _config;
    /** 批量日志缓冲区 */
    private static _logBuffer;
    /** 批量模式配置 */
    private static _batchConfig;
    /** 性能模式下的简化日志函数 */
    private static _fastLog;
    /** 日志级别名称映射 */
    private static readonly _levelNames;
    /** 日志级别样式映射（用于浏览器控制台） */
    private static readonly _levelStyles;
    /**
     * 配置日志系统
     * @param config 日志配置
     */
    static configure(config: Partial<LoggerConfig>): void;
    /**
     * 初始化性能模式
     */
    private static _initializePerformanceMode;
    /**
     * 设置最小日志级别
     * @param level 最小日志级别
     */
    static setMinLevel(level: LogLevel): void;
    /**
     * 设置性能模式
     * @param enabled 是否启用性能模式
     */
    static setPerformanceMode(enabled: boolean): void;
    /**
     * 启用批量模式
     * @param enabled 是否启用
     * @param maxSize 批量大小
     * @param flushInterval 刷新间隔（毫秒）
     */
    static setBatchMode(enabled: boolean, maxSize?: number, flushInterval?: number): void;
    /**
     * 记录调试信息
     * @param message 消息
     * @param data 附加数据
     */
    static debug(message: string, data?: any): void;
    /**
     * 记录一般信息
     * @param message 消息
     * @param data 附加数据
     */
    static info(message: string, data?: any): void;
    /**
     * 记录警告信息
     * @param message 消息
     * @param data 附加数据
     */
    static warn(message: string, data?: any): void;
    /**
     * 记录错误信息
     * @param message 消息
     * @param error 错误对象或附加数据
     */
    static error(message: string, error?: any): void;
    /**
     * 内部日志记录方法
     * @param level 日志级别
     * @param message 消息
     * @param data 附加数据
     */
    private static _log;
    /**
     * 添加日志到批量缓冲区
     */
    private static _addToBatch;
    /**
     * 刷新批量日志
     */
    static flushLogs(): void;
    /**
     * 性能模式输出日志条目
     */
    private static _performanceLogEntry;
    /**
     * 标准模式输出日志条目
     */
    private static _standardLogEntry;
    /**
     * 格式化时间戳
     */
    private static _formatTimestamp;
    /**
     * 性能模式日志输出
     * @param level 日志级别
     * @param message 消息
     * @param data 附加数据
     */
    private static _performanceLog;
    /**
     * 标准模式日志输出
     * @param level 日志级别
     * @param message 消息
     * @param data 附加数据
     */
    private static _standardLog;
    /**
     * 获取时间戳字符串
     * @returns 格式化的时间戳
     */
    private static _getTimestamp;
    /**
     * 根据日志级别获取对应的console方法
     * @param level 日志级别
     * @returns console方法
     */
    private static _getConsoleMethod;
    /**
     * 获取当前配置
     * @returns 当前日志配置的副本
     */
    static getConfig(): Readonly<LoggerConfig>;
    /**
     * 创建带前缀的日志器
     * @param prefix 前缀
     * @returns 新的日志器实例
     */
    static createPrefixed(prefix: string): PrefixedLogger;
}
/**
 * 带前缀的日志器
 * 用于为特定模块或组件创建专用的日志器
 */
declare class PrefixedLogger {
    private readonly _prefix;
    constructor(_prefix: string);
    debug(message: string, data?: any): void;
    info(message: string, data?: any): void;
    warn(message: string, data?: any): void;
    error(message: string, error?: any): void;
}

/**
 * 时间管理器配置选项
 */
interface TimeManagerConfig {
    /** 最大帧间时间差（秒） */
    maxDeltaTime?: number;
    /** 时间缩放比例 */
    timeScale?: number;
    /** 是否使用高精度时间 */
    useHighPrecision?: boolean;
}
/**
 * 全局时间管理器
 *
 * @description
 * 提供高性能的时间管理功能，减少重复的时间计算开销。
 * 使用时间池化技术，在每帧开始时统一计算时间，避免多次调用performance.now()。
 *
 * @example
 * ```typescript
 * // 在游戏主循环开始时更新时间
 * TimeManager.updateFrame();
 *
 * // 获取当前时间（无额外计算开销）
 * const currentTime = TimeManager.getCurrentTime();
 * const deltaTime = TimeManager.getDeltaTime();
 *
 * // 配置时间管理器
 * TimeManager.configure({
 *   maxDeltaTime: 0.1,
 *   timeScale: 1.0,
 *   useHighPrecision: true
 * });
 * ```
 */
declare class TimeManager {
    /** 当前时间（秒） */
    private static _currentTime;
    /** 上一帧时间（秒） */
    private static _lastTime;
    /** 帧间时间差（秒） */
    private static _deltaTime;
    /** 未缩放的帧间时间差（秒） */
    private static _unscaledDeltaTime;
    /** 时间缩放比例 */
    private static _timeScale;
    /** 最大允许的帧间时间差（防止时间跳跃） */
    private static _maxDeltaTime;
    /** 是否使用高精度时间 */
    private static _useHighPrecision;
    /** 是否已初始化 */
    private static _initialized;
    /** 帧计数器 */
    private static _frameCount;
    /** 启动时间 */
    private static _startTime;
    /** 时间更新回调列表 */
    private static _updateCallbacks;
    /**
     * 配置时间管理器
     * @param config 配置选项
     */
    static configure(config: TimeManagerConfig): void;
    /**
     * 初始化时间管理器
     */
    static initialize(): void;
    /**
     * 更新帧时间（应在每帧开始时调用）
     * @param externalDeltaTime 可选的外部提供的时间差
     */
    static updateFrame(externalDeltaTime?: number): void;
    /**
     * 获取系统时间（毫秒）
     */
    private static _getSystemTime;
    /**
     * 触发时间更新回调
     */
    private static _triggerUpdateCallbacks;
    /**
     * 获取当前时间（秒）
     * @returns 从初始化开始的累计时间
     */
    static getCurrentTime(): number;
    /**
     * 获取帧间时间差（秒）
     * @returns 当前帧与上一帧的时间差
     */
    static getDeltaTime(): number;
    /**
     * 获取未缩放的帧间时间差（秒）
     * @returns 未应用时间缩放的帧间时间差
     */
    static getUnscaledDeltaTime(): number;
    /**
     * 获取时间缩放比例
     */
    static getTimeScale(): number;
    /**
     * 设置时间缩放比例
     * @param scale 缩放比例，0表示暂停，1表示正常速度
     */
    static setTimeScale(scale: number): void;
    /**
     * 获取帧计数
     */
    static getFrameCount(): number;
    /**
     * 获取平均帧率
     */
    static getAverageFPS(): number;
    /**
     * 获取当前帧率
     */
    static getCurrentFPS(): number;
    /**
     * 添加时间更新回调
     * @param callback 回调函数
     */
    static addUpdateCallback(callback: (deltaTime: number) => void): void;
    /**
     * 移除时间更新回调
     * @param callback 要移除的回调函数
     */
    static removeUpdateCallback(callback: (deltaTime: number) => void): void;
    /**
     * 清除所有时间更新回调
     */
    static clearUpdateCallbacks(): void;
    /**
     * 重置时间管理器
     */
    static reset(): void;
    /**
     * 获取时间管理器统计信息
     */
    static getStats(): {
        currentTime: number;
        deltaTime: number;
        unscaledDeltaTime: number;
        timeScale: number;
        frameCount: number;
        averageFPS: number;
        currentFPS: number;
        maxDeltaTime: number;
        useHighPrecision: boolean;
    };
}

/**
* 错误处理级别枚举
*/
declare enum ErrorLevel {
    /** 开发模式 - 严格检查，抛出所有错误 */
    Development = 0,
    /** 测试模式 - 记录错误但不中断执行 */
    Testing = 1,
    /** 生产模式 - 最小化错误处理，优先性能 */
    Production = 2,
    /** 静默模式 - 完全禁用错误处理 */
    Silent = 3
}
/**
 * 错误处理配置
 */
interface ErrorHandlerConfig {
    /** 错误处理级别 */
    level: ErrorLevel;
    /** 是否启用断言 */
    enableAssertions: boolean;
    /** 是否启用类型检查 */
    enableTypeChecking: boolean;
    /** 是否启用性能监控 */
    enablePerformanceMonitoring: boolean;
    /** 错误回调函数 */
    onError?: (error: Error, context?: any) => void;
    /** 警告回调函数 */
    onWarning?: (message: string, context?: any) => void;
}
/**
 * 性能监控数据
 */
interface PerformanceData {
    functionName: string;
    executionTime: number;
    callCount: number;
    averageTime: number;
    maxTime: number;
    minTime: number;
}
/**
 * 高性能错误处理系统
 *
 * @description
 * 提供可配置的错误处理策略，支持开发和生产环境的不同行为。
 * 在生产环境中可以完全禁用错误检查以提高性能。
 *
 * @example
 * ```typescript
 * // 配置错误处理器
 * ErrorHandler.configure({
 *   level: ErrorLevel.Development,
 *   enableAssertions: true,
 *   enableTypeChecking: true
 * });
 *
 * // 使用断言
 * ErrorHandler.assert(player.health > 0, '玩家血量必须大于0');
 *
 * // 类型检查
 * ErrorHandler.checkType(value, 'number', '值必须是数字');
 *
 * // 性能监控
 * const result = ErrorHandler.monitor('expensiveFunction', () => {
 *   return expensiveOperation();
 * });
 * ```
 */
declare class ErrorHandler {
    private static _config;
    /** 性能监控数据 */
    private static _performanceData;
    /** 错误统计 */
    private static _errorStats;
    /**
     * 配置错误处理器
     * @param config 配置选项
     */
    static configure(config: Partial<ErrorHandlerConfig>): void;
    /**
     * 设置错误处理级别
     * @param level 错误处理级别
     */
    static setLevel(level: ErrorLevel): void;
    /**
     * 断言检查
     * @param condition 条件
     * @param message 错误消息
     * @param context 上下文信息
     */
    static assert(condition: boolean, message: string, context?: any): asserts condition;
    /**
     * 类型检查
     * @param value 要检查的值
     * @param expectedType 期望的类型
     * @param message 错误消息
     * @param context 上下文信息
     */
    static checkType(value: any, expectedType: string, message?: string, context?: any): void;
    /**
     * 非空检查
     * @param value 要检查的值
     * @param message 错误消息
     * @param context 上下文信息
     */
    static checkNotNull<T>(value: T | null | undefined, message?: string, context?: any): asserts value is T;
    /**
     * 范围检查
     * @param value 要检查的值
     * @param min 最小值
     * @param max 最大值
     * @param message 错误消息
     * @param context 上下文信息
     */
    static checkRange(value: number, min: number, max: number, message?: string, context?: any): void;
    /**
     * 数组边界检查
     * @param array 数组
     * @param index 索引
     * @param message 错误消息
     * @param context 上下文信息
     */
    static checkArrayBounds<T>(array: T[], index: number, message?: string, context?: any): void;
    /**
     * 性能监控装饰器
     * @param name 函数名称
     * @param fn 要监控的函数
     * @returns 函数执行结果
     */
    static monitor<T>(name: string, fn: () => T): T;
    /**
     * 异步性能监控
     * @param name 函数名称
     * @param fn 要监控的异步函数
     * @returns Promise结果
     */
    static monitorAsync<T>(name: string, fn: () => Promise<T>): Promise<T>;
    /**
     * 记录性能数据
     */
    private static _recordPerformance;
    /**
     * 处理错误
     */
    private static _handleError;
    /**
     * 发出警告
     * @param message 警告消息
     * @param context 上下文信息
     */
    static warn(message: string, context?: any): void;
    /**
     * 获取性能统计信息
     */
    static getPerformanceStats(): ReadonlyMap<string, Readonly<PerformanceData>>;
    /**
     * 获取错误统计信息
     */
    static getErrorStats(): Readonly<typeof ErrorHandler._errorStats>;
    /**
     * 重置统计信息
     */
    static resetStats(): void;
    /**
     * 获取当前配置
     */
    static getConfig(): Readonly<ErrorHandlerConfig>;
    /**
     * 创建带错误处理的函数包装器
     * @param fn 原函数
     * @param name 函数名称
     * @param enableMonitoring 是否启用性能监控
     * @returns 包装后的函数
     */
    static wrap<TArgs extends any[], TReturn>(fn: (...args: TArgs) => TReturn, name: string, enableMonitoring?: boolean): (...args: TArgs) => TReturn;
}
/**
 * 错误处理装饰器工厂
 * @param options 装饰器选项
 */
declare function errorHandler(options?: {
    name?: string;
    enableMonitoring?: boolean;
    enableTypeChecking?: boolean;
}): <T extends (...args: any[]) => any>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;

/**
 * 事件管理器配置
 */
interface EventManagerConfig {
    /** 是否启用自动清理 */
    enableAutoCleanup: boolean;
    /** 清理间隔（毫秒） */
    cleanupInterval: number;
    /** 最大监听器数量 */
    maxListeners: number;
    /** 监听器过期时间（毫秒） */
    listenerExpirationTime: number;
    /** 是否启用性能监控 */
    enablePerformanceMonitoring: boolean;
}
/**
 * 事件统计信息
 */
interface EventStats {
    /** 总监听器数量 */
    totalListeners: number;
    /** 活跃监听器数量 */
    activeListeners: number;
    /** 总事件触发次数 */
    totalEvents: number;
    /** 平均事件处理时间 */
    averageEventTime: number;
    /** 最后清理时间 */
    lastCleanupTime: number;
}
/**
 * 高性能事件管理器
 *
 * @description
 * 提供带自动清理机制的事件管理系统，防止内存泄漏。
 * 支持弱引用、优先级、一次性监听器等高级功能。
 *
 * @example
 * ```typescript
 * const eventManager = new EventManager({
 *   enableAutoCleanup: true,
 *   cleanupInterval: 30000, // 30秒清理一次
 *   maxListeners: 1000
 * });
 *
 * // 添加监听器
 * const listenerId = eventManager.on('playerDeath', (data) => {
 *   console.log('玩家死亡:', data);
 * });
 *
 * // 添加弱引用监听器（自动清理）
 * eventManager.onWeak('gameUpdate', callback, gameObject);
 *
 * // 触发事件
 * eventManager.emit('playerDeath', { playerId: 123 });
 *
 * // 移除监听器
 * eventManager.off('playerDeath', listenerId);
 * ```
 */
declare class EventManager {
    private readonly _listeners;
    private readonly _config;
    private _stats;
    private _cleanupTimer;
    private _nextListenerId;
    /**
     * 创建事件管理器
     * @param config 配置选项
     */
    constructor(config?: Partial<EventManagerConfig>);
    /**
     * 添加事件监听器
     * @param eventName 事件名称
     * @param callback 回调函数
     * @param options 监听器选项
     * @returns 监听器ID
     */
    on<T = any>(eventName: string, callback: (data: T) => void, options?: {
        once?: boolean;
        priority?: number;
        weak?: boolean;
        owner?: object;
    }): string;
    /**
     * 添加弱引用监听器（自动清理）
     * @param eventName 事件名称
     * @param callback 回调函数
     * @param owner 拥有者对象
     * @param options 其他选项
     * @returns 监听器ID
     */
    onWeak<T = any>(eventName: string, callback: (data: T) => void, owner: object, options?: {
        once?: boolean;
        priority?: number;
    }): string;
    /**
     * 添加一次性监听器
     * @param eventName 事件名称
     * @param callback 回调函数
     * @param options 其他选项
     * @returns 监听器ID
     */
    once<T = any>(eventName: string, callback: (data: T) => void, options?: {
        priority?: number;
        weak?: boolean;
        owner?: object;
    }): string;
    /**
     * 移除事件监听器
     * @param eventName 事件名称
     * @param listenerId 监听器ID
     * @returns 是否成功移除
     */
    off(eventName: string, listenerId: string): boolean;
    /**
     * 移除所有指定事件的监听器
     * @param eventName 事件名称
     * @returns 移除的监听器数量
     */
    offAll(eventName: string): number;
    /**
     * 移除拥有者的所有监听器
     * @param owner 拥有者对象
     * @returns 移除的监听器数量
     */
    offByOwner(owner: object): number;
    /**
     * 触发事件
     * @param eventName 事件名称
     * @param data 事件数据
     * @returns 成功调用的监听器数量
     */
    emit<T = any>(eventName: string, data?: T): number;
    /**
     * 检查是否有指定事件的监听器
     * @param eventName 事件名称
     * @returns 是否有监听器
     */
    hasListeners(eventName: string): boolean;
    /**
     * 获取指定事件的监听器数量
     * @param eventName 事件名称
     * @returns 监听器数量
     */
    getListenerCount(eventName: string): number;
    /**
     * 获取所有事件名称
     * @returns 事件名称数组
     */
    getEventNames(): string[];
    /**
     * 执行清理操作
     * @param force 是否强制清理所有监听器
     * @returns 清理的监听器数量
     */
    cleanup(force?: boolean): number;
    /**
     * 启动自动清理
     */
    private _startAutoCleanup;
    /**
     * 停止自动清理
     */
    private _stopAutoCleanup;
    /**
     * 执行清理操作
     */
    private _performCleanup;
    /**
     * 生成监听器ID
     */
    private _generateListenerId;
    /**
     * 更新活跃监听器数量
     */
    private _updateActiveListeners;
    /**
     * 更新平均事件处理时间
     */
    private _updateAverageEventTime;
    /**
     * 获取统计信息
     */
    getStats(): Readonly<EventStats>;
    /**
     * 重置统计信息
     */
    resetStats(): void;
    /**
     * 获取配置信息
     */
    getConfig(): Readonly<EventManagerConfig>;
    /**
     * 销毁事件管理器
     */
    destroy(): void;
}

/**
* 类型检查结果
*/
interface TypeCheckResult<T = any> {
    /** 是否通过检查 */
    success: boolean;
    /** 检查的值 */
    value: T;
    /** 错误信息 */
    error?: string;
    /** 期望的类型 */
    expectedType?: string;
    /** 实际的类型 */
    actualType?: string;
}
/**
 * 类型验证器接口
 */
interface TypeValidator<T> {
    /** 验证函数 */
    validate: (value: unknown) => value is T;
    /** 类型名称 */
    typeName: string;
    /** 错误消息模板 */
    errorMessage?: string;
}
/**
 * 复合类型验证器
 */
interface CompositeValidator<T> {
    /** 验证函数 */
    validate: (value: unknown) => TypeCheckResult<T>;
    /** 类型名称 */
    typeName: string;
}
/**
 * 高性能运行时类型检查工具
 *
 * @description
 * 提供全面的运行时类型检查和类型守卫功能，替代不安全的类型断言。
 * 支持基础类型、复合类型、自定义验证器等。
 *
 * @example
 * ```typescript
 * // 基础类型检查
 * if (TypeGuards.isString(value)) {
 *   // value 现在是 string 类型
 *   console.log(value.toUpperCase());
 * }
 *
 * // 复合类型检查
 * const result = TypeGuards.checkObject(data, {
 *   name: TypeGuards.validators.string,
 *   age: TypeGuards.validators.number,
 *   email: TypeGuards.validators.optional(TypeGuards.validators.string)
 * });
 *
 * // 数组类型检查
 * if (TypeGuards.isArrayOf(value, TypeGuards.isNumber)) {
 *   // value 现在是 number[] 类型
 *   const sum = value.reduce((a, b) => a + b, 0);
 * }
 *
 * // 自定义验证器
 * const isPositiveNumber = TypeGuards.createValidator<number>(
 *   (value): value is number => typeof value === 'number' && value > 0,
 *   'PositiveNumber'
 * );
 * ```
 */
declare class TypeGuards {
    /** 内置验证器 */
    static readonly validators: {
        /** 字符串验证器 */
        string: TypeValidator<string>;
        /** 数字验证器 */
        number: TypeValidator<number>;
        /** 布尔值验证器 */
        boolean: TypeValidator<boolean>;
        /** 函数验证器 */
        function: TypeValidator<Function>;
        /** 对象验证器 */
        object: TypeValidator<object>;
        /** 数组验证器 */
        array: TypeValidator<any[]>;
        /** 非空验证器 */
        notNull: TypeValidator<any>;
        /** 整数验证器 */
        integer: TypeValidator<number>;
        /** 正数验证器 */
        positiveNumber: TypeValidator<number>;
        /** 非负数验证器 */
        nonNegativeNumber: TypeValidator<number>;
        /** 非空字符串验证器 */
        nonEmptyString: TypeValidator<string>;
        /** 可选验证器工厂 */
        optional: <T>(validator: TypeValidator<T>) => TypeValidator<T | undefined>;
        /** 可空验证器工厂 */
        nullable: <T>(validator: TypeValidator<T>) => TypeValidator<T | null>;
        /** 联合类型验证器工厂 */
        union: <T extends readonly TypeValidator<any>[]>(...validators: T) => TypeValidator<T[number] extends TypeValidator<infer U> ? U : never>;
    };
    /**
     * 检查是否为字符串
     */
    static isString(value: unknown): value is string;
    /**
     * 检查是否为数字
     */
    static isNumber(value: unknown): value is number;
    /**
     * 检查是否为布尔值
     */
    static isBoolean(value: unknown): value is boolean;
    /**
     * 检查是否为函数
     */
    static isFunction(value: unknown): value is Function;
    /**
     * 检查是否为对象（非null）
     */
    static isObject(value: unknown): value is object;
    /**
     * 检查是否为数组
     */
    static isArray(value: unknown): value is any[];
    /**
     * 检查是否为null或undefined
     */
    static isNullish(value: unknown): value is null | undefined;
    /**
     * 检查是否不为null或undefined
     */
    static isNotNull<T>(value: T | null | undefined): value is T;
    /**
     * 检查是否为指定类型的数组
     */
    static isArrayOf<T>(value: unknown, itemGuard: (item: unknown) => item is T): value is T[];
    /**
     * 检查是否为字符串数组
     */
    static isStringArray(value: unknown): value is string[];
    /**
     * 检查是否为数字数组
     */
    static isNumberArray(value: unknown): value is number[];
    /**
     * 检查是否为指定类的实例
     */
    static isInstanceOf<T>(value: unknown, constructor: new (...args: any[]) => T): value is T;
    /**
     * 检查对象是否具有指定的属性
     */
    static hasProperty<K extends string>(value: unknown, property: K): value is Record<K, unknown>;
    /**
     * 检查对象是否具有指定类型的属性
     */
    static hasPropertyOfType<K extends string, T>(value: unknown, property: K, typeGuard: (value: unknown) => value is T): value is Record<K, T>;
    /**
     * 创建自定义验证器
     */
    static createValidator<T>(guard: (value: unknown) => value is T, typeName: string, errorMessage?: string): TypeValidator<T>;
    /**
     * 检查对象结构
     */
    static checkObject<T extends Record<string, any>>(value: unknown, schema: {
        [K in keyof T]: TypeValidator<T[K]>;
    }): TypeCheckResult<T>;
    /**
     * 安全类型转换
     */
    static safeCast<T>(value: unknown, validator: TypeValidator<T>): TypeCheckResult<T>;
    /**
     * 断言类型（开发模式下抛出错误）
     */
    static assertType<T>(value: unknown, validator: TypeValidator<T>, message?: string): asserts value is T;
    /**
     * 尝试类型转换
     */
    static tryConvert<T>(value: unknown, converter: (value: unknown) => T, validator: TypeValidator<T>): TypeCheckResult<T>;
    /**
     * 字符串转数字
     */
    static stringToNumber(value: unknown): TypeCheckResult<number>;
    /**
     * 任意值转字符串
     */
    static toString(value: unknown): TypeCheckResult<string>;
    /**
     * 任意值转布尔值
     */
    static toBoolean(value: unknown): TypeCheckResult<boolean>;
    /**
     * 检查数字是否在指定范围内
     */
    static isInRange(value: unknown, min: number, max: number, inclusive?: boolean): value is number;
    /**
     * 检查字符串长度是否在指定范围内
     */
    static isStringLengthInRange(value: unknown, minLength: number, maxLength: number): value is string;
    /**
     * 检查数组长度是否在指定范围内
     */
    static isArrayLengthInRange(value: unknown, minLength: number, maxLength: number): value is any[];
    /**
     * 检查字符串是否匹配正则表达式
     */
    static matchesPattern(value: unknown, pattern: RegExp): value is string;
    /**
     * 检查是否为有效的电子邮件地址
     */
    static isEmail(value: unknown): value is string;
    /**
     * 检查是否为有效的URL
     */
    static isUrl(value: unknown): value is string;
    /**
     * 检查是否为有效的UUID
     */
    static isUuid(value: unknown): value is string;
}

/**
 * 行为树节点的执行状态枚举
 *
 * @description 定义了行为树中每个节点可能的执行状态
 */
declare enum TaskStatus {
    /**
     * 无效状态 - 节点尚未执行或已被重置
     */
    Invalid = 0,
    /**
     * 成功状态 - 节点执行完成且成功
     */
    Success = 1,
    /**
     * 失败状态 - 节点执行完成但失败
     */
    Failure = 2,
    /**
     * 运行中状态 - 节点正在执行，需要在下一帧继续
     */
    Running = 3
}

/**
 * 行为树节点的抽象基类
 *
 * @description 所有行为树节点的基类，定义了节点的生命周期和基本行为
 * @template T 上下文对象类型，通常包含游戏状态、AI数据等
 *
 * @example
 * ```typescript
 * class CustomAction<GameContext> extends Behavior<GameContext> {
 *   update(context: GameContext): TaskStatus {
 *     // 执行自定义逻辑
 *     return TaskStatus.Success;
 *   }
 * }
 * ```
 */
declare abstract class Behavior<T> {
    /**
     * 当前节点的执行状态
     * @default TaskStatus.Invalid
     */
    status: TaskStatus;
    /**
     * 抽象方法：节点的核心执行逻辑
     *
     * @description 子类必须实现此方法来定义节点的具体行为
     * @param context 上下文对象，包含执行所需的数据
     * @returns 执行后的状态（Success、Failure或Running）
     */
    abstract update(context: T): TaskStatus;
    /**
     * 重置节点状态为无效
     *
     * @description 使该节点的状态无效，复合节点可以重写此方法来同时重置子节点
     */
    invalidate(): void;
    /**
     * 节点开始执行时的回调
     *
     * @description 在节点首次执行或状态从Invalid变为其他状态时调用
     * 用于初始化变量、重置状态等准备工作
     */
    onStart(): void;
    /**
     * 节点执行结束时的回调
     *
     * @description 当节点状态变为Success或Failure时调用
     * 用于清理资源、记录结果等收尾工作
     */
    onEnd(): void;
    /**
     * 节点执行的主要入口点
     *
     * @description 处理节点的完整执行流程，包括生命周期管理
     * 1. 如果状态为Invalid，调用onStart()
     * 2. 调用update()执行核心逻辑
     * 3. 如果状态不为Running，调用onEnd()
     *
     * @param context 执行上下文
     * @returns 执行后的状态
     */
    tick(context: T): TaskStatus;
}

/**
 * 黑板变量类型枚举
 */
declare enum BlackboardValueType {
    String = "string",
    Number = "number",
    Boolean = "boolean",
    Vector2 = "vector2",
    Vector3 = "vector3",
    Object = "object",
    Array = "array"
}
/**
 * 黑板变量定义接口
 */
interface BlackboardVariable {
    /** 变量名称 */
    name: string;
    /** 变量类型 */
    type: BlackboardValueType;
    /** 当前值 */
    value: any;
    /** 默认值 */
    defaultValue: any;
    /** 变量描述 */
    description?: string;
    /** 是否只读 */
    readonly?: boolean;
    /** 变量分组 */
    group?: string;
    /** 最小值（仅数字类型） */
    min?: number;
    /** 最大值（仅数字类型） */
    max?: number;
    /** 可选值列表 */
    options?: any[];
}
/**
 * 黑板监听器接口
 */
interface BlackboardListener {
    /** 变量名称 */
    variableName: string;
    /** 回调函数 */
    callback: (newValue: any, oldValue: any) => void;
    /** 监听器ID */
    id: string;
}
/**
 * 行为树黑板系统
 *
 * @description
 * 提供类型安全的变量存储和访问机制，支持：
 * - 类型化变量定义和访问
 * - 变量监听和回调
 * - 序列化和反序列化
 * - 实时调试和编辑
 *
 * @example
 * ```typescript
 * // 创建黑板实例
 * const blackboard = new Blackboard();
 *
 * // 定义变量
 * blackboard.defineVariable('playerHealth', BlackboardValueType.Number, 100, {
 *   description: '玩家生命值',
 *   min: 0,
 *   max: 100
 * });
 *
 * // 设置和获取值
 * blackboard.setValue('playerHealth', 80);
 * const health = blackboard.getValue<number>('playerHealth');
 *
 * // 监听变量变化
 * blackboard.addListener('playerHealth', (newVal, oldVal) => {
 *   console.log(`玩家生命值从 ${oldVal} 变为 ${newVal}`);
 * });
 * ```
 */
declare class Blackboard {
    /** 变量定义存储 */
    private _variables;
    /** 变量监听器存储 */
    private _listeners;
    /** 监听器计数器 */
    private _listenerIdCounter;
    /** 变量修改历史 */
    private _history;
    /** 是否启用历史记录 */
    enableHistory: boolean;
    /**
     * 定义一个黑板变量
     *
     * @param name 变量名
     * @param type 变量类型
     * @param defaultValue 默认值
     * @param options 额外选项
     */
    defineVariable(name: string, type: BlackboardValueType, defaultValue: any, options?: Partial<BlackboardVariable>): void;
    /**
     * 设置变量值
     *
     * @param name 变量名
     * @param value 新值
     * @param force 是否强制设置（忽略只读限制）
     */
    setValue<T = any>(name: string, value: T, force?: boolean): boolean;
    /**
     * 获取变量值
     *
     * @param name 变量名
     * @param defaultValue 变量不存在时的默认返回值
     * @returns 变量值
     */
    getValue<T = any>(name: string, defaultValue?: T): T;
    /**
     * 检查变量是否存在
     */
    hasVariable(name: string): boolean;
    /**
     * 获取变量定义
     */
    getVariableDefinition(name: string): BlackboardVariable | undefined;
    /**
     * 获取所有变量名称
     */
    getVariableNames(): string[];
    /**
     * 按分组获取变量
     */
    getVariablesByGroup(group: string): BlackboardVariable[];
    /**
     * 获取所有分组
     */
    getGroups(): string[];
    /**
     * 重置变量到默认值
     */
    resetVariable(name: string): boolean;
    /**
     * 重置所有变量到默认值
     */
    resetAll(): void;
    /**
     * 删除变量
     */
    removeVariable(name: string): boolean;
    /**
     * 添加变量监听器
     */
    addListener(variableName: string, callback: (newValue: any, oldValue: any) => void): string;
    /**
     * 移除监听器
     */
    removeListener(listenerId: string): boolean;
    /**
     * 序列化黑板数据
     */
    serialize(): string;
    /**
     * 从序列化数据恢复黑板
     */
    deserialize(data: string): boolean;
    /**
     * 获取修改历史
     */
    getHistory(): Array<{
        variableName: string;
        oldValue: any;
        newValue: any;
        timestamp: number;
    }>;
    /**
     * 清空历史记录
     */
    clearHistory(): void;
    /**
     * 验证值类型
     */
    private _validateValueType;
    /**
     * 检查是否为Vector2
     */
    private _isVector2;
    /**
     * 检查是否为Vector3
     */
    private _isVector3;
    /**
     * 深拷贝值
     */
    private _cloneValue;
    /**
     * 通知监听器
     */
    private _notifyListeners;
}

/**
 * 行为树控制器
 *
 * @description 管理行为树的执行，支持定时更新和上下文管理
 * @template T 上下文对象类型
 *
 * @example
 * ```typescript
 * // 创建游戏AI的行为树
 * interface GameContext {
 *   player: Player;
 *   enemies: Enemy[];
 *   gameTime: number;
 * }
 *
 * const context: GameContext = { ... };
 * const rootNode = new Selector(...);
 * const behaviorTree = new BehaviorTree(context, rootNode, 0.1); // 每100ms更新一次
 *
 * // 在游戏循环中调用
 * behaviorTree.tick();
 * ```
 */
declare class BehaviorTree<T> {
    /**
     * 行为树更新周期（秒）
     *
     * @description
     * - 大于0：按照指定间隔更新（如0.2表示每秒更新5次）
     * - 小于等于0：每帧都更新
     * @default 0.2
     */
    updatePeriod: number;
    /** 执行上下文，包含行为树运行所需的所有数据 */
    private _context;
    /** 黑板实例，用于节点间的数据共享 */
    private _blackboard;
    /** 行为树的根节点 */
    private _root;
    /** 距离下次更新的剩余时间 */
    private _elapsedTime;
    /** 上次更新的时间戳（秒） */
    private _lastTime;
    /** 是否启用性能优化模式 */
    private _performanceMode;
    /** 性能统计信息 */
    private _stats;
    /**
     * 创建行为树实例
     *
     * @param context 执行上下文对象
     * @param rootNode 根节点
     * @param updatePeriod 更新周期，0表示每帧更新
     * @param performanceMode 是否启用性能优化模式，默认false
     * @param blackboard 可选的黑板实例，如果不提供将自动创建
     * @throws {Error} 当context或rootNode为null时抛出错误
     */
    constructor(context: T, rootNode: Behavior<T>, updatePeriod?: number, performanceMode?: boolean, blackboard?: Blackboard);
    /**
     * 获取当前时间（秒）
     * 优先使用全局时间管理器，回退到本地时间计算
     */
    private _getCurrentTime;
    /**
     * 更新行为树
     *
     * @description
     * 根据updatePeriod设置决定是否执行根节点：
     * - updatePeriod > 0：按时间间隔更新
     * - updatePeriod <= 0：每次调用都更新
     *
     * 通常在游戏主循环中每帧调用此方法
     *
     * @param deltaTime 可选的时间差值（秒），如果提供则使用此值而不是计算
     */
    tick(deltaTime?: number): void;
    /**
     * 执行根节点
     */
    private _executeRoot;
    /**
     * 更新性能统计信息
     * @param executionTime 执行时间
     */
    private _updateStats;
    /**
     * 获取当前上下文
     * @returns 执行上下文对象
     */
    getContext(): T;
    /**
     * 获取黑板实例
     * @returns 黑板实例
     */
    getBlackboard(): Blackboard;
    /**
     * 更新上下文
     * @param context 新的上下文对象
     * @throws {Error} 当context为null时抛出错误
     */
    setContext(context: T): void;
    /**
     * 获取根节点
     * @returns 根节点实例
     */
    getRoot(): Behavior<T>;
    /**
     * 设置新的根节点
     * @param rootNode 新的根节点
     * @throws {Error} 当rootNode为null时抛出错误
     */
    setRoot(rootNode: Behavior<T>): void;
    /**
     * 强制重置整个行为树
     * @description 将根节点及其所有子节点重置为Invalid状态
     */
    reset(): void;
    /**
     * 设置性能模式
     * @param enabled 是否启用性能模式
     */
    setPerformanceMode(enabled: boolean): void;
    /**
     * 获取性能统计信息
     * @returns 性能统计对象
     */
    getStats(): Readonly<typeof this._stats>;
    /**
     * 重置性能统计信息
     */
    resetStats(): void;
    /**
     * 检查行为树是否处于活动状态
     * @returns 是否有待处理的更新
     */
    isActive(): boolean;
    /**
     * 获取到下次更新的剩余时间
     * @returns 剩余时间（秒），如果是每帧更新模式则返回0
     */
    getTimeToNextUpdate(): number;
}

declare enum AbortTypes {
    /**
     * 没有中止类型。即使其他条件更改了状态，当前操作也将始终运行
     */
    None = 0,
    /**
     * 如果一个更重要的有条件的任务改变了状态，它可以发出一个中止指令，使低优先级的任务停止运行，并将控制权转回高优先级的分支。
     * 这种类型应该被设置在作为讨论中的复合体的子体的复合体上。
     * 父复合体将检查它的子体，看它们是否有LowerPriority中止。
     */
    LowerPriority = 1,
    /**
     * 只有当它们都是复合体的子任务时，条件任务才能中止一个行动任务。
     * 这个AbortType只影响它所设置的实际的Composite，不像LowerPriority会影响其父Composite。
     */
    Self = 2,
    /**
     * 检查LowerPriority和Self aborts
     */
    Both = 3
}

/**
 * 支持的黑板变量类型联合类型
 */
type BlackboardVariableValue = string | number | boolean | object | unknown[];
/**
 * 节点属性值类型
 */
type NodePropertyValue = string | number | boolean | object;
/**
 * 执行上下文基础接口
 */
interface ExecutionContext {
    blackboard?: Blackboard;
    [key: string]: unknown;
}
/**
 * 条件配置接口
 */
interface ConditionConfig {
    type: string;
    properties?: Record<string, NodePropertyConfig>;
}
/**
 * 行为树配置接口
 * @description 定义行为树的完整配置结构
 */
interface BehaviorTreeConfig {
    /** 配置版本号 */
    version: string;
    /** 配置类型标识 */
    type: string;
    /** 元数据信息 */
    metadata?: BehaviorTreeMetadata;
    /** 根节点配置 */
    tree: NodeConfig;
}
/**
 * 行为树元数据接口
 * @description 包含行为树的描述性信息
 */
interface BehaviorTreeMetadata {
    /** 行为树名称 */
    name?: string;
    /** 版本信息 */
    version?: string;
    /** 创建时间 */
    created?: string;
    /** 导出类型 */
    exportType?: string;
    /** 更新周期（秒） */
    updatePeriod?: number;
    /** 描述信息 */
    description?: string;
    /** 作者信息 */
    author?: string;
    /** 扩展属性 */
    [key: string]: unknown;
}
/**
 * 节点配置接口
 * @description 定义单个行为树节点的配置结构
 */
interface NodeConfig {
    /** 节点唯一标识符 */
    id: string;
    /** 节点类型 */
    type: string;
    /** 命名空间（可选） */
    namespace?: string;
    /** 节点属性配置 */
    properties?: Record<string, NodePropertyConfig>;
    /** 子节点配置数组 */
    children?: NodeConfig[];
}
/**
 * 节点属性配置接口
 * @description 定义节点属性的类型和值
 */
interface NodePropertyConfig {
    /** 属性类型 */
    type: string;
    /** 属性值 */
    value: NodePropertyValue;
}
/**
 * 行为树JSON配置接口
 * @description 用于从JSON文件加载行为树配置的标准格式
 */
interface BehaviorTreeJSONConfig {
    /** 节点列表 */
    nodes: BehaviorTreeNodeConfig[];
    /** 黑板变量配置 */
    blackboard?: BlackboardVariableConfig[];
    /** 元数据信息 */
    metadata?: BehaviorTreeMetadata;
}
/**
 * 行为树节点配置接口
 * @description JSON格式中的节点配置结构
 */
interface BehaviorTreeNodeConfig {
    /** 节点唯一标识符 */
    id: string;
    /** 节点类型 */
    type: string;
    /** 节点显示名称 */
    name: string;
    /** 节点属性 */
    properties?: Record<string, NodePropertyValue>;
    /** 子节点ID列表 */
    children?: string[];
    /** 条件配置（用于条件装饰器等） */
    condition?: ConditionConfig;
}
/**
 * 黑板变量配置接口
 * @description 定义黑板变量的完整配置信息
 */
interface BlackboardVariableConfig {
    /** 变量名称 */
    name: string;
    /** 变量类型 */
    type: string;
    /** 变量初始值 */
    value: BlackboardVariableValue;
    /** 变量描述 */
    description?: string;
    /** 变量分组 */
    group?: string;
    /** 变量约束条件 */
    constraints?: {
        /** 最小值（数值类型） */
        min?: number;
        /** 最大值（数值类型） */
        max?: number;
        /** 只读标志 */
        readonly?: boolean;
        /** 可选值列表（枚举类型） */
        options?: BlackboardVariableValue[];
    };
}
/**
 * 行为树构建结果接口
 * @description fromBehaviorTreeConfig方法的返回结果
 */
interface BehaviorTreeBuildResult<T> {
    /** 构建好的行为树实例 */
    tree: BehaviorTree<T>;
    /** 初始化的黑板实例 */
    blackboard: Blackboard;
    /** 增强的执行上下文 */
    context: T;
}
/**
 * 行为树构建器类
 * @description 提供构建行为树的流畅API和配置加载功能
 * @template T 执行上下文类型
 *
 * @example
 * ```typescript
 * // 使用流畅API构建
 * const tree = BehaviorTreeBuilder.begin(context)
 *   .selector()
 *     .sequence()
 *       .logAction("开始执行")
 *       .waitAction(1.0)
 *     .endComposite()
 *     .logAction("备选方案")
 *   .endComposite()
 *   .build();
 *
 * // 从JSON配置构建
 * const result = BehaviorTreeBuilder.fromBehaviorTreeConfig(jsonConfig, context);
 * ```
 */
declare class BehaviorTreeBuilder<T> {
    /** 执行上下文 */
    private _context;
    /** 当前创建的节点 */
    private _currentNode;
    /** 父节点堆栈，用于流畅API构建 */
    private _parentNodeStack;
    /**
     * 构造函数
     * @param context 执行上下文
     */
    constructor(context: T);
    /**
     * 开始构建行为树
     * @param context 执行上下文
     * @returns 新的构建器实例
     */
    static begin<T>(context: T): BehaviorTreeBuilder<T>;
    /**
     * 设置子节点到父节点
     * @param child 子节点
     * @returns 构建器实例
     */
    private setChildOnParent;
    /**
     * 将节点推入父节点堆栈
     * @param composite 复合节点或装饰器节点
     * @returns 构建器实例
     */
    private pushParentNode;
    /**
     * 结束装饰器节点
     * @returns 构建器实例
     */
    private endDecorator;
    /**
     * 添加动作节点
     * @param func 动作执行函数
     * @returns 构建器实例
     */
    action(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T>;
    /**
     * 添加返回布尔值的动作节点
     * @param func 返回布尔值的函数
     * @returns 构建器实例
     */
    actionR(func: (t: T) => boolean): BehaviorTreeBuilder<T>;
    /**
     * 添加条件节点
     * @param func 条件检查函数
     * @returns 构建器实例
     */
    conditional(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T>;
    /**
     * 添加返回布尔值的条件节点
     * @param func 返回布尔值的条件函数
     * @returns 构建器实例
     */
    conditionalR(func: (t: T) => boolean): BehaviorTreeBuilder<T>;
    /**
     * 添加日志动作节点
     * @param text 日志文本
     * @returns 构建器实例
     */
    logAction(text: string): BehaviorTreeBuilder<T>;
    /**
     * 添加等待动作节点
     * @param waitTime 等待时间（秒）
     * @returns 构建器实例
     */
    waitAction(waitTime: number): BehaviorTreeBuilder<T>;
    /**
     * 添加子行为树节点
     * @param subTree 子行为树实例
     * @returns 构建器实例
     */
    subTree(subTree: BehaviorTree<T>): BehaviorTreeBuilder<T>;
    /**
     * 添加条件装饰器
     * @param func 条件函数
     * @param shouldReevaluate 是否重新评估
     * @returns 构建器实例
     */
    conditionalDecorator(func: (t: T) => TaskStatus, shouldReevaluate?: boolean): BehaviorTreeBuilder<T>;
    /**
     * 添加返回布尔值的条件装饰器
     * @param func 返回布尔值的条件函数
     * @param shouldReevaluate 是否重新评估
     * @returns 构建器实例
     */
    conditionalDecoratorR(func: (t: T) => boolean, shouldReevaluate?: boolean): BehaviorTreeBuilder<T>;
    /**
     * 添加总是失败装饰器
     * @returns 构建器实例
     */
    alwaysFail(): BehaviorTreeBuilder<T>;
    /**
     * 添加总是成功装饰器
     * @returns 构建器实例
     */
    alwaysSucceed(): BehaviorTreeBuilder<T>;
    /**
     * 添加反转装饰器
     * @returns 构建器实例
     */
    inverter(): BehaviorTreeBuilder<T>;
    /**
     * 添加重复装饰器
     * @param count 重复次数
     * @returns 构建器实例
     */
    repeater(count: number): BehaviorTreeBuilder<T>;
    /**
     * 添加直到失败装饰器
     * @returns 构建器实例
     */
    untilFail(): BehaviorTreeBuilder<T>;
    /**
     * 添加直到成功装饰器
     * @returns 构建器实例
     */
    untilSuccess(): BehaviorTreeBuilder<T>;
    /**
     * 添加并行节点
     * @returns 构建器实例
     */
    paraller(): BehaviorTreeBuilder<T>;
    /**
     * 添加并行选择器节点
     * @returns 构建器实例
     */
    parallelSelector(): BehaviorTreeBuilder<T>;
    /**
     * 添加选择器节点
     * @param abortType 中止类型
     * @returns 构建器实例
     */
    selector(abortType?: AbortTypes): BehaviorTreeBuilder<T>;
    /**
     * 添加随机选择器节点
     * @returns 构建器实例
     */
    randomSelector(): BehaviorTreeBuilder<T>;
    /**
     * 添加序列节点
     * @param abortType 中止类型
     * @returns 构建器实例
     */
    sequence(abortType?: AbortTypes): BehaviorTreeBuilder<T>;
    /**
     * 添加随机序列节点
     * @returns 构建器实例
     */
    randomSequence(): BehaviorTreeBuilder<T>;
    /**
     * 结束复合节点
     * @returns 构建器实例
     */
    endComposite(): BehaviorTreeBuilder<T>;
    /**
     * 构建最终的行为树
     * @param updatePeriod 更新周期（秒），默认0.2秒
     * @returns 构建好的行为树实例
     */
    build(updatePeriod?: number): BehaviorTree<T>;
    /**
     * 从配置对象创建行为树
     * @param config 行为树配置
     * @param context 执行上下文
     * @returns 构建好的行为树
     */
    static fromConfig<T>(config: BehaviorTreeConfig, context: T): BehaviorTree<T>;
    /**
     * 从JSON配置创建行为树
     * @description 自动初始化黑板变量和构建节点树，提供一键式行为树创建
     * @param config JSON格式的行为树配置
     * @param context 执行上下文（可选，如果不提供将创建默认上下文）
     * @returns 包含行为树、黑板和增强上下文的结果对象
     *
     * @example
     * ```typescript
     * const config = {
     *   nodes: [...],
     *   blackboard: [...],
     *   metadata: { name: "MyBehaviorTree" }
     * };
     * const result = BehaviorTreeBuilder.fromBehaviorTreeConfig(config, context);
     * const { tree, blackboard, context: enhancedContext } = result;
     * ```
     */
    static fromBehaviorTreeConfig<T extends ExecutionContext = ExecutionContext>(config: BehaviorTreeJSONConfig, context?: T): BehaviorTreeBuildResult<T>;
    /**
     * 映射字符串类型到BlackboardValueType枚举
     * @param typeString 类型字符串
     * @returns 对应的黑板值类型枚举
     */
    private static mapToBlackboardType;
    /**
     * 转换黑板变量值到正确的类型
     * @param value 原始值（通常来自JSON，都是字符串）
     * @param targetType 目标类型
     * @returns 转换后的值
     */
    private static convertBlackboardValue;
    /**
     * 从节点配置创建节点实例
     * @param nodeConfig 节点配置
     * @returns 创建的节点实例
     */
    private static createNodeFromConfig;
    /**
     * 解析中止类型字符串为枚举值
     * @param value 中止类型字符串
     * @returns 对应的中止类型枚举值
     */
    private static getAbortType;
    /**
     * 从JSON节点配置创建节点实例
     * @description 递归创建节点树，支持所有标准行为树节点类型
     * @param nodeConfig 当前节点配置
     * @param nodeMap 节点ID到配置的映射表
     * @param context 执行上下文
     * @returns 创建的节点实例
     */
    private static createNodeFromJSONConfig;
    /**
     * 创建条件函数
     * @param condition 条件配置
     * @param context 执行上下文
     * @returns 条件检查函数
     */
    private static createConditionFunction;
    /**
     * 替换对象中的黑板变量引用
     * @param obj 要处理的对象
     * @param blackboard 黑板实例
     * @returns 替换后的对象
     */
    private static replaceBlackboardVariables;
    /**
     * 提取嵌套属性值
     * @param prop 属性配置对象或直接值
     * @returns 提取的值
     */
    private static extractNestedValue;
}

/**
 * 通用对象池，用于减少对象创建和销毁的开销
 *
 * @template T 池中对象的类型
 *
 * @example
 * ```typescript
 * // 创建一个ExecuteAction的对象池
 * const actionPool = new ObjectPool(
 *   () => new ExecuteAction(() => TaskStatus.Success),
 *   (action) => action.invalidate(),
 *   50 // 最大池大小
 * );
 *
 * // 获取对象
 * const action = actionPool.get();
 *
 * // 使用完毕后归还
 * actionPool.release(