@esengine/ecs-framework 2.1.7 → 2.1.8

package/index.d.ts

@@ -1,22 +1,3760 @@
 /**
  * @esengine/ecs-framework
  * 高性能ECS框架 - 适用于Cocos Creator和Laya引擎
- * 版本: 2.1.7
- * 构建时间: 2025-06-09T05:30:23.949Z
+ * 版本: 2.1.8
+ * 构建时间: 2025-06-09T06:23:45.962Z
  */
 
+export declare class Core {
+    /**
+     * 核心事件发射器
+     *
+     * 用于发布和订阅核心级别的事件，如帧更新、场景切换等。
+     */
+    static emitter: Emitter<CoreEvents>;
+    /**
+     * 游戏暂停状态
+     *
+     * 当设置为true时，游戏循环将暂停执行。
+     */
+    static paused: boolean;
+    /**
+     * 全局核心实例
+     */
+    private static _instance;
+    /**
+     * 实体系统启用状态
+     *
+     * 控制是否启用ECS实体系统功能。
+     */
+    static entitySystemsEnabled: boolean;
+    /**
+     * 调试模式标志
+     *
+     * 在调试模式下会启用额外的性能监控和错误检查。
+     */
+    readonly debug: boolean;
+    /**
+     * 待切换的场景
+     *
+     * 存储下一帧要切换到的场景实例。
+     */
+    _nextScene: Scene | null;
+    /**
+     * 全局管理器集合
+     *
+     * 存储所有注册的全局管理器实例。
+     */
+    _globalManagers: GlobalManager[];
+    /**
+     * 定时器管理器
+     *
+     * 负责管理所有的游戏定时器。
+     */
+    _timerManager: TimerManager;
+    /**
+     * 性能监控器
+     *
+     * 监控游戏性能并提供优化建议。
+     */
+    _performanceMonitor: PerformanceMonitor;
+    /**
+     * 对象池管理器
+     *
+     * 管理所有对象池的生命周期。
+     */
+    _poolManager: PoolManager;
+    /**
+     * ECS流式API
+     *
+     * 提供便捷的ECS操作接口。
+     */
+    _ecsAPI?: ECSFluentAPI;
+    /**
+     * 当前活动场景
+     */
+    _scene?: Scene;
+    /**
+     * 创建核心实例
+     *
+     * @param debug - 是否启用调试模式，默认为true
+     * @param enableEntitySystems - 是否启用实体系统，默认为true
+     */
+    private constructor();
+    /**
+     * 获取核心实例
+     *
+     * @returns 全局核心实例
+     */
+    static get Instance(): Core;
+    /**
+     * 获取当前活动的场景
+     *
+     * @returns 当前场景实例，如果没有则返回null
+     */
+    static get scene(): Scene | null;
+    /**
+     * 设置当前活动的场景
+     *
+     * 如果当前没有场景，会立即切换；否则会在下一帧切换。
+     *
+     * @param value - 要设置的场景实例
+     * @throws {Error}
+
+export interface IUpdatable {
+    enabled: boolean;
+    updateOrder: number;
+    update(): void;
+}
+
+export declare class IUpdatableComparer {
+    compare(a: IUpdatable, b: IUpdatable): number;
+}
+
+export declare class SceneComponent {
+    /** 组件所属的场景 */
+    scene: Scene;
+    /** 更新顺序 */
+    updateOrder: number;
+    /** 是否启用 */
+    private _enabled;
+    /** 获取是否启用 */
+    get enabled(): boolean;
+    /** 设置是否启用 */
+    set enabled(value: boolean);
+    /**
+     * 当组件启用时调用
+     */
+    onEnabled(): void;
+    /**
+     * 当组件禁用时调用
+     */
+    onDisabled(): void;
+    /**
+     * 当组件从场景中移除时调用
+     */
+    onRemovedFromScene(): void;
+    /**
+     * 每帧更新
+     */
+    update(): void;
+    /**
+     * 比较组件的更新顺序
+     * @param other 其他组件
+     * @returns 比较结果
+     */
+    compare(other: SceneComponent): number;
+}
+
+export type ArchetypeId = string;
+/**
+ * 原型数据结构
+ */
+export interface Archetype {
+    /** 原型唯一标识符 */
+    id: ArchetypeId;
+    /** 包含的组件类型 */
+    componentTypes: ComponentType[];
+    /** 属于该原型的实体列表 */
+    entities: Entity[];
+    /** 原型创建时间 */
+    createdAt: number;
+    /** 最后更新时间 */
+    updatedAt: number;
+}
+
+export interface ArchetypeQueryResult {
+    /** 匹配的原型列表 */
+    archetypes: Archetype[];
+    /** 所有匹配实体的总数 */
+    totalEntities: number;
+    /** 查询执行时间（毫秒） */
+    executionTime: number;
+    /** 是否使用了缓存 */
+    fromCache: boolean;
+}
+
+export declare class ArchetypeSystem {
+    /** 所有原型的映射表 */
+    private _archetypes;
+    /** 实体到原型的映射 */
+    private _entityToArchetype;
+    /** 组件类型到原型的映射 */
+    private _componentToArchetypes;
+    /** 查询缓存 */
+    private _queryCache;
+    private _cacheTimeout;
+    private _maxCacheSize;
+    /**
+     * 添加实体到原型系统
+     */
+    addEntity(entity: Entity): void;
+    /**
+     * 从原型系统中移除实体
+     */
+    removeEntity(entity: Entity): void;
+    /**
+     * 查询包含指定组件组合的原型
+     */
+    queryArchetypes(componentTypes: ComponentType[], operation?: 'AND' | 'OR'): ArchetypeQueryResult;
+    /**
+     * 获取实体所属的原型
+     */
+    getEntityArchetype(entity: Entity): Archetype | undefined;
+    /**
+     * 获取所有原型
+     */
+    getAllArchetypes(): Archetype[];
+    /**
+     * 清空所有数据
+     */
+    clear(): void;
+    /**
+     * 获取实体的组件类型列表
+     */
+    private getEntityComponentTypes;
+    /**
+     * 生成原型ID
+     */
+    private generateArchetypeId;
+    /**
+     * 创建新原型
+     */
+    private createArchetype;
+    /**
+     * 检查原型是否包含所有指定组件
+     */
+    private archetypeContainsAllComponents;
+    /**
+     * 更新组件索引
+     */
+    private updateComponentIndexes;
+    /**
+     * 使查询缓存失效
+     */
+    private invalidateQueryCache;
+}
+
+export type ArchetypeId = string;
+
+export declare class BitMaskOptimizer {
+    private static instance;
+    private maskCache;
+    private componentTypeMap;
+    private nextComponentId;
+    private constructor();
+    static getInstance(): BitMaskOptimizer;
+    /**
+     * 注册组件类型
+     */
+    registerComponentType(componentName: string): number;
+    /**
+     * 获取组件类型ID
+     */
+    getComponentTypeId(componentName: string): number | undefined;
+    /**
+     * 创建单个组件的掩码
+     */
+    createSingleComponentMask(componentName: string): bigint;
+    /**
+     * 创建多个组件的组合掩码
+     */
+    createCombinedMask(componentNames: string[]): bigint;
+    /**
+     * 检查掩码是否包含指定组件
+     */
+    maskContainsComponent(mask: bigint, componentName: string): boolean;
+    /**
+     * 检查掩码是否包含所有指定组件
+     */
+    maskContainsAllComponents(mask: bigint, componentNames: string[]): boolean;
+    /**
+     * 检查掩码是否包含任一指定组件
+     */
+    maskContainsAnyComponent(mask: bigint, componentNames: string[]): boolean;
+    /**
+     * 添加组件到掩码
+     */
+    addComponentToMask(mask: bigint, componentName: string): bigint;
+    /**
+     * 从掩码中移除组件
+     */
+    removeComponentFromMask(mask: bigint, componentName: string): bigint;
+    /**
+     * 预计算常用掩码组合
+     */
+    precomputeCommonMasks(commonCombinations: string[][]): void;
+    /**
+     * 获取掩码缓存统计信息
+     */
+    getCacheStats(): {
+        size: number;
+        componentTypes: number;
+    }
+
+export declare enum IndexType {
+    /** 哈希索引 - 最快查找 */
+    HASH = "hash",
+    /** 位图索引 - 内存高效 */
+    BITMAP = "bitmap",
+    /** 排序索引 - 支持范围查询 */
+    SORTED = "sorted"
+}
+
+export interface IndexStats {
+    /** 索引类型 */
+    type: IndexType;
+    /** 索引大小 */
+    size: number;
+    /** 内存使用量（字节） */
+    memoryUsage: number;
+    /** 查询次数 */
+    queryCount: number;
+    /** 平均查询时间（毫秒） */
+    avgQueryTime: number;
+    /** 最后更新时间 */
+    lastUpdated: number;
+}
+
+export interface IComponentIndex {
+    /** 索引类型 */
+    readonly type: IndexType;
+    /** 添加实体到索引 */
+    addEntity(entity: Entity): void;
+    /** 从索引中移除实体 */
+    removeEntity(entity: Entity): void;
+    /** 查询包含指定组件的实体 */
+    query(componentType: ComponentType): Set<Entity>;
+    /** 批量查询多个组件 */
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    /** 清空索引 */
+    clear(): void;
+    /** 获取索引统计信息 */
+    getStats(): IndexStats;
+}
+
+export declare class HashComponentIndex implements IComponentIndex {
+    readonly type = IndexType.HASH;
+    private _componentToEntities;
+    private _entityToComponents;
+    private _queryCount;
+    private _totalQueryTime;
+    private _lastUpdated;
+    addEntity(entity: Entity): void;
+    removeEntity(entity: Entity): void;
+    query(componentType: ComponentType): Set<Entity>;
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    clear(): void;
+    getStats(): IndexStats;
+}
+
+export declare class BitmapComponentIndex implements IComponentIndex {
+    readonly type = IndexType.BITMAP;
+    private _componentTypeToBit;
+    private _entityToBitmap;
+    private _bitToEntities;
+    private _nextBit;
+    private _queryCount;
+    private _totalQueryTime;
+    private _lastUpdated;
+    addEntity(entity: Entity): void;
+    removeEntity(entity: Entity): void;
+    query(componentType: ComponentType): Set<Entity>;
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    clear(): void;
+    getStats(): IndexStats;
+}
+
+export declare class ComponentIndexManager {
+    private _activeIndex;
+    private _indexHistory;
+    private _autoOptimize;
+    private _optimizationThreshold;
+    constructor(initialType?: IndexType);
+    /**
+     * 添加实体到索引
+     */
+    addEntity(entity: Entity): void;
+    /**
+     * 从索引中移除实体
+     */
+    removeEntity(entity: Entity): void;
+    /**
+     * 查询包含指定组件的实体
+     */
+    query(componentType: ComponentType): Set<Entity>;
+    /**
+     * 批量查询多个组件
+     */
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    /**
+     * 手动切换索引类型
+     */
+    switchIndexType(type: IndexType): void;
+    /**
+     * 启用/禁用自动优化
+     */
+    setAutoOptimize(enabled: boolean): void;
+    /**
+     * 获取当前索引统计信息
+     */
+    getStats(): IndexStats;
+    /**
+     * 获取所有索引类型的历史统计信息
+     */
+    getAllStats(): Map<IndexType, IndexStats>;
+    /**
+     * 清空索引
+     */
+    clear(): void;
+    /**
+     * 创建指定类型的索引
+     */
+    private createIndex;
+    /**
+     * 检查是否需要优化索引
+     */
+    private checkOptimization;
+}
+
+export declare class ComponentPool<T extends Component> {
+    private pool;
+    private createFn;
+    private resetFn?;
+    private maxSize;
+    constructor(createFn: () => T, resetFn?: (component: T) => void, maxSize?: number);
+    /**
+     * 获取一个组件实例
+     */
+    acquire(): T;
+    /**
+     * 释放一个组件实例回池中
+     */
+    release(component: T): void;
+    /**
+     * 预填充对象池
+     */
+    prewarm(count: number): void;
+    /**
+     * 清空对象池
+     */
+    clear(): void;
+    /**
+     * 获取池中可用对象数量
+     */
+    getAvailableCount(): number;
+    /**
+     * 获取池的最大容量
+     */
+    getMaxSize(): number;
+}
+
+export declare class ComponentPoolManager {
+    private static instance;
+    private pools;
+    private constructor();
+    static getInstance(): ComponentPoolManager;
+    /**
+     * 注册组件池
+     */
+    registerPool<T extends Component>(componentName: string, createFn: () => T, resetFn?: (component: T) => void, maxSize?: number): void;
+    /**
+     * 获取组件实例
+     */
+    acquireComponent<T extends Component>(componentName: string): T | null;
+    /**
+     * 释放组件实例
+     */
+    releaseComponent<T extends Component>(componentName: string, component: T): void;
+    /**
+     * 预热所有池
+     */
+    prewarmAll(count?: number): void;
+    /**
+     * 清空所有池
+     */
+    clearAll(): void;
+    /**
+     * 获取池统计信息
+     */
+    getPoolStats(): Map<string, {
+        available: number;
+        maxSize: number;
+    }
+
+export type ComponentType<T extends Component = Component> = new (...args: any[]) => T;
+/**
+ * 组件注册表
+ * 管理组件类型的位掩码分配
+ */
+export declare class ComponentRegistry {
+    private static componentTypes;
+    private static nextBitIndex;
+    private static maxComponents;
+    /**
+     * 注册组件类型并分配位掩码
+     * @param componentType 组件类型
+     * @returns 分配的位索引
+     */
+    static register<T extends Component>(componentType: ComponentType<T>): number;
+    /**
+     * 获取组件类型的位掩码
+     * @param componentType 组件类型
+     * @returns 位掩码
+     */
+    static getBitMask<T extends Component>(componentType: ComponentType<T>): bigint;
+    /**
+     * 获取组件类型的位索引
+     * @param componentType 组件类型
+     * @returns 位索引
+     */
+    static getBitIndex<T extends Component>(componentType: ComponentType<T>): number;
+    /**
+     * 检查组件类型是否已注册
+     * @param componentType 组件类型
+     * @returns 是否已注册
+     */
+    static isRegistered<T extends Component>(componentType: ComponentType<T>): boolean;
+    /**
+     * 获取所有已注册的组件类型
+     * @returns 组件类型映射
+     */
+    static getAllRegisteredTypes(): Map<Function, number>;
+}
+
+export declare class ComponentStorage<T extends Component> {
+    private components;
+    private entityToIndex;
+    private indexToEntity;
+    private freeIndices;
+    private componentType;
+    private _size;
+    constructor(componentType: ComponentType<T>);
+    /**
+     * 添加组件
+     * @param entityId 实体ID
+     * @param component 组件实例
+     */
+    addComponent(entityId: number, component: T): void;
+    /**
+     * 获取组件
+     * @param entityId 实体ID
+     * @returns 组件实例或null
+     */
+    getComponent(entityId: number): T | null;
+    /**
+     * 检查实体是否有此组件
+     * @param entityId 实体ID
+     * @returns 是否有组件
+     */
+    hasComponent(entityId: number): boolean;
+    /**
+     * 移除组件
+     * @param entityId 实体ID
+     * @returns 被移除的组件或null
+     */
+    removeComponent(entityId: number): T | null;
+    /**
+     * 高效遍历所有组件
+     * @param callback 回调函数
+     */
+    forEach(callback: (component: T, entityId: number, index: number) => void): void;
+    /**
+     * 获取所有组件（密集数组）
+     * @returns 组件数组
+     */
+    getDenseArray(): {
+        components: T[];
+        entityIds: number[];
+    }
+
+export declare class ComponentStorageManager {
+    private storages;
+    /**
+     * 获取或创建组件存储器
+     * @param componentType 组件类型
+     * @returns 组件存储器
+     */
+    getStorage<T extends Component>(componentType: ComponentType<T>): ComponentStorage<T>;
+    /**
+     * 添加组件
+     * @param entityId 实体ID
+     * @param component 组件实例
+     */
+    addComponent<T extends Component>(entityId: number, component: T): void;
+    /**
+     * 获取组件
+     * @param entityId 实体ID
+     * @param componentType 组件类型
+     * @returns 组件实例或null
+     */
+    getComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): T | null;
+    /**
+     * 检查实体是否有组件
+     * @param entityId 实体ID
+     * @param componentType 组件类型
+     * @returns 是否有组件
+     */
+    hasComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): boolean;
+    /**
+     * 移除组件
+     * @param entityId 实体ID
+     * @param componentType 组件类型
+     * @returns 被移除的组件或null
+     */
+    removeComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): T | null;
+    /**
+     * 移除实体的所有组件
+     * @param entityId 实体ID
+     */
+    removeAllComponents(entityId: number): void;
+    /**
+     * 获取实体的组件位掩码
+     * @param entityId 实体ID
+     * @returns 组件位掩码
+     */
+    getComponentMask(entityId: number): bigint;
+    /**
+     * 压缩所有存储器
+     */
+    compactAll(): void;
+    /**
+     * 获取所有存储器的统计信息
+     */
+    getAllStats(): Map<string, any>;
+    /**
+     * 清空所有存储器
+     */
+    clear(): void;
+}
+
+export type ComponentType<T extends Component = Component> = new (...args: any[]) => T;
+
+export declare enum DirtyFlag {
+    /** 组件数据已修改 */
+    COMPONENT_MODIFIED = 1,
+    /** 组件已添加 */
+    COMPONENT_ADDED = 2,
+    /** 组件已移除 */
+    COMPONENT_REMOVED = 4,
+    /** 实体位置已改变 */
+    TRANSFORM_CHANGED = 8,
+    /** 实体状态已改变 */
+    STATE_CHANGED = 16,
+    /** 自定义标记1 */
+    CUSTOM_1 = 256,
+    /** 自定义标记2 */
+    CUSTOM_2 = 512,
+    /** 自定义标记3 */
+    CUSTOM_3 = 1024,
+    /** 所有标记 */
+    ALL = 4294967295
+}
+
+export interface DirtyData {
+    /** 实体引用 */
+    entity: Entity;
+    /** 脏标记位 */
+    flags: number;
+    /** 修改的组件类型列表 */
+    modifiedComponents: Set<ComponentType>;
+    /** 标记时间戳 */
+    timestamp: number;
+    /** 帧编号 */
+    frameNumber: number;
+}
+
+export interface DirtyListener {
+    /** 感兴趣的标记类型 */
+    flags: number;
+    /** 回调函数 */
+    callback: (dirtyData: DirtyData) => void;
+    /** 监听器优先级（数字越小优先级越高） */
+    priority?: number;
+}
+
+export interface DirtyStats {
+    /** 当前脏实体数量 */
+    dirtyEntityCount: number;
+    /** 总标记次数 */
+    totalMarkings: number;
+    /** 总清理次数 */
+    totalCleanups: number;
+    /** 监听器数量 */
+    listenerCount: number;
+    /** 平均每帧脏实体数量 */
+    avgDirtyPerFrame: number;
+    /** 内存使用量估算 */
+    estimatedMemoryUsage: number;
+}
+
+export declare class DirtyTrackingSystem {
+    /** 脏实体映射表 */
+    private _dirtyEntities;
+    /** 脏标记监听器 */
+    private _listeners;
+    /** 性能统计 */
+    private _stats;
+    /** 当前帧编号 */
+    private _currentFrame;
+    private _batchSize;
+    private _maxProcessingTime;
+    /** 延迟处理队列 */
+    private _processingQueue;
+    private _isProcessing;
+    /**
+     * 标记实体为脏状态
+     *
+     * @param entity 要标记的实体
+     * @param flags 脏标记位
+     * @param modifiedComponents 修改的组件类型列表
+     */
+    markDirty(entity: Entity, flags: DirtyFlag, modifiedComponents?: ComponentType[]): void;
+    /**
+     * 检查实体是否有指定的脏标记
+     *
+     * @param entity 要检查的实体
+     * @param flags 要检查的标记位
+     * @returns 是否有指定的脏标记
+     */
+    isDirty(entity: Entity, flags?: DirtyFlag): boolean;
+    /**
+     * 清除实体的脏标记
+     *
+     * @param entity 要清除的实体
+     * @param flags 要清除的标记位，默认清除所有
+     */
+    clearDirty(entity: Entity, flags?: DirtyFlag): void;
+    /**
+     * 获取所有脏实体
+     *
+     * @param flags 过滤标记位，只返回包含指定标记的实体
+     * @returns 脏实体数据数组
+     */
+    getDirtyEntities(flags?: DirtyFlag): DirtyData[];
+    /**
+     * 批量处理脏实体
+     *
+     * 使用时间分片的方式处理脏实体，避免单帧卡顿
+     */
+    processDirtyEntities(): void;
+    /**
+     * 添加脏标记监听器
+     *
+     * @param listener 监听器配置
+     */
+    addListener(listener: DirtyListener): void;
+    /**
+     * 移除脏标记监听器
+     *
+     * @param callback 要移除的回调函数
+     */
+    removeListener(callback: (dirtyData: DirtyData) => void): void;
+    /**
+     * 开始新的帧
+     */
+    beginFrame(): void;
+    /**
+     * 结束当前帧
+     */
+    endFrame(): void;
+    /**
+     * 获取统计信息
+     */
+    getStats(): DirtyStats;
+    /**
+     * 清空所有脏标记和统计信息
+     */
+    clear(): void;
+    /**
+     * 配置批量处理参数
+     *
+     * @param batchSize 每次处理的最大实体数量
+     * @param maxProcessingTime 每帧最大处理时间（毫秒）
+     */
+    configureBatchProcessing(batchSize: number, maxProcessingTime: number): void;
+    /**
+     * 处理单个脏实体
+     */
+    private processEntity;
+    /**
+     * 通知监听器
+     */
+    private notifyListeners;
+    /**
+     * 帧结束时的统计更新
+     */
+    private onFrameEnd;
+    /**
+     * 估算内存使用量
+     */
+    private estimateMemoryUsage;
+}
+
+export declare class EntityQueryBuilder {
+    private entityManager;
+    /** 必须包含的组件类型 */
+    private _allComponents;
+    /** 至少包含一个的组件类型 */
+    private _anyComponents;
+    /** 不能包含的组件类型 */
+    private _withoutComponents;
+    /** 必须包含的标签 */
+    private _withTags;
+    /** 不能包含的标签 */
+    private _withoutTags;
+    /** 是否只查询激活状态的实体 */
+    private _activeOnly;
+    /** 是否只查询启用状态的实体 */
+    private _enabledOnly;
+    /** 自定义过滤条件 */
+    private _customPredicates;
+    /**
+     * 创建查询构建器实例
+     * @param entityManager 实体管理器实例
+     */
+    constructor(entityManager: EntityManager);
+    /**
+     * 添加必须包含的组件条件
+     *
+     * 返回的实体必须包含所有指定的组件类型。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 查询构建器实例，支持链式调用
+     */
+    withAll(...componentTypes: ComponentType[]): EntityQueryBuilder;
+    /**
+     * 添加至少包含一个的组件条件
+     *
+     * 返回的实体必须至少包含其中一个指定的组件类型。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 查询构建器实例，支持链式调用
+     */
+    withAny(...componentTypes: ComponentType[]): EntityQueryBuilder;
+    /**
+     * 添加不能包含的组件条件
+     *
+     * 返回的实体不能包含任何指定的组件类型。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 查询构建器实例，支持链式调用
+     */
+    without(...componentTypes: ComponentType[]): EntityQueryBuilder;
+    /**
+     * 添加必须包含的标签条件
+     *
+     * 返回的实体必须具有指定的标签。
+     *
+     * @param tag 标签值
+     * @returns 查询构建器实例，支持链式调用
+     */
+    withTag(tag: number): EntityQueryBuilder;
+    /**
+     * 添加不能包含的标签条件
+     *
+     * 返回的实体不能具有指定的标签。
+     *
+     * @param tag 标签值
+     * @returns 查询构建器实例，支持链式调用
+     */
+    withoutTag(tag: number): EntityQueryBuilder;
+    /**
+     * 添加激活状态过滤条件
+     *
+     * 返回的实体必须处于激活状态（active = true）。
+     *
+     * @returns 查询构建器实例，支持链式调用
+     */
+    active(): EntityQueryBuilder;
+    /**
+     * 添加启用状态过滤条件
+     *
+     * 返回的实体必须处于启用状态（enabled = true）。
+     *
+     * @returns 查询构建器实例，支持链式调用
+     */
+    enabled(): EntityQueryBuilder;
+    /**
+     * 添加自定义过滤条件
+     *
+     * 允许用户定义复杂的过滤逻辑。
+     *
+     * @param predicate 自定义过滤函数，接收实体作为参数，返回布尔值
+     * @returns 查询构建器实例，支持链式调用
+     *
+     * @example
+     * ```typescript
+     * .where(entity => entity.name.startsWith("Player"))
+     * .where(entity => entity.components.length > 5)
+     * ```
+     */
+    where(predicate: (entity: Entity) => boolean): EntityQueryBuilder;
+    /**
+     * 执行查询并返回所有匹配的实体
+     *
+     * @returns 符合所有查询条件的实体数组
+     */
+    execute(): Entity[];
+    /**
+     * 执行查询并返回第一个匹配的实体
+     *
+     * @returns 第一个符合查询条件的实体，如果没有找到则返回null
+     */
+    first(): Entity | null;
+    /**
+     * 执行查询并返回匹配实体的数量
+     *
+     * @returns 符合查询条件的实体数量
+     */
+    count(): number;
+    /**
+     * 对所有匹配的实体执行指定操作
+     *
+     * @param action 要执行的操作函数，接收匹配的实体作为参数
+     */
+    forEach(action: (entity: Entity) => void): void;
+    /**
+     * 检查实体是否匹配所有查询条件
+     *
+     * 按优先级顺序检查各种过滤条件，一旦发现不匹配立即返回false。
+     *
+     * @param entity 要检查的实体
+     * @returns 实体是否匹配所有查询条件
+     */
+    private matchesEntity;
+}
+
+export declare class EntityManager {
+    /** 主要实体存储，使用ID作为键 */
+    private _entities;
+    /** 按名称索引的实体映射 */
+    private _entitiesByName;
+    /** 按标签索引的实体映射 */
+    private _entitiesByTag;
+    /** 实体ID分配器 */
+    private _identifierPool;
+    /** 已销毁实体的ID集合 */
+    private _destroyedEntities;
+    /** 性能优化系统 */
+    private _componentIndexManager;
+    private _archetypeSystem;
+    private _dirtyTrackingSystem;
+    /** 事件总线 */
+    private _eventBus;
+    /**
+     * 创建实体管理器实例
+     *
+     * 初始化内部数据结构和ID分配器。
+     */
+    constructor();
+    /**
+     * 获取实体总数
+     *
+     * @returns 当前管理的实体总数量
+     */
+    get entityCount(): number;
+    /**
+     * 获取激活状态的实体数量
+     *
+     * 只计算同时满足激活状态且未被销毁的实体。
+     *
+     * @returns 激活状态的实体数量
+     */
+    get activeEntityCount(): number;
+    /**
+     * 创建新实体
+     *
+     * 分配唯一ID并将实体添加到管理系统中，同时更新相关索引。
+     *
+     * @param name 实体名称，如果未指定则使用时间戳生成默认名称
+     * @returns 创建的实体实例
+     *
+     * @example
+     * ```typescript
+     * const player = entityManager.createEntity("Player");
+     * const enemy = entityManager.createEntity(); // 使用默认名称
+     * ```
+     */
+    createEntity(name?: string): Entity;
+    /**
+     * 销毁实体
+     *
+     * 支持通过实体对象、名称或ID来销毁实体。
+     * 会清理所有相关索引并回收ID。
+     *
+     * @param entityOrId 要销毁的实体，可以是实体对象、名称字符串或ID数字
+     * @returns 是否成功销毁实体
+     *
+     * @example
+     * ```typescript
+     * // 通过实体对象销毁
+     * entityManager.destroyEntity(player);
+     *
+     * // 通过名称销毁
+     * entityManager.destroyEntity("Enemy_1");
+     *
+     * // 通过ID销毁
+     * entityManager.destroyEntity(123);
+     * ```
+     */
+    destroyEntity(entityOrId: Entity | string | number): boolean;
+    /**
+     * 获取所有实体
+     *
+     * 返回当前管理的所有实体的副本数组。
+     *
+     * @returns 所有实体的数组
+     */
+    getAllEntities(): Entity[];
+    /**
+     * 根据ID获取实体
+     *
+     * 支持字符串和数字类型的ID。
+     *
+     * @param id 实体ID，可以是字符串或数字
+     * @returns 对应的实体，如果不存在则返回null
+     */
+    getEntity(id: string | number): Entity | null;
+    /**
+     * 根据名称获取实体
+     *
+     * 如果存在多个同名实体，返回第一个找到的实体。
+     *
+     * @param name 实体名称
+     * @returns 匹配的实体，如果不存在则返回null
+     */
+    getEntityByName(name: string): Entity | null;
+    /**
+     * 根据标签获取实体列表
+     *
+     * 返回所有具有指定标签的实体。
+     *
+     * @param tag 标签值
+     * @returns 具有指定标签的实体数组
+     */
+    getEntitiesByTag(tag: number): Entity[];
+    /**
+     * 获取包含指定组件的所有实体
+     *
+     * 遍历所有实体，查找包含指定组件类型的实体。
+     *
+     * @param componentType 组件类型
+     * @returns 包含指定组件的实体数组
+     *
+     * @example
+     * ```typescript
+     * const entitiesWithHealth = entityManager.getEntitiesWithComponent(HealthComponent);
+     * ```
+     */
+    getEntitiesWithComponent<T extends Component>(componentType: ComponentType<T>): Entity[];
+    /**
+     * 创建查询构建器
+     *
+     * 返回一个新的查询构建器实例，用于构建复杂的实体查询。
+     *
+     * @returns 新的查询构建器实例
+     *
+     * @example
+     * ```typescript
+     * const results = entityManager.query()
+     *     .withAll(PositionComponent, HealthComponent)
+     *     .without(VelocityComponent)
+     *     .active()
+     *     .execute();
+     * ```
+     */
+    query(): EntityQueryBuilder;
+    /**
+     * 使用组件索引进行多组件查询
+     *
+     * @param componentTypes 组件类型数组
+     * @param operation 查询操作：'AND' 或 'OR'
+     * @returns 匹配的实体集合
+     */
+    queryWithComponentIndex(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    /**
+     * 标记实体组件已修改
+     *
+     * @param entity 修改的实体
+     * @param componentTypes 修改的组件类型
+     */
+    markEntityDirty(entity: Entity, componentTypes: ComponentType[]): void;
+    /**
+     * 获取性能优化统计信息
+     */
+    getOptimizationStats(): any;
+    /**
+     * 获取事件总线实例
+     *
+     * 允许外部代码监听和发射ECS相关事件。
+     *
+     * @returns 事件总线实例
+     */
+    get eventBus(): EventBus;
+    /**
+     * 更新名称索引
+     *
+     * 维护按名称查找实体的索引结构。支持添加和移除操作。
+     *
+     * @param entity 要更新索引的实体
+     * @param isAdd true表示添加到索引，false表示从索引中移除
+     */
+    private updateNameIndex;
+    /**
+     * 更新标签索引
+     *
+     * 维护按标签查找实体的索引结构。支持添加和移除操作。
+     *
+     * @param entity 要更新索引的实体
+     * @param isAdd true表示添加到索引，false表示从索引中移除
+     */
+    private updateTagIndex;
+}
+
+export declare class EventBus implements IEventBus {
+    private eventSystem;
+    private eventIdCounter;
+    private isDebugMode;
+    constructor(debugMode?: boolean);
+    /**
+     * 发射事件
+     * @param eventType 事件类型
+     * @param data 事件数据
+     */
+    emit<T>(eventType: string, data: T): void;
+    /**
+     * 异步发射事件
+     * @param eventType 事件类型
+     * @param data 事件数据
+     */
+    emitAsync<T>(eventType: string, data: T): Promise<void>;
+    /**
+     * 监听事件
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    on<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听事件（一次性）
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    once<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
+    /**
+     * 异步监听事件
+     * @param eventType 事件类型
+     * @param handler 异步事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    onAsync<T>(eventType: string, handler: (data: T) => Promise<void>, config?: IEventListenerConfig): string;
+    /**
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
+     */
+    off(eventType: string, listenerId: string): boolean;
+    /**
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
+     */
+    offAll(eventType: string): void;
+    /**
+     * 检查是否有指定事件的监听器
+     * @param eventType 事件类型
+     */
+    hasListeners(eventType: string): boolean;
+    /**
+     * 获取事件统计信息
+     * @param eventType 事件类型（可选）
+     */
+    getStats(eventType?: string): IEventStats | Map<string, IEventStats>;
+    /**
+     * 清空所有监听器
+     */
+    clear(): void;
+    /**
+     * 启用或禁用事件系统
+     * @param enabled 是否启用
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 设置调试模式
+     * @param debug 是否启用调试
+     */
+    setDebugMode(debug: boolean): void;
+    /**
+     * 设置最大监听器数量
+     * @param max 最大数量
+     */
+    setMaxListeners(max: number): void;
+    /**
+     * 获取监听器数量
+     * @param eventType 事件类型
+     */
+    getListenerCount(eventType: string): number;
+    /**
+     * 设置事件批处理配置
+     * @param eventType 事件类型
+     * @param batchSize 批处理大小
+     * @param delay 延迟时间（毫秒）
+     */
+    setBatchConfig(eventType: string, batchSize: number, delay: number): void;
+    /**
+     * 刷新指定事件的批处理队列
+     * @param eventType 事件类型
+     */
+    flushBatch(eventType: string): void;
+    /**
+     * 重置事件统计
+     * @param eventType 事件类型（可选）
+     */
+    resetStats(eventType?: string): void;
+    /**
+     * 发射实体创建事件
+     * @param entityData 实体事件数据
+     */
+    emitEntityCreated(entityData: IEntityEventData): void;
+    /**
+     * 发射实体销毁事件
+     * @param entityData 实体事件数据
+     */
+    emitEntityDestroyed(entityData: IEntityEventData): void;
+    /**
+     * 发射组件添加事件
+     * @param componentData 组件事件数据
+     */
+    emitComponentAdded(componentData: IComponentEventData): void;
+    /**
+     * 发射组件移除事件
+     * @param componentData 组件事件数据
+     */
+    emitComponentRemoved(componentData: IComponentEventData): void;
+    /**
+     * 发射系统添加事件
+     * @param systemData 系统事件数据
+     */
+    emitSystemAdded(systemData: ISystemEventData): void;
+    /**
+     * 发射系统移除事件
+     * @param systemData 系统事件数据
+     */
+    emitSystemRemoved(systemData: ISystemEventData): void;
+    /**
+     * 发射场景变化事件
+     * @param sceneData 场景事件数据
+     */
+    emitSceneChanged(sceneData: ISceneEventData): void;
+    /**
+     * 发射性能警告事件
+     * @param performanceData 性能事件数据
+     */
+    emitPerformanceWarning(performanceData: IPerformanceEventData): void;
+    /**
+     * 监听实体创建事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onEntityCreated(handler: (data: IEntityEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听组件添加事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onComponentAdded(handler: (data: IComponentEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听系统错误事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onSystemError(handler: (data: ISystemEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听性能警告事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onPerformanceWarning(handler: (data: IPerformanceEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 验证事件类型
+     * @param eventType 事件类型
+     */
+    private validateEventType;
+    /**
+     * 增强事件数据
+     * @param eventType 事件类型
+     * @param data 原始数据
+     */
+    private enhanceEventData;
+    /**
+     * 转换EventStats为IEventStats
+     * @param stats EventStats实例
+     */
+    private convertEventStats;
+}
+
+export declare class GlobalEventBus {
+    private static instance;
+    /**
+     * 获取全局事件总线实例
+     * @param debugMode 是否启用调试模式
+     */
+    static getInstance(debugMode?: boolean): EventBus;
+    /**
+     * 重置全局事件总线实例
+     * @param debugMode 是否启用调试模式
+     */
+    static reset(debugMode?: boolean): EventBus;
+}
+
+export type EventHandler<T = any> = (event: T) => void;
+/**
+ * 异步事件处理器函数类型
+ */
+export type AsyncEventHandler<T = any> = (event: T) => Promise<void>;
+/**
+ * 事件监听器配置
+ */
+export interface EventListenerConfig {
+    /** 是否只执行一次 */
+    once?: boolean;
+    /** 优先级（数字越大优先级越高） */
+    priority?: number;
+    /** 是否异步执行 */
+    async?: boolean;
+    /** 执行上下文 */
+    context?: any;
+}
+
+export interface EventStats {
+    /** 事件类型 */
+    eventType: string;
+    /** 监听器数量 */
+    listenerCount: number;
+    /** 触发次数 */
+    triggerCount: number;
+    /** 总执行时间（毫秒） */
+    totalExecutionTime: number;
+    /** 平均执行时间（毫秒） */
+    averageExecutionTime: number;
+    /** 最后触发时间 */
+    lastTriggerTime: number;
+}
+
+export interface EventBatchConfig {
+    /** 批处理大小 */
+    batchSize: number;
+    /** 批处理延迟（毫秒） */
+    delay: number;
+    /** 是否启用批处理 */
+    enabled: boolean;
+}
+
+export declare class TypeSafeEventSystem {
+    private listeners;
+    private stats;
+    private batchQueue;
+    private batchTimers;
+    private batchConfigs;
+    private nextListenerId;
+    private isEnabled;
+    private maxListeners;
+    /**
+     * 添加事件监听器
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID（用于移除）
+     */
+    on<T>(eventType: string, handler: EventHandler<T>, config?: EventListenerConfig): string;
+    /**
+     * 添加一次性事件监听器
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    once<T>(eventType: string, handler: EventHandler<T>, config?: EventListenerConfig): string;
+    /**
+     * 添加异步事件监听器
+     * @param eventType 事件类型
+     * @param handler 异步事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    onAsync<T>(eventType: string, handler: AsyncEventHandler<T>, config?: EventListenerConfig): string;
+    /**
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
+     * @returns 是否成功移除
+     */
+    off(eventType: string, listenerId: string): boolean;
+    /**
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
+     */
+    offAll(eventType: string): void;
+    /**
+     * 触发事件
+     * @param eventType 事件类型
+     * @param event 事件数据
+     * @returns Promise（如果有异步监听器）
+     */
+    emit<T>(eventType: string, event: T): Promise<void>;
+    /**
+     * 同步触发事件（忽略异步监听器）
+     * @param eventType 事件类型
+     * @param event 事件数据
+     */
+    emitSync<T>(eventType: string, event: T): void;
+    /**
+     * 设置事件批处理配置
+     * @param eventType 事件类型
+     * @param config 批处理配置
+     */
+    setBatchConfig(eventType: string, config: EventBatchConfig): void;
+    /**
+     * 立即处理指定事件类型的批处理队列
+     * @param eventType 事件类型
+     */
+    flushBatch(eventType: string): void;
+    /**
+     * 获取事件统计信息
+     * @param eventType 事件类型（可选）
+     * @returns 统计信息
+     */
+    getStats(eventType?: string): EventStats | Map<string, EventStats>;
+    /**
+     * 重置统计信息
+     * @param eventType 事件类型（可选，不指定则重置所有）
+     */
+    resetStats(eventType?: string): void;
+    /**
+     * 启用/禁用事件系统
+     * @param enabled 是否启用
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 检查是否有指定事件类型的监听器
+     * @param eventType 事件类型
+     * @returns 是否有监听器
+     */
+    hasListeners(eventType: string): boolean;
+    /**
+     * 获取指定事件类型的监听器数量
+     * @param eventType 事件类型
+     * @returns 监听器数量
+     */
+    getListenerCount(eventType: string): number;
+    /**
+     * 清空所有事件监听器和数据
+     */
+    clear(): void;
+    /**
+     * 设置每个事件类型的最大监听器数量
+     * @param max 最大数量
+     */
+    setMaxListeners(max: number): void;
+    /**
+     * 添加监听器的内部实现
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 配置
+     * @returns 监听器ID
+     */
+    private addListener;
+    /**
+     * 执行事件的内部实现
+     * @param eventType 事件类型
+     * @param event 事件数据
+     */
+    private executeEvent;
+    /**
+     * 按优先级排序监听器
+     * @param listeners 监听器数组
+     * @returns 排序后的监听器数组
+     */
+    private sortListenersByPriority;
+    /**
+     * 移除指定的监听器
+     * @param eventType 事件类型
+     * @param listenerIds 要移除的监听器ID数组
+     */
+    private removeListeners;
+    /**
+     * 添加事件到批处理队列
+     * @param eventType 事件类型
+     * @param event 事件数据
+     */
+    private addToBatch;
+    /**
+     * 处理批处理事件
+     * @param eventType 事件类型
+     * @param batch 批处理事件数组
+     */
+    private processBatch;
+    /**
+     * 清除指定事件类型的批处理
+     * @param eventType 事件类型
+     */
+    private clearBatch;
+    /**
+     * 清除所有批处理
+     */
+    private clearAllBatches;
+    /**
+     * 更新事件统计信息
+     * @param eventType 事件类型
+     * @param executionTime 执行时间
+     */
+    private updateStats;
+    /**
+     * 创建空的统计信息
+     * @param eventType 事件类型
+     * @returns 空的统计信息
+     */
+    private createEmptyStats;
+}
+
+export type EventHandler<T = any> = (event: T) => void;
+/**
+ * 异步事件处理器函数类型
+ */
+export type AsyncEventHandler<T = any> = (event: T) => Promise<void>;
+
+export declare class EntityBuilder {
+    private entity;
+    private scene;
+    private storageManager;
+    constructor(scene: Scene, storageManager: ComponentStorageManager);
+    /**
+     * 设置实体名称
+     * @param name 实体名称
+     * @returns 实体构建器
+     */
+    named(name: string): EntityBuilder;
+    /**
+     * 设置实体标签
+     * @param tag 标签
+     * @returns 实体构建器
+     */
+    tagged(tag: number): EntityBuilder;
+    /**
+     * 添加组件
+     * @param component 组件实例
+     * @returns 实体构建器
+     */
+    with<T extends Component>(component: T): EntityBuilder;
+    /**
+     * 添加多个组件
+     * @param components 组件数组
+     * @returns 实体构建器
+     */
+    withComponents(...components: Component[]): EntityBuilder;
+    /**
+     * 条件性添加组件
+     * @param condition 条件
+     * @param component 组件实例
+     * @returns 实体构建器
+     */
+    withIf<T extends Component>(condition: boolean, component: T): EntityBuilder;
+    /**
+     * 使用工厂函数创建并添加组件
+     * @param factory 组件工厂函数
+     * @returns 实体构建器
+     */
+    withFactory<T extends Component>(factory: () => T): EntityBuilder;
+    /**
+     * 配置组件属性
+     * @param componentType 组件类型
+     * @param configurator 配置函数
+     * @returns 实体构建器
+     */
+    configure<T extends Component>(componentType: ComponentType<T>, configurator: (component: T) => void): EntityBuilder;
+    /**
+     * 设置实体为启用状态
+     * @param enabled 是否启用
+     * @returns 实体构建器
+     */
+    enabled(enabled?: boolean): EntityBuilder;
+    /**
+     * 设置实体为活跃状态
+     * @param active 是否活跃
+     * @returns 实体构建器
+     */
+    active(active?: boolean): EntityBuilder;
+    /**
+     * 添加子实体
+     * @param childBuilder 子实体构建器
+     * @returns 实体构建器
+     */
+    withChild(childBuilder: EntityBuilder): EntityBuilder;
+    /**
+     * 批量添加子实体
+     * @param childBuilders 子实体构建器数组
+     * @returns 实体构建器
+     */
+    withChildren(...childBuilders: EntityBuilder[]): EntityBuilder;
+    /**
+     * 使用工厂函数创建子实体
+     * @param childFactory 子实体工厂函数
+     * @returns 实体构建器
+     */
+    withChildFactory(childFactory: (parent: Entity) => EntityBuilder): EntityBuilder;
+    /**
+     * 条件性添加子实体
+     * @param condition 条件
+     * @param childBuilder 子实体构建器
+     * @returns 实体构建器
+     */
+    withChildIf(condition: boolean, childBuilder: EntityBuilder): EntityBuilder;
+    /**
+     * 构建并返回实体
+     * @returns 构建的实体
+     */
+    build(): Entity;
+    /**
+     * 构建实体并添加到场景
+     * @returns 构建的实体
+     */
+    spawn(): Entity;
+    /**
+     * 克隆当前构建器
+     * @returns 新的实体构建器
+     */
+    clone(): EntityBuilder;
+}
+
+export declare class SceneBuilder {
+    private scene;
+    constructor();
+    /**
+     * 设置场景名称
+     * @param name 场景名称
+     * @returns 场景构建器
+     */
+    named(name: string): SceneBuilder;
+    /**
+     * 添加实体
+     * @param entity 实体
+     * @returns 场景构建器
+     */
+    withEntity(entity: Entity): SceneBuilder;
+    /**
+     * 使用实体构建器添加实体
+     * @param builderFn 实体构建器函数
+     * @returns 场景构建器
+     */
+    withEntityBuilder(builderFn: (builder: EntityBuilder) => EntityBuilder): SceneBuilder;
+    /**
+     * 批量添加实体
+     * @param entities 实体数组
+     * @returns 场景构建器
+     */
+    withEntities(...entities: Entity[]): SceneBuilder;
+    /**
+     * 添加系统
+     * @param system 系统实例
+     * @returns 场景构建器
+     */
+    withSystem(system: any): SceneBuilder;
+    /**
+     * 批量添加系统
+     * @param systems 系统数组
+     * @returns 场景构建器
+     */
+    withSystems(...systems: any[]): SceneBuilder;
+    /**
+     * 构建并返回场景
+     * @returns 构建的场景
+     */
+    build(): Scene;
+}
+
+export declare class ComponentBuilder<T extends Component> {
+    private component;
+    constructor(componentClass: new (...args: any[]) => T, ...args: any[]);
+    /**
+     * 设置组件属性
+     * @param property 属性名
+     * @param value 属性值
+     * @returns 组件构建器
+     */
+    set<K extends keyof T>(property: K, value: T[K]): ComponentBuilder<T>;
+    /**
+     * 使用配置函数设置组件
+     * @param configurator 配置函数
+     * @returns 组件构建器
+     */
+    configure(configurator: (component: T) => void): ComponentBuilder<T>;
+    /**
+     * 条件性设置属性
+     * @param condition 条件
+     * @param property 属性名
+     * @param value 属性值
+     * @returns 组件构建器
+     */
+    setIf<K extends keyof T>(condition: boolean, property: K, value: T[K]): ComponentBuilder<T>;
+    /**
+     * 构建并返回组件
+     * @returns 构建的组件
+     */
+    build(): T;
+}
+
+export declare class ECSFluentAPI {
+    private scene;
+    private querySystem;
+    private eventSystem;
+    constructor(scene: Scene, querySystem: QuerySystem, eventSystem: TypeSafeEventSystem);
+    /**
+     * 创建实体构建器
+     * @returns 实体构建器
+     */
+    createEntity(): EntityBuilder;
+    /**
+     * 创建场景构建器
+     * @returns 场景构建器
+     */
+    createScene(): SceneBuilder;
+    /**
+     * 创建组件构建器
+     * @param componentClass 组件类
+     * @param args 构造参数
+     * @returns 组件构建器
+     */
+    createComponent<T extends Component>(componentClass: new (...args: any[]) => T, ...args: any[]): ComponentBuilder<T>;
+    /**
+     * 创建查询构建器
+     * @returns 查询构建器
+     */
+    query(): QueryBuilder;
+    /**
+     * 查找实体（简化版）
+     * @param componentTypes 组件类型
+     * @returns 实体数组
+     */
+    find(...componentTypes: ComponentType[]): Entity[];
+    /**
+     * 查找第一个匹配的实体
+     * @param componentTypes 组件类型
+     * @returns 实体或null
+     */
+    findFirst(...componentTypes: ComponentType[]): Entity | null;
+    /**
+     * 按名称查找实体
+     * @param name 实体名称
+     * @returns 实体或null
+     */
+    findByName(name: string): Entity | null;
+    /**
+     * 按标签查找实体
+     * @param tag 标签
+     * @returns 实体数组
+     */
+    findByTag(tag: number): Entity[];
+    /**
+     * 触发事件
+     * @param eventType 事件类型
+     * @param event 事件数据
+     */
+    emit<T>(eventType: string, event: T): void;
+    /**
+     * 异步触发事件
+     * @param eventType 事件类型
+     * @param event 事件数据
+     */
+    emitAsync<T>(eventType: string, event: T): Promise<void>;
+    /**
+     * 监听事件
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @returns 监听器ID
+     */
+    on<T>(eventType: string, handler: (event: T) => void): string;
+    /**
+     * 一次性监听事件
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @returns 监听器ID
+     */
+    once<T>(eventType: string, handler: (event: T) => void): string;
+    /**
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
+     */
+    off(eventType: string, listenerId: string): void;
+    /**
+     * 批量操作实体
+     * @param entities 实体数组
+     * @returns 批量操作器
+     */
+    batch(entities: Entity[]): EntityBatchOperator;
+    /**
+     * 获取场景统计信息
+     * @returns 统计信息
+     */
+    getStats(): {
+        entityCount: number;
+        systemCount: number;
+        componentStats: Map<string, any>;
+        queryStats: any;
+        eventStats: Map<string, any>;
+    }
+
+export declare class EntityBatchOperator {
+    private entities;
+    constructor(entities: Entity[]);
+    /**
+     * 批量添加组件
+     * @param component 组件实例
+     * @returns 批量操作器
+     */
+    addComponent<T extends Component>(component: T): EntityBatchOperator;
+    /**
+     * 批量移除组件
+     * @param componentType 组件类型
+     * @returns 批量操作器
+     */
+    removeComponent<T extends Component>(componentType: ComponentType<T>): EntityBatchOperator;
+    /**
+     * 批量设置活跃状态
+     * @param active 是否活跃
+     * @returns 批量操作器
+     */
+    setActive(active: boolean): EntityBatchOperator;
+    /**
+     * 批量设置标签
+     * @param tag 标签
+     * @returns 批量操作器
+     */
+    setTag(tag: number): EntityBatchOperator;
+    /**
+     * 批量执行操作
+     * @param operation 操作函数
+     * @returns 批量操作器
+     */
+    forEach(operation: (entity: Entity, index: number) => void): EntityBatchOperator;
+    /**
+     * 过滤实体
+     * @param predicate 过滤条件
+     * @returns 新的批量操作器
+     */
+    filter(predicate: (entity: Entity) => boolean): EntityBatchOperator;
+    /**
+     * 获取实体数组
+     * @returns 实体数组
+     */
+    toArray(): Entity[];
+    /**
+     * 获取实体数量
+     * @returns 实体数量
+     */
+    count(): number;
+}
+
+export declare enum IndexUpdateType {
+    ADD_ENTITY = "add_entity",
+    REMOVE_ENTITY = "remove_entity",
+    UPDATE_ENTITY = "update_entity"
+}
+
+export interface IndexUpdateOperation {
+    type: IndexUpdateType;
+    entity: Entity;
+    oldMask?: bigint;
+    newMask?: bigint;
+}
+
+export declare class IndexUpdateBatcher {
+    private pendingOperations;
+    private isProcessing;
+    private batchSize;
+    private flushTimeout;
+    private flushDelay;
+    /**
+     * 添加索引更新操作
+     */
+    addOperation(operation: IndexUpdateOperation): void;
+    /**
+     * 批量添加实体
+     */
+    addEntities(entities: Entity[]): void;
+    /**
+     * 批量移除实体
+     */
+    removeEntities(entities: Entity[]): void;
+    /**
+     * 批量更新实体
+     */
+    updateEntities(updates: Array<{
+        entity: Entity;
+        oldMask: bigint;
+        newMask: bigint;
+    }
+
+export declare enum QueryConditionType {
+    /** 必须包含所有指定组件 */
+    ALL = "all",
+    /** 必须包含任意一个指定组件 */
+    ANY = "any",
+    /** 不能包含任何指定组件 */
+    NONE = "none"
+}
+
+export interface QueryCondition {
+    type: QueryConditionType;
+    componentTypes: ComponentType[];
+    mask: bigint;
+}
+
+export interface QueryResult {
+    entities: Entity[];
+    count: number;
+    /** 查询执行时间（毫秒） */
+    executionTime: number;
+    /** 是否来自缓存 */
+    fromCache: boolean;
+}
+
+export declare class QuerySystem {
+    private entities;
+    private wasmAvailable;
+    private entityIndex;
+    private indexDirty;
+    private queryCache;
+    private cacheMaxSize;
+    private cacheTimeout;
+    private componentPoolManager;
+    private bitMaskOptimizer;
+    private indexUpdateBatcher;
+    private componentIndexManager;
+    private archetypeSystem;
+    private dirtyTrackingSystem;
+    private queryStats;
+    constructor();
+    /**
+     * 初始化WebAssembly支持
+     *
+     * 自动检测运行环境并启用WebAssembly计算加速。
+     * 如果WebAssembly不可用，系统将自动回退到JavaScript实现。
+     */
+    private initializeWasm;
+    /**
+     * 设置实体列表并重建索引
+     *
+     * 当实体集合发生大规模变化时调用此方法。
+     * 系统将重新构建所有索引以确保查询性能。
+     *
+     * @param entities 新的实体列表
+     */
+    setEntities(entities: Entity[]): void;
+    /**
+     * 添加单个实体到查询系统
+     *
+     * 将新实体添加到查询系统中，并自动更新相关索引。
+     * 为了提高批量添加性能，可以延迟缓存清理。
+     *
+     * @param entity 要添加的实体
+     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
+     */
+    addEntity(entity: Entity, deferCacheClear?: boolean): void;
+    /**
+     * 批量添加实体
+     *
+     * 高效地批量添加多个实体，减少缓存清理次数。
+     * 使用Set来避免O(n)的重复检查。
+     *
+     * @param entities 要添加的实体列表
+     */
+    addEntities(entities: Entity[]): void;
+    /**
+     * 批量添加实体（无重复检查版本）
+     *
+     * 假设所有实体都是新的，跳过重复检查以获得最大性能。
+     * 仅在确保没有重复实体时使用。
+     *
+     * @param entities 要添加的实体列表
+     */
+    addEntitiesUnchecked(entities: Entity[]): void;
+    /**
+     * 从查询系统移除实体
+     *
+     * 从查询系统中移除指定实体，并清理相关索引。
+     *
+     * @param entity 要移除的实体
+     */
+    removeEntity(entity: Entity): void;
+    /**
+     * 将实体添加到各种索引中（优化版本）
+     */
+    private addEntityToIndexes;
+    /**
+     * 从各种索引中移除实体
+     */
+    private removeEntityFromIndexes;
+    /**
+     * 重建所有索引
+     *
+     * 清空并重新构建所有查询索引。
+     * 通常在大量实体变更后调用以确保索引一致性。
+     */
+    private rebuildIndexes;
+    /**
+     * 查询包含所有指定组件的实体
+     *
+     * 返回同时包含所有指定组件类型的实体列表。
+     * 系统会自动选择最高效的查询策略，包括索引查找和缓存机制。
+     *
+     * @param componentTypes 要查询的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询同时具有位置和速度组件的实体
+     * const result = querySystem.queryAll(PositionComponent, VelocityComponent);
+     * console.log(`找到 ${result.count}
+
+export declare class QueryBuilder {
+    private conditions;
+    private querySystem;
+    constructor(querySystem: QuerySystem);
+    /**
+     * 添加"必须包含所有组件"条件
+     *
+     * @param componentTypes 必须包含的组件类型
+     * @returns 查询构建器实例，支持链式调用
+     */
+    withAll(...componentTypes: ComponentType[]): QueryBuilder;
+    /**
+     * 添加"必须包含任意组件"条件
+     *
+     * @param componentTypes 必须包含其中任意一个的组件类型
+     * @returns 查询构建器实例，支持链式调用
+     */
+    withAny(...componentTypes: ComponentType[]): QueryBuilder;
+    /**
+     * 添加"不能包含任何组件"条件
+     *
+     * @param componentTypes 不能包含的组件类型
+     * @returns 查询构建器实例，支持链式调用
+     */
+    without(...componentTypes: ComponentType[]): QueryBuilder;
+    /**
+     * 执行查询并返回结果
+     *
+     * 根据已添加的查询条件执行实体查询。
+     *
+     * @returns 查询结果，包含匹配的实体和性能信息
+     */
+    execute(): QueryResult;
+    /**
+     * 创建组件掩码
+     */
+    private createComponentMask;
+    /**
+     * 重置查询构建器
+     *
+     * 清除所有已添加的查询条件，重新开始构建查询。
+     *
+     * @returns 查询构建器实例，支持链式调用
+     */
+    reset(): QueryBuilder;
+}
+
+export declare enum CoreEvents {
+    /**
+     * 当场景发生变化时触发
+     */
+    sceneChanged = 0,
+    /**
+     * 每帧更新事件
+     */
+    frameUpdated = 1,
+    /**
+     * 当渲染发生时触发
+     */
+    renderChanged = 2
+}
+
+export declare enum ECSEventType {
+    ENTITY_CREATED = "entity:created",
+    ENTITY_DESTROYED = "entity:destroyed",
+    ENTITY_ENABLED = "entity:enabled",
+    ENTITY_DISABLED = "entity:disabled",
+    ENTITY_TAG_ADDED = "entity:tag:added",
+    ENTITY_TAG_REMOVED = "entity:tag:removed",
+    ENTITY_NAME_CHANGED = "entity:name:changed",
+    COMPONENT_ADDED = "component:added",
+    COMPONENT_REMOVED = "component:removed",
+    COMPONENT_MODIFIED = "component:modified",
+    COMPONENT_ENABLED = "component:enabled",
+    COMPONENT_DISABLED = "component:disabled",
+    SYSTEM_ADDED = "system:added",
+    SYSTEM_REMOVED = "system:removed",
+    SYSTEM_ENABLED = "system:enabled",
+    SYSTEM_DISABLED = "system:disabled",
+    SYSTEM_PROCESSING_START = "system:processing:start",
+    SYSTEM_PROCESSING_END = "system:processing:end",
+    SYSTEM_ERROR = "system:error",
+    SCENE_CREATED = "scene:created",
+    SCENE_DESTROYED = "scene:destroyed",
+    SCENE_ACTIVATED = "scene:activated",
+    SCENE_DEACTIVATED = "scene:deactivated",
+    SCENE_PAUSED = "scene:paused",
+    SCENE_RESUMED = "scene:resumed",
+    QUERY_EXECUTED = "query:executed",
+    QUERY_CACHE_HIT = "query:cache:hit",
+    QUERY_CACHE_MISS = "query:cache:miss",
+    QUERY_OPTIMIZED = "query:optimized",
+    PERFORMANCE_WARNING = "performance:warning",
+    PERFORMANCE_CRITICAL = "performance:critical",
+    MEMORY_USAGE_HIGH = "memory:usage:high",
+    FRAME_RATE_DROP = "frame:rate:drop",
+    INDEX_CREATED = "index:created",
+    INDEX_UPDATED = "index:updated",
+    INDEX_OPTIMIZED = "index:optimized",
+    ARCHETYPE_CREATED = "archetype:created",
+    ARCHETYPE_ENTITY_ADDED = "archetype:entity:added",
+    ARCHETYPE_ENTITY_REMOVED = "archetype:entity:removed",
+    DIRTY_MARK_ADDED = "dirty:mark:added",
+    DIRTY_BATCH_PROCESSED = "dirty:batch:processed",
+    ERROR_OCCURRED = "error:occurred",
+    WARNING_ISSUED = "warning:issued",
+    FRAMEWORK_INITIALIZED = "framework:initialized",
+    FRAMEWORK_SHUTDOWN = "framework:shutdown",
+    DEBUG_INFO = "debug:info",
+    DEBUG_STATS_UPDATED = "debug:stats:updated"
+}
+
+export declare enum EventPriority {
+    LOWEST = 0,
+    LOW = 25,
+    NORMAL = 50,
+    HIGH = 75,
+    HIGHEST = 100,
+    CRITICAL = 200
+}
+
+export declare const EVENT_TYPES: {
+    readonly CORE: {
+        readonly SCENE_CHANGED: "core:scene:changed";
+        readonly FRAME_UPDATED: "core:frame:updated";
+        readonly RENDER_CHANGED: "core:render:changed";
+    }
+
+export declare class EventTypeValidator {
+    private static validTypes;
+    /**
+     * 验证事件类型是否有效
+     * @param eventType 事件类型
+     * @returns 是否有效
+     */
+    static isValid(eventType: string): boolean;
+    /**
+     * 获取所有有效的事件类型
+     * @returns 事件类型数组
+     */
+    static getAllValidTypes(): string[];
+    /**
+     * 添加自定义事件类型
+     * @param eventType 事件类型
+     */
+    static addCustomType(eventType: string): void;
+    /**
+     * 移除自定义事件类型
+     * @param eventType 事件类型
+     */
+    static removeCustomType(eventType: string): void;
+}
+
+export declare class EntityComparer {
+    /**
+     * 比较两个实体
+     *
+     * @param self - 第一个实体
+     * @param other - 第二个实体
+     * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
+     */
+    compare(self: Entity, other: Entity): number;
+}
+
+export declare class Entity {
+    /**
+     * 实体比较器实例
+     */
+    static entityComparer: EntityComparer;
+    /**
+     * 全局事件总线实例
+     * 用于发射组件相关事件
+     */
+    static eventBus: EventBus | null;
+    /**
+     * 实体名称
+     *
+     * 用于标识和调试的友好名称。
+     */
+    name: string;
+    /**
+     * 实体唯一标识符
+     *
+     * 在场景中唯一的数字标识符。
+     */
+    readonly id: number;
+    /**
+     * 组件集合
+     *
+     * 存储实体拥有的所有组件。
+     */
+    readonly components: Component[];
+    /**
+     * 所属场景引用
+     *
+     * 指向实体所在的场景实例。
+     */
+    scene: any;
+    /**
+     * 更新间隔
+     *
+     * 控制实体更新的频率，值越大更新越不频繁。
+     */
+    updateInterval: number;
+    /**
+     * 销毁状态标志
+     *
+     * 标记实体是否已被销毁。
+     */
+    _isDestroyed: boolean;
+    /**
+     * 父实体引用
+     *
+     * 指向父级实体，用于构建实体层次结构。
+     */
+    private _parent;
+    /**
+     * 子实体集合
+     *
+     * 存储所有子级实体的数组。
+     */
+    private _children;
+    /**
+     * 激活状态
+     *
+     * 控制实体是否处于激活状态。
+     */
+    private _active;
+    /**
+     * 实体标签
+     *
+     * 用于分类和查询的数字标签。
+     */
+    private _tag;
+    /**
+     * 启用状态
+     *
+     * 控制实体是否启用更新和处理。
+     */
+    private _enabled;
+    /**
+     * 更新顺序
+     *
+     * 控制实体在系统中的更新优先级。
+     */
+    private _updateOrder;
+    /**
+     * 组件位掩码
+     *
+     * 用于快速查询实体拥有的组件类型。
+     */
+    private _componentMask;
+    /**
+     * 组件类型到索引的映射
+     *
+     * 用于快速定位组件在数组中的位置。
+     */
+    private _componentTypeToIndex;
+    /**
+     * 组件缓存
+     *
+     * 高性能组件访问缓存。
+     */
+    private _componentCache;
+    /**
+     * 组件访问统计
+     *
+     * 记录组件访问的性能统计信息。
+     */
+    private _componentAccessStats;
+    /**
+     * 构造函数
+     *
+     * @param name - 实体名称
+     * @param id - 实体唯一标识符
+     */
+    constructor(name: string, id: number);
+    /**
+     * 获取销毁状态
+     *
+     * @returns 如果实体已被销毁则返回true
+     */
+    get isDestroyed(): boolean;
+    /**
+     * 获取父实体
+     *
+     * @returns 父实体，如果没有父实体则返回null
+     */
+    get parent(): Entity | null;
+    /**
+     * 获取子实体数组的只读副本
+     *
+     * @returns 子实体数组的副本
+     */
+    get children(): readonly Entity[];
+    /**
+     * 获取子实体数量
+     *
+     * @returns 子实体的数量
+     */
+    get childCount(): number;
+    /**
+     * 获取活跃状态
+     *
+     * @returns 如果实体处于活跃状态则返回true
+     */
+    get active(): boolean;
+    /**
+     * 设置活跃状态
+     *
+     * 设置实体的活跃状态，会影响子实体的有效活跃状态。
+     *
+     * @param value - 新的活跃状态
+     */
+    set active(value: boolean);
+    /**
+     * 获取实体的有效活跃状态
+     *
+     * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
+     *
+     * @returns 有效的活跃状态
+     */
+    get activeInHierarchy(): boolean;
+    /**
+     * 获取实体标签
+     *
+     * @returns 实体的数字标签
+     */
+    get tag(): number;
+    /**
+     * 设置实体标签
+     *
+     * @param value - 新的标签值
+     */
+    set tag(value: number);
+    /**
+     * 获取启用状态
+     *
+     * @returns 如果实体已启用则返回true
+     */
+    get enabled(): boolean;
+    /**
+     * 设置启用状态
+     *
+     * @param value - 新的启用状态
+     */
+    set enabled(value: boolean);
+    /**
+     * 获取更新顺序
+     *
+     * @returns 实体的更新顺序值
+     */
+    get updateOrder(): number;
+    /**
+     * 设置更新顺序
+     *
+     * @param value - 新的更新顺序值
+     */
+    set updateOrder(value: number);
+    /**
+     * 获取组件位掩码
+     *
+     * @returns 实体的组件位掩码
+     */
+    get componentMask(): bigint;
+    /**
+     * 创建并添加组件
+     *
+     * @param componentType - 组件类型
+     * @param args - 组件构造函数参数
+     * @returns 创建的组件实例
+     */
+    createComponent<T extends Component>(componentType: ComponentType<T>, ...args: any[]): T;
+    /**
+     * 内部添加组件方法（不进行重复检查，用于初始化）
+     *
+     * @param component - 要添加的组件实例
+     * @returns 添加的组件实例
+     */
+    private addComponentInternal;
+    /**
+     * 添加组件到实体
+     *
+     * @param component - 要添加的组件实例
+     * @returns 添加的组件实例
+     * @throws {Error}
+
+export declare class Scene {
+    /**
+     * 场景名称
+     *
+     * 用于标识和调试的友好名称。
+     */
+    name: string;
+    /**
+     * 场景中的实体集合
+     *
+     * 管理场景内所有实体的生命周期。
+     */
+    readonly entities: EntityList;
+    /**
+     * 实体系统处理器集合
+     *
+     * 管理场景内所有实体系统的执行。
+     */
+    readonly entityProcessors: EntityProcessorList;
+    /**
+     * 实体ID池
+     *
+     * 用于分配和回收实体的唯一标识符。
+     */
+    readonly identifierPool: IdentifierPool;
+    /**
+     * 组件存储管理器
+     *
+     * 高性能的组件存储和查询系统。
+     */
+    readonly componentStorageManager: ComponentStorageManager;
+    /**
+     * 查询系统
+     *
+     * 基于位掩码的高性能实体查询系统。
+     */
+    readonly querySystem: QuerySystem;
+    /**
+     * 事件系统
+     *
+     * 类型安全的事件系统。
+     */
+    readonly eventSystem: TypeSafeEventSystem;
+    /**
+     * 场景是否已开始运行
+     */
+    private _didSceneBegin;
+    /**
+     * 获取系统列表（兼容性属性）
+     */
+    get systems(): EntitySystem[];
+    /**
+     * 创建场景实例
+     * @param enableWasmAcceleration 是否启用WebAssembly加速，默认为true
+     */
+    constructor(enableWasmAcceleration?: boolean);
+    /**
+     * 初始化场景
+     *
+     * 在场景创建时调用，子类可以重写此方法来设置初始实体和组件。
+     */
+    initialize(): void;
+    /**
+     * 场景开始运行时的回调
+     *
+     * 在场景开始运行时调用，可以在此方法中执行场景启动逻辑。
+     */
+    onStart(): void;
+    /**
+     * 场景卸载时的回调
+     *
+     * 在场景被销毁时调用，可以在此方法中执行清理工作。
+     */
+    unload(): void;
+    /**
+     * 开始场景，启动实体处理器等
+     *
+     * 这个方法会启动场景。它将启动实体处理器等，并调用onStart方法。
+     */
+    begin(): void;
+    /**
+     * 结束场景，清除实体、实体处理器等
+     *
+     * 这个方法会结束场景。它将移除所有实体，结束实体处理器等，并调用unload方法。
+     */
+    end(): void;
+    /**
+     * 更新场景，更新实体组件、实体处理器等
+     */
+    update(): void;
+    /**
+     * 将实体添加到此场景，并返回它
+     * @param name 实体名称
+     */
+    createEntity(name: string): Entity;
+    /**
+     * 在场景的实体列表中添加一个实体
+     * @param entity 要添加的实体
+     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
+     */
+    addEntity(entity: Entity, deferCacheClear?: boolean): Entity;
+    /**
+     * 批量创建实体（高性能版本）
+     * @param count 要创建的实体数量
+     * @param namePrefix 实体名称前缀
+     * @returns 创建的实体列表
+     */
+    createEntities(count: number, namePrefix?: string): Entity[];
+    /**
+     * 批量创建实体
+     * @param count 要创建的实体数量
+     * @param namePrefix 实体名称前缀
+     * @returns 创建的实体列表
+     */
+    createEntitiesOld(count: number, namePrefix?: string): Entity[];
+    /**
+     * 从场景中删除所有实体
+     */
+    destroyAllEntities(): void;
+    /**
+     * 搜索并返回第一个具有名称的实体
+     * @param name 实体名称
+     */
+    findEntity(name: string): Entity | null;
+    /**
+     * 根据ID查找实体
+     * @param id 实体ID
+     */
+    findEntityById(id: number): Entity | null;
+    /**
+     * 根据标签查找实体
+     * @param tag 实体标签
+     */
+    findEntitiesByTag(tag: number): Entity[];
+    /**
+     * 根据名称查找实体（别名方法）
+     * @param name 实体名称
+     */
+    getEntityByName(name: string): Entity | null;
+    /**
+     * 根据标签查找实体（别名方法）
+     * @param tag 实体标签
+     */
+    getEntitiesByTag(tag: number): Entity[];
+    /**
+     * 在场景中添加一个EntitySystem处理器
+     * @param processor 处理器
+     */
+    addEntityProcessor(processor: EntitySystem): EntitySystem;
+    /**
+     * 添加系统到场景（addEntityProcessor的别名）
+     * @param system 系统
+     */
+    addSystem(system: EntitySystem): EntitySystem;
+    /**
+     * 从场景中删除EntitySystem处理器
+     * @param processor 要删除的处理器
+     */
+    removeEntityProcessor(processor: EntitySystem): void;
+    /**
+     * 获取指定类型的EntitySystem处理器
+     * @param type 处理器类型
+     */
+    getEntityProcessor<T extends EntitySystem>(type: new (...args: any[]) => T): T | null;
+    /**
+     * 获取场景统计信息
+     */
+    getStats(): {
+        entityCount: number;
+        processorCount: number;
+        componentStorageStats: Map<string, any>;
+    }
+
+export declare class Bits {
+    private _words;
+    private static readonly WORD_SIZE;
+    constructor();
+    /**
+     * 设置指定位置的位为1
+     * @param index 位置索引
+     */
+    set(index: number): void;
+    /**
+     * 清除指定位置的位（设为0）
+     * @param index 位置索引
+     */
+    clear(index: number): void;
+    /**
+     * 获取指定位置的位值
+     * @param index 位置索引
+     * @returns 位值（true或false）
+     */
+    get(index: number): boolean;
+    /**
+     * 检查是否包含所有指定的位
+     * @param other 另一个Bits对象
+     * @returns 如果包含所有位则返回true
+     */
+    containsAll(other: Bits): boolean;
+    /**
+     * 检查是否包含任意一个指定的位
+     * @param other 另一个Bits对象
+     * @returns 如果包含任意位则返回true
+     */
+    intersects(other: Bits): boolean;
+    /**
+     * 检查是否不包含任何指定的位
+     * @param other 另一个Bits对象
+     * @returns 如果不包含任何位则返回true
+     */
+    excludes(other: Bits): boolean;
+    /**
+     * 清空所有位
+     */
+    clearAll(): void;
+    /**
+     * 检查是否为空（没有设置任何位）
+     * @returns 如果为空则返回true
+     */
+    isEmpty(): boolean;
+    /**
+     * 获取设置的位数量
+     * @returns 设置的位数量
+     */
+    cardinality(): number;
+    /**
+     * 计算一个32位整数中设置的位数量
+     * @param n 32位整数
+     * @returns 设置的位数量
+     */
+    private popCount;
+    /**
+     * 复制另一个Bits对象
+     * @param other 要复制的Bits对象
+     */
+    copyFrom(other: Bits): void;
+    /**
+     * 创建当前Bits的副本
+     * @returns 新的Bits对象
+     */
+    clone(): Bits;
+}
+
+export declare class ComponentTypeManager {
+    private static _instance;
+    private _componentTypes;
+    private _typeNames;
+    private _nextTypeId;
+    /**
+     * 获取单例实例
+     */
+    static get instance(): ComponentTypeManager;
+    private constructor();
+    /**
+     * 获取组件类型的ID
+     * @param componentType 组件类型构造函数
+     * @returns 组件类型ID
+     */
+    getTypeId<T extends Component>(componentType: new (...args: any[]) => T): number;
+    /**
+     * 获取组件类型名称
+     * @param typeId 组件类型ID
+     * @returns 组件类型名称
+     */
+    getTypeName(typeId: number): string;
+    /**
+     * 创建包含指定组件类型的Bits对象
+     * @param componentTypes 组件类型构造函数数组
+     * @returns Bits对象
+     */
+    createBits(...componentTypes: (new (...args: any[]) => Component)[]): Bits;
+    /**
+     * 获取实体的组件位掩码
+     * @param components 组件数组
+     * @returns Bits对象
+     */
+    getEntityBits(components: Component[]): Bits;
+    /**
+     * 重置管理器（主要用于测试）
+     */
+    reset(): void;
+    /**
+     * 获取已注册的组件类型数量
+     */
+    get registeredTypeCount(): number;
+}
+
+export declare class EntityList {
+    buffer: Entity[];
+    private _scene;
+    private _idToEntity;
+    private _nameToEntities;
+    private _entitiesToAdd;
+    private _entitiesToRemove;
+    private _isUpdating;
+    get count(): number;
+    constructor(scene: any);
+    /**
+     * 添加实体（立即添加或延迟添加）
+     * @param entity 要添加的实体
+     */
+    add(entity: Entity): void;
+    /**
+     * 立即添加实体
+     * @param entity 要添加的实体
+     */
+    private addImmediate;
+    /**
+     * 移除实体（立即移除或延迟移除）
+     * @param entity 要移除的实体
+     */
+    remove(entity: Entity): void;
+    /**
+     * 立即移除实体
+     * @param entity 要移除的实体
+     */
+    private removeImmediate;
+    /**
+     * 移除所有实体
+     */
+    removeAllEntities(): void;
+    /**
+     * 更新实体列表，处理延迟操作
+     */
+    updateLists(): void;
+    /**
+     * 更新所有实体
+     */
+    update(): void;
+    /**
+     * 根据名称查找实体（使用索引，O(1)复杂度）
+     * @param name 实体名称
+     * @returns 找到的第一个实体或null
+     */
+    findEntity(name: string): Entity | null;
+    /**
+     * 根据名称查找所有实体
+     * @param name 实体名称
+     * @returns 找到的所有实体数组
+     */
+    findEntitiesByName(name: string): Entity[];
+    /**
+     * 根据ID查找实体（使用索引，O(1)复杂度）
+     * @param id 实体ID
+     * @returns 找到的实体或null
+     */
+    findEntityById(id: number): Entity | null;
+    /**
+     * 根据标签查找实体
+     * @param tag 标签
+     * @returns 找到的所有实体数组
+     */
+    findEntitiesByTag(tag: number): Entity[];
+    /**
+     * 根据组件类型查找实体
+     * @param componentType 组件类型
+     * @returns 找到的所有实体数组
+     */
+    findEntitiesWithComponent<T extends Component>(componentType: new (...args: any[]) => T): Entity[];
+    /**
+     * 批量操作：对所有实体执行指定操作
+     * @param action 要执行的操作
+     */
+    forEach(action: (entity: Entity) => void): void;
+    /**
+     * 批量操作：对符合条件的实体执行指定操作
+     * @param predicate 筛选条件
+     * @param action 要执行的操作
+     */
+    forEachWhere(predicate: (entity: Entity) => boolean, action: (entity: Entity) => void): void;
+    /**
+     * 更新名称索引
+     * @param entity 实体
+     * @param isAdd 是否为添加操作
+     */
+    private updateNameIndex;
+    /**
+     * 获取实体列表的统计信息
+     * @returns 统计信息
+     */
+    getStats(): {
+        totalEntities: number;
+        activeEntities: number;
+        pendingAdd: number;
+        pendingRemove: number;
+        nameIndexSize: number;
+    }
+
+export declare class EntityProcessorList {
+    private _processors;
+    private _isDirty;
+    /**
+     * 设置为脏状态，需要重新排序
+     */
+    setDirty(): void;
+    /**
+     * 添加实体处理器
+     * @param processor 要添加的处理器
+     */
+    add(processor: EntitySystem): void;
+    /**
+     * 移除实体处理器
+     * @param processor 要移除的处理器
+     */
+    remove(processor: EntitySystem): void;
+    /**
+     * 获取指定类型的处理器
+     * @param type 处理器类型
+     */
+    getProcessor<T extends EntitySystem>(type: new (...args: any[]) => T): T | null;
+    /**
+     * 开始处理
+     */
+    begin(): void;
+    /**
+     * 结束处理
+     */
+    end(): void;
+    /**
+     * 更新所有处理器
+     */
+    update(): void;
+    /**
+     * 后期更新所有处理器
+     */
+    lateUpdate(): void;
+    /**
+     * 排序处理器
+     */
+    private sortProcessors;
+    /** 获取处理器列表 */
+    get processors(): EntitySystem[];
+    /** 获取处理器数量 */
+    get count(): number;
+}
+
+export declare class IdentifierPool {
+    private _nextAvailableId;
+    private _ids;
+    /**
+     * 获取一个可用的ID
+     */
+    checkOut(): number;
+    /**
+     * 回收一个ID
+     * @param id 要回收的ID
+     */
+    checkIn(id: number): void;
+}
+
+export declare class Matcher {
+    protected allSet: (new (...args: any[]) => Component)[];
+    protected exclusionSet: (new (...args: any[]) => Component)[];
+    protected oneSet: (new (...args: any[]) => Component)[];
+    private _allBits?;
+    private _exclusionBits?;
+    private _oneBits?;
+    private _isDirty;
+    static empty(): Matcher;
+    getAllSet(): (new (...args: any[]) => Component)[];
+    getExclusionSet(): (new (...args: any[]) => Component)[];
+    getOneSet(): (new (...args: any[]) => Component)[];
+    /**
+     * 检查实体是否匹配条件
+     * @param entity 要检查的实体
+     * @returns 是否匹配
+     */
+    isInterestedEntity(entity: Entity): boolean;
+    /**
+     * 检查组件位掩码是否匹配条件
+     * @param componentBits 组件位掩码
+     * @returns 是否匹配
+     */
+    isInterested(componentBits: Bits): boolean;
+    /**
+     * 添加所有包含的组件类型
+     * @param types 所有包含的组件类型列表
+     */
+    all(...types: (new (...args: any[]) => Component)[]): Matcher;
+    /**
+     * 添加排除包含的组件类型
+     * @param types 排除包含的组件类型列表
+     */
+    exclude(...types: (new (...args: any[]) => Component)[]): Matcher;
+    /**
+     * 添加至少包含其中之一的组件类型
+     * @param types 至少包含其中之一的组件类型列表
+     */
+    one(...types: (new (...args: any[]) => Component)[]): Matcher;
+    /**
+     * 获取实体的组件位掩码
+     * @param entity 实体
+     * @returns 组件位掩码
+     */
+    private getEntityBits;
+    /**
+     * 如果位掩码已过期，则更新它们
+     */
+    private updateBitsIfDirty;
+    /**
+     * 创建匹配器的字符串表示（用于调试）
+     * @returns 字符串表示
+     */
+    toString(): string;
+}
+
+export declare class TestRunner {
+    private results;
+    /**
+     * 运行所有单元测试
+     */
+    runUnitTests(): Promise<void>;
+    /**
+     * 运行性能测试
+     */
+    runPerformanceTests(): Promise<void>;
+    /**
+     * 运行集成测试
+     */
+    runIntegrationTests(): Promise<void>;
+    /**
+     * 运行所有测试
+     */
+    runAllTests(): Promise<void>;
+    /**
+     * 运行单个测试
+     */
+    private runTest;
+    /**
+     * 打印测试摘要
+     */
+    private printSummary;
+    /**
+     * 打印最终测试摘要
+     */
+    private printFinalSummary;
+    /**
+     * 清除测试结果
+     */
+    clearResults(): void;
+}
+
+export declare class FuncPack {
+    /** 函数 */
+    func: Function;
+    /** 上下文 */
+    context: any;
+    constructor(func: Function, context: any);
+}
+
+export declare class Emitter<T> {
+    private _messageTable;
+    constructor();
+    /**
+     * 开始监听项
+     * @param eventType 监听类型
+     * @param handler 监听函数
+     * @param context 监听上下文
+     */
+    addObserver(eventType: T, handler: Function, context: any): void;
+    /**
+     * 移除监听项
+     * @param eventType 事件类型
+     * @param handler 事件函数
+     */
+    removeObserver(eventType: T, handler: Function): void;
+    /**
+     * 触发该事件
+     * @param eventType 事件类型
+     * @param data 事件数据
+     */
+    emit(eventType: T, ...data: any[]): void;
+    /**
+     * 判断是否存在该类型的观察者
+     * @param eventType 事件类型
+     * @param handler 事件函数
+     */
+    hasObserver(eventType: T, handler: Function): boolean;
+}
+
+export declare class NumberExtension {
+    /**
+     * 将值转换为数字
+     * @param value 要转换的值
+     * @returns 转换后的数字，如果值为undefined则返回0
+     */
+    static toNumber(value: any): number;
+}
+
+export declare class TypeUtils {
+    /**
+     * 获取对象的类型
+     * @param obj 对象
+     * @returns 对象的构造函数
+     */
+    static getType(obj: any): any;
+}
+
+export declare class GlobalManager {
+    /**
+     * 表示管理器是否启用
+     */
+    _enabled: boolean;
+    /**
+     * 获取或设置管理器是否启用
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * 设置管理器是否启用
+     * @param isEnabled 如果为true，则启用管理器；否则禁用管理器
+     */
+    setEnabled(isEnabled: boolean): void;
+    /**
+     * 在启用管理器时调用的回调方法
+     */
+    protected onEnabled(): void;
+    /**
+     * 在禁用管理器时调用的回调方法
+     */
+    protected onDisabled(): void;
+    /**
+     * 更新管理器状态的方法
+     */
+    update(): void;
+}
+
+export interface PerformanceData {
+    /** 系统名称 */
+    name: string;
+    /** 执行时间（毫秒） */
+    executionTime: number;
+    /** 处理的实体数量 */
+    entityCount: number;
+    /** 平均每个实体的处理时间 */
+    averageTimePerEntity: number;
+    /** 最后更新时间戳 */
+    lastUpdateTime: number;
+    /** 内存使用量（字节） */
+    memoryUsage?: number;
+    /** CPU使用率（百分比） */
+    cpuUsage?: number;
+}
+
+export interface PerformanceStats {
+    /** 总执行时间 */
+    totalTime: number;
+    /** 平均执行时间 */
+    averageTime: number;
+    /** 最小执行时间 */
+    minTime: number;
+    /** 最大执行时间 */
+    maxTime: number;
+    /** 执行次数 */
+    executionCount: number;
+    /** 最近的执行时间列表 */
+    recentTimes: number[];
+    /** 标准差 */
+    standardDeviation: number;
+    /** 95百分位数 */
+    percentile95: number;
+    /** 99百分位数 */
+    percentile99: number;
+}
+
+export declare enum PerformanceWarningType {
+    HIGH_EXECUTION_TIME = "high_execution_time",
+    HIGH_MEMORY_USAGE = "high_memory_usage",
+    HIGH_CPU_USAGE = "high_cpu_usage",
+    FREQUENT_GC = "frequent_gc",
+    LOW_FPS = "low_fps",
+    HIGH_ENTITY_COUNT = "high_entity_count"
+}
+
+export interface PerformanceWarning {
+    type: PerformanceWarningType;
+    systemName: string;
+    message: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    timestamp: number;
+    value: number;
+    threshold: number;
+    suggestion?: string;
+}
+
+export interface PerformanceThresholds {
+    /** 执行时间阈值（毫秒） */
+    executionTime: {
+        warning: number;
+        critical: number;
+    }
+
+export declare class PerformanceMonitor {
+    private static _instance;
+    private _systemData;
+    private _systemStats;
+    private _warnings;
+    private _isEnabled;
+    private _maxRecentSamples;
+    private _maxWarnings;
+    private _thresholds;
+    private _fpsHistory;
+    private _lastFrameTime;
+    private _frameCount;
+    private _fpsUpdateInterval;
+    private _lastFpsUpdate;
+    private _currentFps;
+    private _memoryCheckInterval;
+    private _lastMemoryCheck;
+    private _memoryHistory;
+    private _gcCount;
+    private _lastGcCheck;
+    private _gcCheckInterval;
+    /**
+     * 获取单例实例
+     */
+    static get instance(): PerformanceMonitor;
+    private constructor();
+    /**
+     * 启用性能监控
+     */
+    enable(): void;
+    /**
+     * 禁用性能监控
+     */
+    disable(): void;
+    /**
+     * 检查是否启用了性能监控
+     */
+    get isEnabled(): boolean;
+    /**
+     * 开始监控系统性能
+     * @param systemName 系统名称
+     * @returns 开始时间戳
+     */
+    startMonitoring(systemName: string): number;
+    /**
+     * 结束监控并记录性能数据
+     * @param systemName 系统名称
+     * @param startTime 开始时间戳
+     * @param entityCount 处理的实体数量
+     */
+    endMonitoring(systemName: string, startTime: number, entityCount?: number): void;
+    /**
+     * 更新系统统计信息
+     * @param systemName 系统名称
+     * @param executionTime 执行时间
+     */
+    private updateStats;
+    /**
+     * 计算高级统计信息
+     * @param stats 统计信息对象
+     */
+    private calculateAdvancedStats;
+    /**
+     * 获取系统的当前性能数据
+     * @param systemName 系统名称
+     * @returns 性能数据或undefined
+     */
+    getSystemData(systemName: string): PerformanceData | undefined;
+    /**
+     * 获取系统的统计信息
+     * @param systemName 系统名称
+     * @returns 统计信息或undefined
+     */
+    getSystemStats(systemName: string): PerformanceStats | undefined;
+    /**
+     * 获取所有系统的性能数据
+     * @returns 所有系统的性能数据
+     */
+    getAllSystemData(): Map<string, PerformanceData>;
+    /**
+     * 获取所有系统的统计信息
+     * @returns 所有系统的统计信息
+     */
+    getAllSystemStats(): Map<string, PerformanceStats>;
+    /**
+     * 获取性能报告
+     * @returns 格式化的性能报告字符串
+     */
+    getPerformanceReport(): string;
+    /**
+     * 重置所有性能数据
+     */
+    reset(): void;
+    /**
+     * 重置指定系统的性能数据
+     * @param systemName 系统名称
+     */
+    resetSystem(systemName: string): void;
+    /**
+     * 获取性能警告
+     * @param thresholdMs 警告阈值（毫秒）
+     * @returns 超过阈值的系统列表
+     */
+    getPerformanceWarnings(thresholdMs?: number): string[];
+    /**
+     * 设置最大保留样本数
+     * @param maxSamples 最大样本数
+     */
+    setMaxRecentSamples(maxSamples: number): void;
+}
+
+export interface IPoolable {
+    /**
+     * 重置对象状态，准备重用
+     */
+    reset(): void;
+}
+
+export interface PoolStats {
+    /** 池中对象数量 */
+    size: number;
+    /** 池的最大大小 */
+    maxSize: number;
+    /** 总共创建的对象数量 */
+    totalCreated: number;
+    /** 总共获取的次数 */
+    totalObtained: number;
+    /** 总共释放的次数 */
+    totalReleased: number;
+    /** 命中率（从池中获取的比例） */
+    hitRate: number;
+    /** 内存使用估算（字节） */
+    estimatedMemoryUsage: number;
+}
+
+export declare class Pool<T extends IPoolable> {
+    private static _pools;
+    private _objects;
+    private _createFn;
+    private _maxSize;
+    private _stats;
+    private _objectSize;
+    /**
+     * 构造函数
+     * @param createFn 创建对象的函数
+     * @param maxSize 池的最大大小，默认100
+     * @param estimatedObjectSize 估算的单个对象大小（字节），默认1024
+     */
+    constructor(createFn: () => T, maxSize?: number, estimatedObjectSize?: number);
+    /**
+     * 获取指定类型的对象池
+     * @param type 对象类型
+     * @param maxSize 池的最大大小
+     * @param estimatedObjectSize 估算的单个对象大小
+     * @returns 对象池实例
+     */
+    static getPool<T extends IPoolable>(type: new (...args: any[]) => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
+    /**
+     * 从池中获取对象
+     * @returns 对象实例
+     */
+    obtain(): T;
+    /**
+     * 将对象归还到池中
+     * @param obj 要归还的对象
+     */
+    free(obj: T): void;
+    /**
+     * 预热池，创建指定数量的对象
+     * @param count 要创建的对象数量
+     */
+    warmUp(count: number): void;
+    /**
+     * 清空池
+     */
+    clear(): void;
+    /**
+     * 获取池中对象数量
+     */
+    get size(): number;
+    /**
+     * 获取池的最大大小
+     */
+    get maxSize(): number;
+    /**
+     * 设置池的最大大小
+     */
+    set maxSize(value: number);
+    /**
+     * 获取池的统计信息
+     */
+    getStats(): PoolStats;
+    /**
+     * 重置统计信息
+     */
+    resetStats(): void;
+    /**
+     * 更新命中率
+     */
+    private _updateHitRate;
+    /**
+     * 更新内存使用估算
+     */
+    private _updateMemoryUsage;
+    /**
+     * 静态方法：从指定类型的池中获取对象
+     * @param type 对象类型
+     * @returns 对象实例
+     */
+    static obtain<T extends IPoolable>(type: new (...args: any[]) => T): T;
+    /**
+     * 静态方法：将对象归还到对应类型的池中
+     * @param type 对象类型
+     * @param obj 要归还的对象
+     */
+    static free<T extends IPoolable>(type: new (...args: any[]) => T, obj: T): void;
+    /**
+     * 静态方法：预热指定类型的池
+     * @param type 对象类型
+     * @param count 要创建的对象数量
+     */
+    static warmUp<T extends IPoolable>(type: new (...args: any[]) => T, count: number): void;
+    /**
+     * 静态方法：清空指定类型的池
+     * @param type 对象类型
+     */
+    static clearPool<T extends IPoolable>(type: new (...args: any[]) => T): void;
+    /**
+     * 静态方法：清空所有池
+     */
+    static clearAllPools(): void;
+    /**
+     * 静态方法：获取池的统计信息
+     * @returns 池的统计信息
+     */
+    static getStats(): {
+        [typeName: string]: PoolStats;
+    }
+
+export declare class TieredObjectPool<T extends IPoolable> {
+    private pools;
+    private createFn;
+    private resetFn;
+    private tierSizes;
+    private totalObtained;
+    private totalReleased;
+    /**
+     * 构造函数
+     * @param createFn 创建对象的函数
+     * @param resetFn 重置对象的函数
+     * @param tierSizes 各层级的大小，默认[10, 50, 200]
+     * @param estimatedObjectSize 估算的单个对象大小
+     */
+    constructor(createFn: () => T, resetFn: (obj: T) => void, tierSizes?: number[], estimatedObjectSize?: number);
+    /**
+     * 获取对象
+     * @returns 对象实例
+     */
+    obtain(): T;
+    /**
+     * 释放对象
+     * @param obj 要释放的对象
+     */
+    release(obj: T): void;
+    /**
+     * 预热所有池
+     * @param totalCount 总预热数量
+     */
+    warmUp(totalCount: number): void;
+    /**
+     * 清空所有池
+     */
+    clear(): void;
+    /**
+     * 获取统计信息
+     */
+    getStats(): {
+        totalSize: number;
+        totalMaxSize: number;
+        totalMemoryUsage: number;
+        tierStats: PoolStats[];
+        hitRate: number;
+    }
+
+export declare class PoolManager {
+    private static instance;
+    private pools;
+    private autoCompactInterval;
+    private lastCompactTime;
+    static getInstance(): PoolManager;
+    /**
+     * 注册池
+     * @param name 池名称
+     * @param pool 池实例
+     */
+    registerPool<T extends IPoolable>(name: string, pool: Pool<T> | TieredObjectPool<T>): void;
+    /**
+     * 获取池
+     * @param name 池名称
+     * @returns 池实例
+     */
+    getPool<T extends IPoolable>(name: string): Pool<T> | TieredObjectPool<T> | null;
+    /**
+     * 更新池管理器（应在游戏循环中调用）
+     */
+    update(): void;
+    /**
+     * 压缩所有池（清理碎片）
+     */
+    compactAllPools(): void;
+    /**
+     * 获取所有池的统计信息
+     */
+    getAllStats(): Map<string, any>;
+    /**
+     * 生成性能报告
+     */
+    generateReport(): string;
+}
+
+export declare class Time {
+    /**
+     * 上一帧到当前帧的时间间隔（秒）
+     */
+    static deltaTime: number;
+    /**
+     * 未缩放的帧时间间隔（秒）
+     */
+    static unscaledDeltaTime: number;
+    /**
+     * 游戏开始以来的总时间（秒）
+     */
+    static totalTime: number;
+    /**
+     * 未缩放的总时间（秒）
+     */
+    static unscaledTotalTime: number;
+    /**
+     * 时间缩放比例
+     */
+    static timeScale: number;
+    /**
+     * 当前帧数
+     */
+    static frameCount: number;
+    /**
+     * 上一帧的时间戳
+     */
+    private static _lastTime;
+    /**
+     * 是否为第一次更新
+     */
+    private static _isFirstUpdate;
+    /**
+     * 更新时间信息
+     * @param currentTime 当前时间戳（毫秒）
+     */
+    static update(currentTime?: number): void;
+    /**
+     * 场景改变时重置时间
+     */
+    static sceneChanged(): void;
+    /**
+     * 检查指定的时间间隔是否已经过去
+     * @param interval 时间间隔（秒）
+     * @param lastTime 上次检查的时间
+     * @returns 是否已经过去指定时间
+     */
+    static checkEvery(interval: number, lastTime: number): boolean;
+}
+
+export interface ITimer {
+    context: any;
+    /**
+     * 调用stop以停止此计时器再次运行。这对非重复计时器没有影响。
+     */
+    stop(): void;
+    /**
+     * 将计时器的运行时间重置为0
+     */
+    reset(): void;
+    /**
+     * 返回投向T的上下文，作为方便
+     */
+    getContext<T>(): T;
+}
+
+export declare class Timer implements ITimer {
+    context: any;
+    _timeInSeconds: number;
+    _repeats: boolean;
+    _onTime: (timer: ITimer) => void;
+    _isDone: boolean;
+    _elapsedTime: number;
+    getContext<T>(): T;
+    reset(): void;
+    stop(): void;
+    tick(): boolean;
+    initialize(timeInsSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): void;
+    /**
+     * 空出对象引用，以便在js需要时GC可以清理它们的引用
+     */
+    unload(): void;
+}
+
+export declare class TimerManager extends GlobalManager {
+    _timers: Timer[];
+    update(): void;
+    /**
+     * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
+     * @param timeInSeconds
+     * @param repeats
+     * @param context
+     * @param onTime
+     */
+    schedule(timeInSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): Timer;
+}
+
+export declare class WasmEcsCore {
+    private wasmLoader;
+    private jsFallback;
+    private initialized;
+    private usingWasm;
+    constructor();
+    setSilent(silent: boolean): void;
+    initialize(): Promise<boolean>;
+    createEntity(): EntityId;
+    destroyEntity(entityId: EntityId): boolean;
+    updateEntityMask(entityId: EntityId, mask: ComponentMask): void;
+    batchUpdateMasks(entityIds: EntityId[], masks: ComponentMask[]): void;
+    queryEntities(mask: ComponentMask, maxResults?: number): QueryResult;
+    queryCached(mask: ComponentMask): QueryResult;
+    queryMultipleComponents(masks: ComponentMask[], maxResults?: number): QueryResult;
+    queryWithExclusion(includeMask: ComponentMask, excludeMask: ComponentMask, maxResults?: number): QueryResult;
+    getEntityMask(entityId: EntityId): ComponentMask | null;
+    entityExists(entityId: EntityId): boolean;
+    createComponentMask(componentIds: number[]): ComponentMask;
+    maskContainsComponent(mask: ComponentMask, componentId: number): boolean;
+    getPerformanceStats(): PerformanceStats;
+    clear(): void;
+    isUsingWasm(): boolean;
+    isInitialized(): boolean;
+    private ensureInitialized;
+    cleanup(): void;
+}
+
+export declare class JavaScriptFallback {
+    private jsEntityMasks;
+    private jsNextEntityId;
+    private jsQueryCount;
+    private jsUpdateCount;
+    createEntity(): EntityId;
+    destroyEntity(entityId: EntityId): boolean;
+    updateEntityMask(entityId: EntityId, mask: ComponentMask): void;
+    batchUpdateMasks(entityIds: EntityId[], masks: ComponentMask[]): void;
+    queryEntities(mask: ComponentMask, maxResults?: number): QueryResult;
+    queryCached(mask: ComponentMask): QueryResult;
+    queryMultipleComponents(masks: ComponentMask[], maxResults?: number): QueryResult;
+    queryWithExclusion(includeMask: ComponentMask, excludeMask: ComponentMask, maxResults?: number): QueryResult;
+    getEntityMask(entityId: EntityId): ComponentMask | null;
+    entityExists(entityId: EntityId): boolean;
+    createComponentMask(componentIds: number[]): ComponentMask;
+    maskContainsComponent(mask: ComponentMask, componentId: number): boolean;
+    getPerformanceStats(): PerformanceStats;
+    clear(): void;
+    getEntityCount(): number;
+}
+
+export declare class WasmLoader {
+    private wasmModule;
+    private wasmCore;
+    private silent;
+    setSilent(silent: boolean): void;
+    loadWasmModule(): Promise<boolean>;
+    private initializeWasmModule;
+    getWasmCore(): WasmEcsCoreInstance | null;
+    getWasmModule(): WasmModule | null;
+    cleanup(): void;
+}
+
+export type EntityId = number;
+export type ComponentMask = bigint;
+export interface QueryResult {
+    entities: Uint32Array;
+    count: number;
+}
+
+export interface PerformanceStats {
+    entityCount: number;
+    indexCount: number;
+    queryCount: number;
+    updateCount: number;
+    wasmEnabled: boolean;
+}
+
+export interface WasmEcsCoreInstance {
+    create_entity(): number;
+    destroy_entity(entity_id: number): boolean;
+    update_entity_mask(entity_id: number, mask: bigint): void;
+    batch_update_masks(entity_ids: Uint32Array, masks: BigUint64Array): void;
+    query_entities(mask: bigint, max_results: number): number;
+    get_query_result_count(): number;
+    query_cached(mask: bigint): number;
+    get_cached_query_count(mask: bigint): number;
+    query_multiple_components(masks: BigUint64Array, max_results: number): number;
+    query_with_exclusion(include_mask: bigint, exclude_mask: bigint, max_results: number): number;
+    get_entity_mask(entity_id: number): bigint;
+    entity_exists(entity_id: number): boolean;
+    get_entity_count(): number;
+    get_performance_stats(): Array<any>;
+    clear(): void;
+    rebuild_query_cache(): void;
+    free?(): void;
+}
+
+export interface WasmModule {
+    EcsCore: new () => WasmEcsCoreInstance;
+    create_component_mask: (componentIds: Uint32Array) => ComponentMask;
+    mask_contains_component: (mask: ComponentMask, componentId: number) => boolean;
+    default: (input?: any) => Promise<any>;
+    initSync?: (input: any) => any;
+    memory?: WebAssembly.Memory;
+}
+
+export type EntityId = number;
+export type ComponentMask = bigint;
+
+export type Query = import('./Wasm').QueryResult;
+
+export function create_component_mask(component_ids: Uint32Array): bigint;
+/**
+ * 检查掩码是否包含指定组件
+ */
+export function mask_contains_component(mask: bigint, component_id: number): boolean;
 /**
- * ECS Framework - 轻量级实体组件系统框架
- * 适用于Laya、Cocos等游戏引擎的小游戏开发
+ * 初始化函数
  */
-export { Core } from './Core';
-export { CoreEvents } from './ECS/CoreEvents';
-export { Emitter, FuncPack } from './Utils/Emitter';
-export { GlobalManager } from './Utils/GlobalManager';
-export { TimerManager } from './Utils/Timers/TimerManager';
-export { ITimer } from './Utils/Timers/ITimer';
-export { Timer } from './Utils/Timers/Timer';
-export * from './ECS';
-export * from './Utils';
-export * from './Types';
-//# sourceMappingURL=index.d.ts.map
+export function main(): void;
+/**
+ * 高性能ECS核心，专注于实体查询和掩码管理
+ */
+export class EcsCore {
+  free(): void;
+  /**
+   * 创建新的ECS核心
+   */
+  constructor();
+  /**
+   * 创建新实体
+   */
+  create_entity(): number;
+  /**
+   * 删除实体
+   */
+  destroy_entity(entity_id: number): boolean;
+  /**
+   * 更新实体的组件掩码
+   */
+  update_entity_mask(entity_id: number, mask: bigint): void;
+  /**
+   * 批量更新实体掩码
+   */
+  batch_update_masks(entity_ids: Uint32Array, masks: BigUint64Array): void;
+  /**
+   * 查询实体
+   */
+  query_entities(mask: bigint, max_results: number): number;
+  /**
+   * 获取查询结果数量
+   */
+  get_query_result_count(): number;
+  /**
+   * 缓存查询实体
+   */
+  query_cached(mask: bigint): number;
+  /**
+   * 获取缓存查询结果数量
+   */
+  get_cached_query_count(mask: bigint): number;
+  /**
+   * 多组件查询
+   */
+  query_multiple_components(masks: BigUint64Array, max_results: number): number;
+  /**
+   * 排除查询
+   */
+  query_with_exclusion(include_mask: bigint, exclude_mask: bigint, max_results: number): number;
+  /**
+   * 获取实体的组件掩码
+   */
+  get_entity_mask(entity_id: number): bigint;
+  /**
+   * 检查实体是否存在
+   */
+  entity_exists(entity_id: number): boolean;
+  /**
+   * 获取实体数量
+   */
+  get_entity_count(): number;
+  /**
+   * 获取性能统计信息
+   */
+  get_performance_stats(): Array<any>;
+  /**
+   * 清理所有数据
+   */
+  clear(): void;
+  /**
+   * 重建查询缓存
+   */
+  rebuild_query_cache(): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_ecscore_free: (a: number, b: number) => void;
+  readonly ecscore_new: () => number;
+  readonly ecscore_create_entity: (a: number) => number;
+  readonly ecscore_destroy_entity: (a: number, b: number) => number;
+  readonly ecscore_update_entity_mask: (a: number, b: number, c: bigint) => void;
+  readonly ecscore_batch_update_masks: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly ecscore_query_entities: (a: number, b: bigint, c: number) => number;
+  readonly ecscore_get_query_result_count: (a: number) => number;
+  readonly ecscore_query_cached: (a: number, b: bigint) => number;
+  readonly ecscore_get_cached_query_count: (a: number, b: bigint) => number;
+  readonly ecscore_query_multiple_components: (a: number, b: number, c: number, d: number) => number;
+  readonly ecscore_query_with_exclusion: (a: number, b: bigint, c: bigint, d: number) => number;
+  readonly ecscore_get_entity_mask: (a: number, b: number) => bigint;
+  readonly ecscore_entity_exists: (a: number, b: number) => number;
+  readonly ecscore_get_entity_count: (a: number) => number;
+  readonly ecscore_get_performance_stats: (a: number) => any;
+  readonly ecscore_clear: (a: number) => void;
+  readonly ecscore_rebuild_query_cache: (a: number) => void;
+  readonly create_component_mask: (a: number, b: number) => bigint;
+  readonly mask_contains_component: (a: bigint, b: number) => number;
+  readonly main: () => void;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }}
+
+export function initSync(module: { module: SyncInitInput }
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+