@esengine/ecs-framework 2.0.6 → 2.0.7

package/bin/ECS/Core/QuerySystem.d.ts

@@ -13,7 +13,7 @@ export declare enum QueryConditionType {
     NONE = "none"
 }
 /**
- * 查询条件
+ * 查询条件接口
  */
 export interface QueryCondition {
     type: QueryConditionType;
@@ -21,30 +21,7 @@ export interface QueryCondition {
     mask: bigint;
 }
 /**
- * 组件元组类型
- */
-export type ComponentTuple<T extends readonly ComponentType[]> = {
-    [K in keyof T]: T[K] extends ComponentType<infer C> ? C : never;
-};
-/**
- * 类型安全的查询结果
- */
-export interface TypedQueryResult<T extends readonly ComponentType[]> {
-    entities: Entity[];
-    components: ComponentTuple<T>[];
-    count: number;
-    executionTime: number;
-    fromCache: boolean;
-}
-/**
- * 实体和组件的配对结果
- */
-export interface EntityComponentPair<T extends readonly ComponentType[]> {
-    entity: Entity;
-    components: ComponentTuple<T>;
-}
-/**
- * 实体查询结果
+ * 实体查询结果接口
  */
 export interface QueryResult {
     entities: Entity[];
@@ -54,521 +31,392 @@ export interface QueryResult {
     /** 是否来自缓存 */
     fromCache: boolean;
 }
-/**
- * 查询性能统计
- */
-interface QueryPerformanceStats {
-    totalQueries: number;
-    averageExecutionTime: number;
-    cacheHitRate: number;
-    indexHitRate: number;
-    slowQueries: Array<{
-        query: string;
-        executionTime: number;
-        timestamp: number;
-    }>;
-}
 /**
  * 高性能实体查询系统
- * 使用位掩码进行快速组件匹配，支持多级索引和智能缓存
+ *
+ * 提供快速的实体查询功能，支持按组件类型、标签、名称等多种方式查询实体。
+ * 系统采用多级索引和智能缓存机制，确保在大量实体场景下的查询性能。
+ *
+ * 主要特性：
+ * - 支持单组件和多组件查询
+ * - 自动索引管理和缓存优化
+ * - WebAssembly计算加速（如果可用）
+ * - 详细的性能统计信息
+ *
+ * @example
+ * ```typescript
+ * // 查询所有包含Position和Velocity组件的实体
+ * const movingEntities = querySystem.queryAll(PositionComponent, VelocityComponent);
+ *
+ * // 查询特定标签的实体
+ * const playerEntities = querySystem.queryByTag(PLAYER_TAG);
+ * ```
  */
 export declare class QuerySystem {
     private entities;
-    private queryCache;
-    private cacheTimeout;
-    private maxCacheSize;
-    private cacheHits;
-    private cacheMisses;
+    private wasmAvailable;
     private entityIndex;
-    private performanceStats;
     private indexDirty;
-    private lastIndexUpdate;
-    private indexUpdateThreshold;
-    private pendingEntityAdds;
-    private pendingEntityRemoves;
-    private batchUpdateScheduled;
-    /**
-     * 设置实体列表
-     * @param entities 实体数组
+    private queryCache;
+    private cacheMaxSize;
+    private cacheTimeout;
+    private componentPoolManager;
+    private bitMaskOptimizer;
+    private indexUpdateBatcher;
+    private queryStats;
+    constructor();
+    /**
+     * 初始化WebAssembly支持
+     *
+     * 自动检测运行环境并启用WebAssembly计算加速。
+     * 如果WebAssembly不可用，系统将自动回退到JavaScript实现。
+     */
+    private initializeWasm;
+    /**
+     * 设置实体列表并重建索引
+     *
+     * 当实体集合发生大规模变化时调用此方法。
+     * 系统将重新构建所有索引以确保查询性能。
+     *
+     * @param entities 新的实体列表
      */
     setEntities(entities: Entity[]): void;
     /**
-     * 添加实体
-     * @param entity 实体
+     * 添加单个实体到查询系统
+     *
+     * 将新实体添加到查询系统中，并自动更新相关索引。
+     * 为了提高批量添加性能，可以延迟缓存清理。
+     *
+     * @param entity 要添加的实体
+     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
      */
-    addEntity(entity: Entity): void;
+    addEntity(entity: Entity, deferCacheClear?: boolean): void;
     /**
      * 批量添加实体
-     * @param entities 实体数组
+     *
+     * 高效地批量添加多个实体，减少缓存清理次数。
+     * 使用Set来避免O(n)的重复检查。
+     *
+     * @param entities 要添加的实体列表
      */
     addEntities(entities: Entity[]): void;
     /**
-     * 移除实体
-     * @param entity 实体
+     * 批量添加实体（无重复检查版本）
+     *
+     * 假设所有实体都是新的，跳过重复检查以获得最大性能。
+     * 仅在确保没有重复实体时使用。
+     *
+     * @param entities 要添加的实体列表
      */
-    removeEntity(entity: Entity): void;
+    addEntitiesUnchecked(entities: Entity[]): void;
     /**
-     * 批量移除实体
-     * @param entities 实体数组
+     * 从查询系统移除实体
+     *
+     * 从查询系统中移除指定实体，并清理相关索引。
+     *
+     * @param entity 要移除的实体
      */
-    removeEntities(entities: Entity[]): void;
-    /**
-     * 调度批量更新
-     */
-    private scheduleBatchUpdate;
-    /**
-     * 处理批量更新
-     */
-    private processBatchUpdates;
-    /**
-     * 强制立即处理所有待处理的更新
-     */
-    flushUpdates(): void;
-    /**
-     * 无效化所有索引
-     */
-    private invalidateIndexes;
+    removeEntity(entity: Entity): void;
     /**
-     * 将实体添加到索引
-     * @param entity 实体
+     * 将实体添加到各种索引中（优化版本）
      */
     private addEntityToIndexes;
     /**
-     * 从索引中移除实体
-     * @param entity 实体
+     * 从各种索引中移除实体
      */
     private removeEntityFromIndexes;
     /**
      * 重建所有索引
+     *
+     * 清空并重新构建所有查询索引。
+     * 通常在大量实体变更后调用以确保索引一致性。
      */
     private rebuildIndexes;
-    /**
-     * 确保索引是最新的
-     */
-    private ensureIndexesUpdated;
     /**
      * 查询包含所有指定组件的实体
-     * @param componentTypes 组件类型数组
-     * @returns 查询结果
+     *
+     * 返回同时包含所有指定组件类型的实体列表。
+     * 系统会自动选择最高效的查询策略，包括索引查找和缓存机制。
+     *
+     * @param componentTypes 要查询的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询同时具有位置和速度组件的实体
+     * const result = querySystem.queryAll(PositionComponent, VelocityComponent);
+     * console.log(`找到 ${result.count} 个移动实体`);
+     * ```
      */
     queryAll(...componentTypes: ComponentType[]): QueryResult;
     /**
-     * 查询包含任意指定组件的实体
-     * @param componentTypes 组件类型数组
-     * @returns 查询结果
+     * 多组件查询算法
+     *
+     * 针对多组件查询场景的高效算法实现。
+     * 通过选择最小的组件集合作为起点，减少需要检查的实体数量。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 匹配的实体列表
      */
-    queryAny(...componentTypes: ComponentType[]): QueryResult;
+    private queryMultipleComponents;
     /**
-     * 查询不包含任何指定组件的实体
-     * @param componentTypes 组件类型数组
-     * @returns 查询结果
+     * 线性扫描查询
+     *
+     * 当索引不可用时的备用查询方法。
+     * 遍历所有实体进行组件匹配检查。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 匹配的实体列表
      */
-    queryNone(...componentTypes: ComponentType[]): QueryResult;
+    private queryByLinearScan;
     /**
-     * 复合查询：同时满足多个条件
-     * @param conditions 查询条件数组
-     * @returns 查询结果
+     * 查询包含任意指定组件的实体
+     *
+     * 返回包含任意一个指定组件类型的实体列表。
+     * 使用集合合并算法确保高效的查询性能。
+     *
+     * @param componentTypes 要查询的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询具有武器或护甲组件的实体
+     * const result = querySystem.queryAny(WeaponComponent, ArmorComponent);
+     * console.log(`找到 ${result.count} 个装备实体`);
+     * ```
      */
-    queryComplex(...conditions: QueryCondition[]): QueryResult;
+    queryAny(...componentTypes: ComponentType[]): QueryResult;
     /**
-     * 流式查询构建器
-     * @returns 查询构建器实例
+     * 查询不包含任何指定组件的实体
+     *
+     * 返回不包含任何指定组件类型的实体列表。
+     * 适用于排除特定类型实体的查询场景。
+     *
+     * @param componentTypes 要排除的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询不具有AI和玩家控制组件的实体（如静态物体）
+     * const result = querySystem.queryNone(AIComponent, PlayerControlComponent);
+     * console.log(`找到 ${result.count} 个静态实体`);
+     * ```
      */
-    createQuery(): QueryBuilder;
+    queryNone(...componentTypes: ComponentType[]): QueryResult;
     /**
-     * 根据标签查询实体
-     * @param tag 标签
-     * @returns 查询结果
+     * 按标签查询实体
+     *
+     * 返回具有指定标签的所有实体。
+     * 标签查询使用专用索引，具有很高的查询性能。
+     *
+     * @param tag 要查询的标签值
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询所有玩家实体
+     * const players = querySystem.queryByTag(PLAYER_TAG);
+     * ```
      */
     queryByTag(tag: number): QueryResult;
     /**
-     * 根据名称查询实体
-     * @param name 名称
-     * @returns 查询结果
+     * 按名称查询实体
+     *
+     * 返回具有指定名称的所有实体。
+     * 名称查询使用专用索引，适用于查找特定的命名实体。
+     *
+     * @param name 要查询的实体名称
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查找名为"Player"的实体
+     * const player = querySystem.queryByName("Player");
+     * ```
      */
     queryByName(name: string): QueryResult;
     /**
-     * 根据单个组件类型快速查询
-     * @param componentType 组件类型
-     * @returns 查询结果
+     * 按单个组件类型查询实体
+     *
+     * 返回包含指定组件类型的所有实体。
+     * 这是最基础的查询方法，具有最高的查询性能。
+     *
+     * @param componentType 要查询的组件类型
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询所有具有位置组件的实体
+     * const entitiesWithPosition = querySystem.queryByComponent(PositionComponent);
+     * ```
      */
     queryByComponent<T extends Component>(componentType: ComponentType<T>): QueryResult;
     /**
-     * 类型安全的查询所有指定组件的实体
-     * @param componentTypes 组件类型数组
-     * @returns 类型安全的查询结果
-     */
-    queryAllTyped<T extends readonly ComponentType[]>(...componentTypes: T): TypedQueryResult<T>;
-    /**
-     * 查询具有特定组件组合的实体并返回组件实例
-     * @param componentTypes 组件类型数组
-     * @returns 实体和对应组件的映射
-     */
-    queryWithComponents<T extends readonly ComponentType[]>(...componentTypes: T): EntityComponentPair<T>[];
-    /**
-     * 迭代查询结果，为每个匹配的实体执行回调
-     * @param componentTypes 组件类型数组
-     * @param callback 回调函数
-     */
-    forEachWithComponents<T extends readonly ComponentType[]>(componentTypes: T, callback: (entity: Entity, components: ComponentTuple<T>) => void): void;
-    /**
-     * 查询单个组件类型的实体，返回类型安全的结果
-     * @param componentType 组件类型
-     * @returns 实体和组件的配对数组
-     */
-    queryComponentTyped<T extends Component>(componentType: ComponentType<T>): Array<{
-        entity: Entity;
-        component: T;
-    }>;
-    /**
-     * 查询两个组件类型的实体，返回类型安全的结果
-     * @param componentType1 第一个组件类型
-     * @param componentType2 第二个组件类型
-     * @returns 实体和组件的配对数组
-     */
-    queryTwoComponents<T1 extends Component, T2 extends Component>(componentType1: ComponentType<T1>, componentType2: ComponentType<T2>): Array<{
-        entity: Entity;
-        component1: T1;
-        component2: T2;
-    }>;
-    /**
-     * 查询三个组件类型的实体，返回类型安全的结果
-     * @param componentType1 第一个组件类型
-     * @param componentType2 第二个组件类型
-     * @param componentType3 第三个组件类型
-     * @returns 实体和组件的配对数组
-     */
-    queryThreeComponents<T1 extends Component, T2 extends Component, T3 extends Component>(componentType1: ComponentType<T1>, componentType2: ComponentType<T2>, componentType3: ComponentType<T3>): Array<{
-        entity: Entity;
-        component1: T1;
-        component2: T2;
-        component3: T3;
-    }>;
-    /**
-     * 执行单个条件查询
-     * @param condition 查询条件
-     * @returns 查询结果
-     */
-    private query;
-    /**
-     * 使用索引优化查询
-     * @param condition 查询条件
-     * @returns 查询结果或null（如果无法优化）
-     */
-    private queryWithIndexOptimization;
-    /**
-     * 更新性能统计
-     * @param executionTime 执行时间
-     * @param fromIndex 是否来自索引
-     */
-    private updatePerformanceStats;
-    /**
-     * 根据条件过滤实体
-     * @param entities 实体数组
-     * @param condition 查询条件
-     * @returns 过滤后的实体数组
-     */
-    private filterEntitiesByCondition;
-    /**
-     * 检查实体是否匹配条件
-     * @param entity 实体
-     * @param condition 查询条件
-     * @returns 是否匹配
+     * 从缓存获取查询结果
      */
-    private matchesCondition;
+    private getFromCache;
     /**
-     * 创建组件类型的位掩码
-     * @param componentTypes 组件类型数组
-     * @returns 位掩码
+     * 添加查询结果到缓存
      */
-    private createMask;
+    private addToCache;
     /**
-     * 生成缓存键
-     * @param condition 查询条件
-     * @returns 缓存键
+     * 清理缓存
      */
-    private generateCacheKey;
+    private cleanupCache;
     /**
-     * 生成复合查询的缓存键
-     * @param conditions 查询条件数组
-     * @returns 缓存键
+     * 清除所有查询缓存
      */
-    private generateComplexCacheKey;
+    private clearQueryCache;
     /**
-     * 获取缓存结果
-     * @param cacheKey 缓存键
-     * @returns 缓存项或null
-     */
-    private getCachedResult;
-    /**
-     * 缓存查询结果
-     * @param cacheKey 缓存键
-     * @param entities 实体数组
-     */
-    private cacheResult;
-    /**
-     * 清空查询缓存
+     * 公共方法：清理查询缓存
+     *
+     * 用于外部调用清理缓存，通常在批量操作后使用。
      */
     clearCache(): void;
     /**
-     * 删除最少使用的缓存项
-     */
-    private evictLeastUsedCache;
+     * 批量更新实体组件
+     *
+     * 对大量实体进行批量组件更新操作。
+     * 当更新数量超过阈值时，系统会自动使用WebAssembly加速。
+     *
+     * @param updates 更新操作列表，包含实体ID和新的组件掩码
+     *
+     * @example
+     * ```typescript
+     * // 批量更新实体的组件配置
+     * const updates = [
+     *     { entityId: 1, componentMask: BigInt(0b1011) },
+     *     { entityId: 2, componentMask: BigInt(0b1101) }
+     * ];
+     * querySystem.batchUpdateComponents(updates);
+     * ```
+     */
+    batchUpdateComponents(updates: Array<{
+        entityId: number;
+        componentMask: bigint;
+    }>): void;
+    /**
+     * JavaScript实现的批量更新
+     */
+    private batchUpdateComponentsJS;
+    /**
+     * 获取加速状态信息
+     *
+     * 返回当前查询系统的加速状态和性能信息。
+     * 包括WebAssembly可用性、缓存统计等详细信息。
+     *
+     * @returns 加速状态信息对象
+     */
+    getAccelerationStatus(): {
+        wasmEnabled: boolean;
+        currentProvider: string;
+        availableProviders: string[];
+        performanceInfo?: any;
+    };
     /**
-     * 获取详细的查询统计信息
+     * 切换加速提供者
+     *
+     * 兼容性接口，保持向后兼容。
+     * 系统会自动选择最佳的实现方式。
+     *
+     * @param providerName 提供者名称
+     * @returns 是否切换成功
+     */
+    switchAccelerationProvider(providerName: string): Promise<boolean>;
+    /**
+     * 创建组件掩码
+     *
+     * 根据组件类型列表生成对应的位掩码。
+     * 使用位掩码优化器进行缓存和预计算。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 生成的位掩码
+     */
+    private createComponentMask;
+    /**
+     * 获取系统统计信息
+     *
+     * 返回查询系统的详细统计信息，包括实体数量、索引状态、
+     * 查询性能统计等，用于性能监控和调试。
+     *
+     * @returns 系统统计信息对象
      */
     getStats(): {
         entityCount: number;
-        cacheSize: number;
-        cacheHits: number;
-        cacheMisses: number;
-        hitRate: number;
-        maxCacheSize: number;
         indexStats: {
             maskIndexSize: number;
             componentIndexSize: number;
             tagIndexSize: number;
             nameIndexSize: number;
         };
-        performanceStats: QueryPerformanceStats;
-    };
-    /**
-     * 获取性能报告
-     */
-    getPerformanceReport(): string;
-    /**
-     * 优化索引配置
-     */
-    optimizeIndexes(): void;
-    /**
-     * 批量查询多个条件
-     * @param queries 查询条件数组
-     * @returns 查询结果数组
-     */
-    batchQuery(queries: QueryCondition[]): QueryResult[];
-    /**
-     * 设置缓存配置
-     * @param maxSize 最大缓存大小
-     * @param timeout 缓存超时时间（毫秒）
-     */
-    setCacheConfig(maxSize: number, timeout: number): void;
-    /**
-     * 重置统计信息
-     */
-    resetStats(): void;
-    /**
-     * 预热查询缓存
-     * @param commonQueries 常用查询条件数组
-     */
-    warmUpCache(commonQueries: QueryCondition[]): void;
-    /**
-     * 获取实体变更监听器
-     * @param condition 查询条件
-     * @param callback 变更回调
-     * @returns 取消监听的函数
-     */
-    watchQuery(condition: QueryCondition, callback: (entities: Entity[], changeType: 'added' | 'removed' | 'updated') => void): () => void;
-    /**
-     * 获取查询结果的快照
-     * @param condition 查询条件
-     * @returns 查询快照
-     */
-    createSnapshot(condition: QueryCondition): {
-        entities: Entity[];
-        timestamp: number;
-        condition: QueryCondition;
-    };
-    /**
-     * 比较两个查询快照
-     * @param snapshot1 第一个快照
-     * @param snapshot2 第二个快照
-     * @returns 比较结果
-     */
-    compareSnapshots(snapshot1: ReturnType<QuerySystem['createSnapshot']>, snapshot2: ReturnType<QuerySystem['createSnapshot']>): {
-        added: Entity[];
-        removed: Entity[];
-        unchanged: Entity[];
+        accelerationStatus: ReturnType<QuerySystem['getAccelerationStatus']>;
+        queryStats: {
+            totalQueries: number;
+            cacheHits: number;
+            indexHits: number;
+            linearScans: number;
+            cacheHitRate: string;
+        };
     };
-    /**
-     * 执行并行查询
-     * @param conditions 查询条件数组
-     * @returns Promise<查询结果数组>
-     */
-    parallelQuery(conditions: QueryCondition[]): Promise<QueryResult[]>;
-    /**
-     * 获取查询建议
-     * @param entities 实体数组
-     * @returns 查询优化建议
-     */
-    getQuerySuggestions(entities: Entity[]): string[];
-    /**
-     * 导出查询统计数据
-     * @returns 统计数据的JSON字符串
-     */
-    exportStats(): string;
-    /**
-     * 导入查询统计数据
-     * @param statsJson 统计数据的JSON字符串
-     */
-    importStats(statsJson: string): void;
 }
 /**
- * 流式查询构建器
- * 提供链式调用的查询API
+ * 查询构建器
+ *
+ * 提供链式API来构建复杂的实体查询条件。
+ * 支持组合多种查询条件，创建灵活的查询表达式。
+ *
+ * @example
+ * ```typescript
+ * const result = new QueryBuilder(querySystem)
+ *     .withAll(PositionComponent, VelocityComponent)
+ *     .without(DeadComponent)
+ *     .execute();
+ * ```
  */
 export declare class QueryBuilder {
     private conditions;
     private querySystem;
     constructor(querySystem: QuerySystem);
     /**
-     * 添加"包含所有"条件
-     * @param componentTypes 组件类型
-     * @returns 查询构建器
+     * 添加"必须包含所有组件"条件
+     *
+     * @param componentTypes 必须包含的组件类型
+     * @returns 查询构建器实例，支持链式调用
      */
     withAll(...componentTypes: ComponentType[]): QueryBuilder;
     /**
-     * 添加"包含任意"条件
-     * @param componentTypes 组件类型
-     * @returns 查询构建器
+     * 添加"必须包含任意组件"条件
+     *
+     * @param componentTypes 必须包含其中任意一个的组件类型
+     * @returns 查询构建器实例，支持链式调用
      */
     withAny(...componentTypes: ComponentType[]): QueryBuilder;
     /**
-     * 添加"不包含"条件
-     * @param componentTypes 组件类型
-     * @returns 查询构建器
+     * 添加"不能包含任何组件"条件
+     *
+     * @param componentTypes 不能包含的组件类型
+     * @returns 查询构建器实例，支持链式调用
      */
     without(...componentTypes: ComponentType[]): QueryBuilder;
     /**
-     * 执行查询
-     * @returns 查询结果
+     * 执行查询并返回结果
+     *
+     * 根据已添加的查询条件执行实体查询。
+     *
+     * @returns 查询结果，包含匹配的实体和性能信息
      */
     execute(): QueryResult;
     /**
-     * 获取第一个匹配的实体
-     * @returns 实体或null
-     */
-    first(): Entity | null;
-    /**
-     * 检查是否有匹配的实体
-     * @returns 是否有匹配
-     */
-    any(): boolean;
-    /**
-     * 获取匹配实体的数量
-     * @returns 实体数量
-     */
-    count(): number;
-    /**
-     * 对每个匹配的实体执行操作
-     * @param callback 回调函数
+     * 创建组件掩码
      */
-    forEach(callback: (entity: Entity, index: number) => void): void;
+    private createComponentMask;
     /**
-     * 转换为数组
-     * @returns 实体数组
-     */
-    toArray(): Entity[];
-    /**
-     * 创建组件类型的位掩码
-     * @param componentTypes 组件类型数组
-     * @returns 位掩码
-     */
-    private createMask;
-    /**
-     * 重置查询条件
-     * @returns 查询构建器
+     * 重置查询构建器
+     *
+     * 清除所有已添加的查询条件，重新开始构建查询。
+     *
+     * @returns 查询构建器实例，支持链式调用
      */
     reset(): QueryBuilder;
-    private tagFilter?;
-    private nameFilter?;
-    private limitCount?;
-    private offsetCount?;
-    private sortFunction?;
-    /**
-     * 添加标签过滤条件
-     * @param tag 标签
-     * @returns 查询构建器实例
-     */
-    withTag(tag: number): QueryBuilder;
-    /**
-     * 添加名称过滤条件
-     * @param name 名称
-     * @returns 查询构建器实例
-     */
-    withName(name: string): QueryBuilder;
-    /**
-     * 限制结果数量
-     * @param limit 最大结果数量
-     * @returns 查询构建器实例
-     */
-    limit(limit: number): QueryBuilder;
-    /**
-     * 跳过指定数量的结果
-     * @param offset 跳过的数量
-     * @returns 查询构建器实例
-     */
-    offset(offset: number): QueryBuilder;
-    /**
-     * 对结果进行排序
-     * @param compareFn 比较函数
-     * @returns 查询构建器实例
-     */
-    orderBy(compareFn: (a: Entity, b: Entity) => number): QueryBuilder;
-    /**
-     * 按更新顺序排序
-     * @returns 查询构建器实例
-     */
-    orderByUpdateOrder(): QueryBuilder;
-    /**
-     * 按ID排序
-     * @returns 查询构建器实例
-     */
-    orderById(): QueryBuilder;
-    /**
-     * 按名称排序
-     * @returns 查询构建器实例
-     */
-    orderByName(): QueryBuilder;
-    /**
-     * 克隆查询构建器
-     * @returns 新的查询构建器
-     */
-    clone(): QueryBuilder;
-    /**
-     * 添加自定义过滤器
-     * @param predicate 过滤谓词
-     * @returns 查询构建器实例
-     */
-    filter(predicate: (entity: Entity) => boolean): QueryBuilder;
-    /**
-     * 映射查询结果
-     * @param mapper 映射函数
-     * @returns 映射后的结果数组
-     */
-    map<T>(mapper: (entity: Entity) => T): T[];
-    /**
-     * 查找第一个满足条件的实体
-     * @param predicate 查找谓词
-     * @returns 实体或null
-     */
-    find(predicate?: (entity: Entity) => boolean): Entity | null;
-    /**
-     * 检查是否所有实体都满足条件
-     * @param predicate 检查谓词
-     * @returns 是否所有实体都满足条件
-     */
-    every(predicate: (entity: Entity) => boolean): boolean;
-    /**
-     * 检查是否有实体满足条件
-     * @param predicate 检查谓词
-     * @returns 是否有实体满足条件
-     */
-    some(predicate: (entity: Entity) => boolean): boolean;
-    /**
-     * 获取查询的调试信息
-     * @returns 调试信息字符串
-     */
-    getDebugInfo(): string;
 }
-export {};
 //# sourceMappingURL=QuerySystem.d.ts.map