@ives_xxz/framework 2.0.16 → 2.1.0

package/types/FW.d.ts

@@ -1,13 +1,26 @@
 export as namespace FW;
 
 declare namespace FW {
+  /**
+   * 可构造类型 - 表示可以用 new 关键字实例化的类
+   * @template TInstance - 实例类型
+   * @template TArgs - 构造函数参数类型数组
+   */
   type Newable<TInstance = unknown, TArgs extends unknown[] = any[]> = new (
     ...args: TArgs
   ) => TInstance;
+
+  /**
+   * 抽象类型 - 表示具有原型的对象类型
+   * @template T - 原型类型
+   */
   type Abstract<T> = {
     prototype: T;
   };
-
+  /**
+   * 服务标识符数据类型 - 用于标识服务的多种可能类型
+   * @template TInstance - 实例类型
+   */
   type ServiceIdentifierData<TInstance = unknown> = string | symbol | Newable<TInstance> | Function;
 
   type CommonNewable<TInstance = unknown, TArgs extends unknown[] = any[]> = Newable<
@@ -18,43 +31,122 @@ declare namespace FW {
 
   type ServiceIdentifier<T = unknown> = CommonServiceIdentifier<T>;
   /**
-   * 入口对象
+   * 框架入口对象 - 提供访问各种管理器和服务的统一入口
    */
   type Entry = {
+    /** 时间管理器 */
     timeMgr: TimeManager;
+    /** 层级管理器 */
     layerMgr: LayerManager;
+    /** 资源管理器 */
     resMgr: ResManager;
+    /** 动画管理器 */
     animationMgr: AnimationManager;
+    /** 状态管理器 */
     stateMgr: StateManager;
+    /** 音频管理器 */
     audioMgr: AudioManager;
+    /** Socket管理器 */
     socketMgr: SocketManager;
+    /** 对象管理器 */
     objectMgr: ObjectManager;
+    /** UI管理器 */
     uiMgr: UiManager;
+    /** 组件管理器 */
     componentMgr: ComponentManager;
+    /** 语言管理器 */
     languageMgr: LanguageManager;
+    /** 事件管理器 */
     evtMgr: EventManager;
+    /** 引擎管理器 */
     engineMgr: EngineManager;
+    /** 任务管理器 */
     taskMgr: TaskManager;
+    /** 热更新管理器 */
     hotUpdateMgr: HotUpdateManager;
+    /** Promise管理器 */
     promiseMgr: PromiseManager;
+    /** 性能管理器 */
     performanceMgr: PerformanceManager;
+    /** 场景组件 */
     scene: Scene;
+    /** 当前bundle名称 */
     bundleName: string;
+
+    /**
+     * 获取指定类型的服务组件
+     * @template T - 组件类型
+     * @param serviceIdentifier - 服务标识符
+     * @returns 对应类型的组件实例
+     */
     getComponent<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T;
+
+    /**
+     * 获取指定类型的所有服务组件
+     * @template T - 组件类型
+     * @param serviceIdentifier - 服务标识符，可选
+     * @returns 对应类型的所有组件实例数组
+     */
     getComponents<T>(serviceIdentifier?: FW.ServiceIdentifier<T>): T[];
+
+    /**
+     * 启动场景
+     * @param bundleName - bundle名称
+     */
     launchScene(bundleName: string): void;
+
+    /**
+     * 注册框架组件
+     * @param data - 注册数据
+     */
     register(data: RegisterBundle): void;
+
+    /**
+     * 注销框架组件
+     * @param data - 注销数据
+     */
     unRegister(data: RegisterBundle): void;
+
+    /**
+     * 获取场景名称
+     * @param bundleName - bundle名称
+     * @returns 场景名称
+     */
     getSceneName(bundleName: string): string;
+
+    /**
+     * 获取依赖项
+     * @param bundleName - bundle名称
+     * @returns 依赖项数组
+     */
     getDepend(bundleName: string): string[];
+
+    /**
+     * 更新方法 - 每帧调用
+     * @param dt - 帧时间间隔
+     */
     update(dt: number): void;
+
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 重启方法 */
     restart(): void;
   };
 
   type Manager = {};
 
+  /**
+   * Promise管理器 - 提供增强的Promise功能
+   */
   type PromiseManager = {
+    /**
+     * 执行Promise操作
+     * @template T - Promise解析值类型
+     * @param executor - Promise执行器函数
+     * @param options - 执行选项
+     * @returns Promise代理对象
+     */
     execute<T = any>(
       executor: (
         resolve: (value: T | PromiseLike<T>) => void,
@@ -64,29 +156,103 @@ declare namespace FW {
       ) => void = PromiseExcutor,
       options: PromiseExecuteOptions = {},
     ): PromiseProxy<T>;
+
+    /**
+     * 等待所有Promise完成
+     * @template T - Promise解析值类型
+     * @param promises - Promise代理数组
+     * @param options - 执行选项
+     * @returns 包含所有结果的Promise代理
+     */
     all<T = any>(
       promises: FW.PromiseProxy<T>[],
       options: FW.PromiseExecuteOptions = {},
     ): FW.PromiseProxy<FW.PromiseResult<T>>;
   };
 
+  /**
+   * 语言管理器 - 负责多语言支持和本地化
+   */
   type LanguageManager = {
+    /**
+     * 注册语言包枚举
+     * @param bundleName - bundle名称
+     * @param language - 语言枚举
+     * @param getter - 获取语言值的函数
+     */
     registerLanguagePackageEnum(
       bundleName: string,
       language: any,
       getter: (key: string, language?: string) => string,
     ): void;
+
+    /**
+     * 获取支持的语言列表
+     * @returns 支持的语言数组
+     */
     getSupportedLanguages(): string[];
+
+    /**
+     * 设置支持的语言列表
+     * @param languages - 语言数组
+     */
     setSupportedLanguages(languages: string[]): void;
+
+    /**
+     * 获取所有bundle名称
+     * @returns bundle名称数组
+     */
     getBundles(): string[];
+
+    /**
+     * 获取当前语言
+     * @returns 当前语言代码
+     */
     getLanguage(): string;
+
+    /**
+     * 获取当前语言索引
+     * @returns 语言索引
+     */
     getLanguageIndex(): number;
+
+    /**
+     * 获取语言包值
+     * @param bundleName - bundle名称
+     * @param key - 键值
+     * @param language - 语言代码（可选）
+     * @returns 语言包对应值
+     */
     getLanguagePackageValue(bundleName: string, key: string, language?: string): string;
+
+    /**
+     * 获取语言包枚举键列表
+     * @param bundleName - bundle名称
+     * @returns 键名数组
+     */
     getLanguagePackageEnumKeys(bundleName: string): string[];
+
+    /**
+     * 获取语言包枚举值列表
+     * @param bundleName - bundle名称
+     * @returns 值数组
+     */
     getLanguagePackageEnumValues(bundleName: string): string[];
+
+    /**
+     * 获取语言包枚举
+     * @template K - bundle名称类型
+     * @param bundleName - bundle名称
+     * @returns 语言包访问器
+     */
     getLanguagePackageEnum<K extends keyof ILanguageBundleAccessor>(
       bundleName: K,
     ): ILanguageBundleAccessor[K];
+
+    /**
+     * 初始化语言设置
+     * @param language - 语言代码
+     */
     initializeLanguage(language: string);
   };
 
@@ -155,7 +321,19 @@ declare namespace FW {
     onDestroy();
   };
 
+  /**
+   * Socket管理器 - 负责WebSocket连接的管理
+   */
   type SocketManager = {
+    /**
+     * 创建Socket连接
+     * @param tag - 标识符
+     * @param address - 地址
+     * @param sender - 发送器
+     * @param handle - 处理器
+     * @param config - 配置
+     * @returns Socket实例的Promise
+     */
     createSocket(
       tag: string,
       address: string,
@@ -163,23 +341,29 @@ declare namespace FW {
       handle: Handle,
       config: SocketConfig,
     ): Promise<Socket>;
+
     /**
-     * 获取socket
-     * @param type
-     * @returns
+     * 获取Socket实例
+     * @param tag - 标识符（可选）
+     * @returns Socket实例
      */
     getSocket(tag?: string): Socket;
 
+    /**
+     * 获取所有Socket映射
+     * @returns Socket映射表
+     */
     getSocketMap(): Map<string, Socket>;
+
     /** 暂停消息处理 */
     pauseMessageHandle(): void;
 
     /** 恢复消息处理 */
     resumeMessageHandle(): void;
+
     /**
-     * 关闭
-     * @param fs
-     * @returns
+     * 关闭Socket连接
+     * @param fs - Socket实例
      */
     closeSocket(fs: Socket): void;
   };
@@ -210,48 +394,67 @@ declare namespace FW {
     schedule: TimerSchedule;
   };
 
+  /**
+   * Socket连接对象
+   */
   type Socket = {
+    /** 销毁方法 */
     public onDestroy(): void;
+
     /**
-     * 获取tag
-     * */
+     * 获取标识符
+     * @returns 标识符字符串
+     */
     public getTag(): string;
+
     /**
      * 获取地址
-     * @returns
+     * @returns 地址字符串
      */
     getAddress(): string;
 
     /**
-     * 获取socket状态
-     * @returns
+     * 获取Socket状态
+     * @returns 状态码
      */
     getReadyState(): number;
+
     /**
-     * 重连
+     * 重新连接
+     * @param force - 是否强制重连
      */
     reconnect(force?: boolean): void;
-    /**
-     * 关闭连接
-     */
+
+    /** 关闭连接 */
     close();
-    /**
-     * 清理
-     */
+
+    /** 清理资源 */
     clear();
-    /**
-     * 暂停消息处理
-     */
+
+    /** 暂停消息处理 */
     pauseMessageHandle();
-    /**
-     * 恢复消息处理
-     */
+
+    /** 恢复消息处理 */
     resumeMessageHandle();
 
+    /**
+     * 发送消息
+     * @param msg - 消息内容
+     */
     send(msg);
 
+    /** 原生WebSocket对象 */
     socket: WebSocket;
 
+    /**
+     * 创建Socket连接
+     * @param address - 地址
+     * @param tag - 标识符
+     * @param sender - 发送器
+     * @param handle - 处理器
+     * @param config - 配置
+     * @returns SocketPromise代理对象
+     */
     createSocket(
       address: string,
       tag: string,
@@ -261,15 +464,26 @@ declare namespace FW {
     ): SocketPromiseProxy;
   };
 
+  /**
+   * Socket配置
+   */
   type SocketConfig = {
+    /** 心跳间隔 */
     heartInternal: number;
+    /** 心跳超时时间 */
     heartTimeout: number;
+    /** 心跳弱网时间 */
     heartWeakTime: number;
+    /** 最大重连次数 */
     maxReconnectTimes: number;
+    /** 重连间隔 */
     reconnectInternal: number;
+    /** 协议符号 */
     protocolSymbol: Symbol;
+    /** 协议轮询时间 */
     protocolPollingTime: number;
-    certificate: cc.Asset;
+    /** 证书（可选） */
+    certificate?: cc.Asset;
   };
 
   /**
@@ -329,46 +543,43 @@ declare namespace FW {
     buttonDisable(target: TargetType);
   };
 
+  /**
+   * 时间管理器 - 负责游戏中的定时器和更新循环
+   */
   type TimeManager = {
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 销毁方法 */
     onDestroy(): void;
 
-    getTime(): string;
     /**
-     * 一次性调度器
+     * 获取当前时间字符串
+     * @returns 时间字符串
      */
-    scheduleOnce(cb?: () => void, tag?: string): FW.TimerSchedule;
+    getTime(): string;
+
     /**
-     * 一次性调度器
+     * 一次性调度器（多种重载形式）
      */
+    scheduleOnce(cb?: () => void, tag?: string): FW.TimerSchedule;
     scheduleOnce(time?: number, tag?: string): FW.TimerSchedule;
-    /**
-     * 一次性调度器
-     */
     scheduleOnce(cb?: () => void, target?: any): FW.TimerSchedule;
-    /**
-     * 一次性调度器
-     */
     scheduleOnce(time?: number, target?: any): FW.TimerSchedule;
-    /**
-     * 一次性调度器
-     */
     scheduleOnce(cb?: () => void, time?: number, tag?: string): FW.TimerSchedule;
-    /**
-     * 一次性调度器
-     */
     scheduleOnce(time?: number, cb?: () => void, tag?: string): FW.TimerSchedule;
-    /**
-     * 一次性调度器
-     */
     scheduleOnce(time?: number, cb?: () => void, target?: any): FW.TimerSchedule;
-    /**
-     * 一次性调度器
-     */
     scheduleOnce(cb?: () => void, time?: number, target?: any): FW.TimerSchedule;
+
     /**
      * 自定义调度器
-     * */
+     * @param cb - 回调函数
+     * @param time - 时间间隔
+     * @param repeat - 重复次数
+     * @param target - 目标对象
+     * @param tag - 标签
+     * @returns 时间调度器
+     */
     schedule(
       cb?: () => void,
       time?: number,
@@ -376,42 +587,85 @@ declare namespace FW {
       target?: TargetType,
       tag?: string,
     ): TimerSchedule;
-    /** 暂停调度器 */
-    pauseSchedule(tag: string): void;
-    pauseSchedule(target: TargetType): void;
-    pauseSchedule(id: number): void;
+
     /**
-     * 取消调度器
-     * */
-    unSchedule(tag: string): void;
-    unSchedule(target: TargetType): void;
-    unSchedule(id: number): void;
+     * 暂停调度器
+     * @param tag
+     */
+    pauseSchedule(tag: string);
     /**
-     * 恢复调度器
+     * 暂停调度器
+     * @param target
+     */
+    pauseSchedule(target: FW.TargetType);
+    /**
+     * 暂停调度器
+     * @param id
+     */
+    pauseSchedule(id: number);
+
+    /**
+     * 停止调度器
      * @param tag
      */
-    resumeSchedule(tag: string): void;
-    resumeSchedule(target: TargetType): void;
-    resumeSchedule(id: number): void;
+    unSchedule(tag: string);
     /**
-     * 每一帧更新
-     * @param cb
+     * 停止调度器
+     * @param target: Comment | Object | cc.Node
+     */
+    unSchedule(target: FW.TargetType);
+    /**
+     * 停止调度器
+     * @param id: number
+     */
+    unSchedule(id: number);
+
+    /**
+     * 恢复调度器
      * @param tag
      */
+    resumeSchedule(tag: string);
+    /**
+     * 恢复调度器
+     * @param target
+     */
+    resumeSchedule(target: FW.TargetType);
+    /**
+     * 暂停调度器
+     * @param id
+     */
+    resumeSchedule(id: number);
+
+    /**
+     * 每帧更新回调注册
+     * @param cb - 更新回调函数
+     * @param tag - 标签（可选）
+     */
     update(cb: (dt: number) => void, tag?: string): void;
-    update(cb: (dt: number) => void, target?: TargetType): void;
-    update(cb: (dt: number) => void, tag?: string, target?: TargetType): void;
+
+    /**
+     * 更新处理方法
+     * @param dt - 帧时间间隔
+     */
     onUpdate(dt: number): void;
   };
 
+  /**
+   * 事件管理器 - 负责全局事件的注册、派发和管理
+   */
   type EventManager = {
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 销毁方法 */
     onDestroy(): void;
+
     /**
-     * 注册事件
-     * @param eventName
-     * @param cb
-     * @param target
+     * 注册事件监听器
+     * @param eventName - 事件名称
+     * @param cb - 回调函数
+     * @param target - 目标对象
+     * @param options - 选项配置
      */
     register(
       eventName: string | number,
@@ -434,6 +688,13 @@ declare namespace FW {
       },
     );
 
+    /**
+     * 注册一次性事件监听器
+     * @param eventName - 事件名称
+     * @param cb - 回调函数
+     * @param target - 目标对象
+     * @param options - 选项配置
+     */
     registerOnce(
       eventName: string | number,
       cb: (
@@ -457,23 +718,24 @@ declare namespace FW {
 
     /**
      * 获取事件监听器数量
-     * @param eventName 事件名
+     * @param eventName - 事件名
      * @returns 监听器数量
      */
     getListenerCount(eventName: string | number): number;
+
     /**
      * 派发事件
-     * @param eventName
-     * @param args1
-     * @param args2
-     * @param args3
-     * @param args4
-     * @param args5
-     * @param args6
-     * @param args7
-     * @param args8
-     * @param args9
-     * @param args10
+     * @param eventName - 事件名称
+     * @param args1 - 参数1（可选）
+     * @param args2 - 参数2（可选）
+     * @param args3 - 参数3（可选）
+     * @param args4 - 参数4（可选）
+     * @param args5 - 参数5（可选）
+     * @param args6 - 参数6（可选）
+     * @param args7 - 参数7（可选）
+     * @param args8 - 参数8（可选）
+     * @param args9 - 参数9（可选）
+     * @param args10 - 参数10（可选）
      */
     dispatch(
       eventName: string | number,
@@ -488,43 +750,46 @@ declare namespace FW {
       args9?: FW.EventManagerArgs,
       args10?: FW.EventManagerArgs,
     ): void;
+
     /**
-     * 注销事件
-     * @param eventName
+     * 注销事件监听器
+     * @param eventName - 事件名称
+     * @param target - 目标对象
      */
     unRegister(eventName: string | number, target: TargetType): void;
 
     /**
-     * 注销所有事件
-     * @param eventName
+     * 注销所有指定事件的监听器
+     * @param eventName - 事件名称
      */
     eventOff(eventName: string | number): void;
 
     /**
-     * 注销目标所有事件
-     * @param target
+     * 注销目标对象上的所有事件监听器
+     * @param target - 目标对象
      */
     targetOff(target: TargetType): void;
 
     /**
-     * 目标对象是否注册了指定事件
-     * @param eventName
-     * @param target
+     * 检查目标对象是否注册了指定事件
+     * @param eventName - 事件名称
+     * @param target - 目标对象
+     * @returns 是否已注册
      */
     has(eventName: string | number, target: Comment | Object): boolean;
 
     /**
-     * 暂停目标身上注册事件
-     * @param target
+     * 暂停目标对象上的所有事件监听
+     * @param target - 目标对象
      */
     targetPause(target: TargetType): void;
+
     /**
-     * 恢复目标身上注册事件
-     * @param target
+     * 恢复目标对象上的所有事件监听
+     * @param target - 目标对象
      */
     targetResume(target: TargetType);
   };
-
   /**
    * 事件管理参数
    */
@@ -620,16 +885,23 @@ declare namespace FW {
   };
 
   /**
-   * 层级管理器
+   * 层级管理器 - 负责游戏界面层级的管理，包括打开、关闭、显示和隐藏等操作
    */
   type LayerManager = {
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 销毁方法 */
     onDestroy(): void;
+
+    /** 清理方法 */
     clear(): void;
 
     /**
      * 异步打开layer
-     * @param data
+     * @template Ctr - LayerController类型
+     * @param data - 层级打开参数
+     * @returns Promise返回打开的控制器实例
      */
     openAsync<Ctr extends FW.LayerController = FWLayerController>(
       data: LayerOpenArgs<Ctr>,
@@ -637,43 +909,60 @@ declare namespace FW {
 
     /**
      * 同步打开layer
-     * @param data
+     * @template Ctr - LayerController类型
+     * @param data - 层级打开参数
+     * @returns 打开的控制器实例
      */
     openSync<Ctr extends FW.LayerController = FWLayerController>(data: LayerOpenArgs<Ctr>): Ctr;
+
     /**
      * 显示常驻layer
-     * @param layer
+     * @template Ctr - LayerController类型
+     * @param ctr - 控制器实例
+     * @returns 控制器实例
      */
     displayLayer<Ctr extends FW.LayerController = FWLayerController>(ctr: Ctr): Ctr;
+
     /**
      * 隐藏常驻layer
-     * @param layer
+     * @template Ctr - LayerController类型
+     * @param ctr - 控制器实例
+     * @returns 控制器实例
      */
     hideLayer<Ctr extends FW.LayerController = FWLayerController>(ctr: Ctr): Ctr;
+
     /**
      * 关闭layer
-     * @param layer
+     * @template Ctr - LayerController类型
+     * @param ctr - 控制器实例
+     * @returns LayerController实例
      */
     close<Ctr extends FW.LayerController = FWLayerController>(ctr: Ctr): FWLayerController;
 
     /**
-     * 从栈关闭
+     * 从栈关闭指定数量的layer
+     * @param count - 关闭层数量，默认为1
      */
     closeFromStack(count?: number): void;
+
     /**
-     * 通过名字关闭
-     * @param name
+     * 通过名字关闭layer
+     * @param name - layer名称或名称数组
      */
     closeFromLayerName(name: string | string[]);
+
     /**
-     * 移除所有子Layer
-     * @param layer
+     * 移除指定节点的所有子Layer
+     * @param node - 父节点
      */
     removeAllChildren(node: cc.Node);
 
+    /**
+     * 获取Layer映射表
+     * @returns Map<控制器构造函数, LayerData>
+     */
     getLayerMap(): Map<new () => LayerController, LayerData>;
   };
-
   /**
    * 资源数据
    */
@@ -722,48 +1011,68 @@ declare namespace FW {
     assetProperty: AssetProperty;
   };
 
+  /**
+   * 资源管理器 - 负责游戏资源的加载、获取和释放等操作
+   */
   type ResManager = {
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 销毁方法 */
     onDestroy(): void;
 
     /**
-     * 加载包
-     * @param bundleName
+     * 加载指定bundle
+     * @param bundleName - bundle名称
+     * @returns Promise返回加载的bundle对象
      */
     loadBundle(bundleName: string): Promise<cc.AssetManager.Bundle>;
+
     /**
-     * 获取包
-     * @param bundleName
+     * 获取指定bundle
+     * @param bundleName - bundle名称
+     * @returns bundle对象
      */
     getBundle(bundleName: string): cc.AssetManager.Bundle;
+
     /**
-     * 获取所有bundle
+     * 获取所有bundle映射表
+     * @returns Map<bundle名称, bundle对象>
      */
     getBundleMap(): Map<string, cc.AssetManager.Bundle>;
+
     /**
-     * 释放包
-     * @param bundleName
+     * 释放指定bundle
+     * @param bundleName - bundle名称
      */
     releaseBundle(bundleName: string): void;
+
     /**
-     * 包是否存在
-     * @param bundleName
+     * 检查是否已加载指定bundle
+     * @param bundleName - bundle名称
+     * @returns 是否已加载
      */
     hasBundle(bundleName: string): boolean;
+
     /**
-     * 预加载
-     * @param assetProperty
+     * 预加载资源
+     * @param assetProperty - 资源属性或资源属性数组
      */
     preLoad(assetProperty: FW.AssetProperty | FW.AssetProperty[]);
+
     /**
      * 加载远程资源
-     * @param url
-     * @param cb
+     * @template T - 资源类型
+     * @param url - 资源URL
+     * @param cb - 回调函数
+     * @returns Promise返回加载的资源
      */
     loadRemote<T extends cc.Asset = cc.Asset>(url: string, cb?: (asset: cc.Asset) => T): Promise<T>;
+
     /**
-     * 从远程加载spine动画
-     * @param data
+     * 从远程加载spine动画数据
+     * @param data - spine资源信息
+     * @returns Promise返回spine骨骼数据
      */
     loadSpineDataFromRemote(data: {
       img: string;
@@ -773,42 +1082,54 @@ declare namespace FW {
     }): Promise<sp.SkeletonData>;
 
     /**
-     * 加载资源返回数据
-     * @param assetProperty
+     * 加载资源并返回资源数据
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @returns Promise返回资源数据
      */
     loadAssetData<T extends cc.Asset>(assetProperty: AssetProperty): Promise<AssetData>;
 
     /**
      * 加载资源
-     * @param assetProperty
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @param cb - 回调函数
+     * @returns Promise返回加载的资源
      */
     loadAsset<T extends cc.Asset>(assetProperty: AssetProperty, cb?: () => void): Promise<T>;
 
     /**
-     * 获取资源
-     * @param assetProperty
+     * 获取资源数据
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @returns 资源数据
      */
     getAssetData<T extends cc.Asset>(assetProperty: AssetProperty): AssetData;
 
     /**
      * 获取资源
-     * @param assetProperty
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @returns 资源对象
      */
     getAsset<T extends cc.Asset = cc.Asset>(assetProperty: AssetProperty): T;
+
     /**
      * 释放资源
-     * @param assetProperty
+     * @param assetProperty - 资源属性
      */
     releaseAsset(assetProperty: AssetProperty): void;
 
     /**
-     * 资源是否存在
-     * @param assetProperty
+     * 检查资源是否存在
+     * @param assetProperty - 资源属性
+     * @returns 资源是否存在
      */
     hasAsset(assetProperty: AssetProperty): boolean;
+
     /**
-     * 初始化远程包配置
-     * @param config
+     * 初始化远程bundle配置
+     * @param config - 远程bundle配置
      */
     initializeRemoteBundleConfig(config: RemoteBundleConfig): void;
   };
@@ -1075,71 +1396,83 @@ declare namespace FW {
   type TaskManager = {
     /**
      * 创建任务
-     * @param options
-     *
-     * frameBudget?: number; 每帧最大执行时间
-     * tasksFrameCount?: number; 每帧最多执行的任务个数
+     * @param options - 任务选项
+     * @returns Task对象
      */
-
     createTask(options?: Partial<FW.TaskOptions>): FW.Task;
+
     /**
-     * 获取任务
-     * @param taskId
+     * 获取指定ID的任务
+     * @param taskId - 任务ID
+     * @returns Task对象或undefined
      */
     getTask(taskId: number): FW.Task | undefined;
+
     /**
-     * 移除任务
-     * @param taskId
+     * 停止指定ID的任务
+     * @param taskId - 任务ID
      */
     stopTask(taskId: number): void;
+
     /**
      * 获取所有任务
+     * @returns Task数组
      */
     getAllTasks(): FW.Task[];
 
+    /** 销毁方法 */
     onDestroy();
   };
 
+  /**
+   * 状态管理器 - 负责创建和管理系统状态机
+   */
   type StateManager = {
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 销毁方法 */
     onDestroy(): void;
+
     /**
      * 创建一个状态机
-     * @param stateMachineName
+     * @param stateMachineName - 状态机名称（可选）
+     * @returns StateMachine对象
      */
     createStateMachine(stateMachineName?: string): StateMachine;
+
     /**
      * 移除一个状态机
-     * @param stateMachineName
-     * @returns
+     * @param stateMachineName - 状态机名称（可选）
      */
     removeStateMachine(stateMachineName?: string);
+
     /**
      * 暂停一个状态机
-     * @param stateMachineName
-     * @returns
+     * @param stateMachineName - 状态机名称（可选）
      */
     pauseStateMachine(stateMachineName?: string);
+
     /**
      * 恢复状态机
-     * @param stateMachineName
-     * @returns
+     * @param stateMachineName - 状态机名称（可选）
      */
     resumeStateMachine(stateMachineName?: string);
+
     /**
      * 注册状态进指定状态机
-     * @param stateMachineName
-     * @param state
-     * @returns
+     * @param state - 状态机注册参数
+     * @param stateMachineName - 状态机名称（可选）
      */
     register(
       state: FW.StateMachineRegisterArgs | FW.StateMachineRegisterArgs[],
       stateMachineName?: string,
     );
+
     /**
      * 注销指定状态机的某个状态
-     * @param stateMachineName
-     * @param stateType
+     * @param stateType - 状态类型
+     * @param stateMachineName - 状态机名称（可选）
      */
     unRegister(stateType: number, stateMachineName?: string);
   };
@@ -1149,42 +1482,89 @@ declare namespace FW {
     error: boolean;
   };
 
+  /**
+   * 动画管理器 - 负责游戏中的动画创建和管理
+   */
   type AnimationManager = {
+    /** 初始化方法 */
     initialize(): void;
+
+    /** 销毁方法 */
     onDestroy(): void;
 
     /**
      * 创建一个tween动画
-     * @param args
-     * @returns
+     * @param args - tween动画参数
+     * @returns Tween动画对象
      */
-    createTween(args?: FW.TweenArgs): FW.Tween;
+    createTween(args?: FW.TweenArgs): Tween;
+
     /**
      * 创建一个skeleton动画
-     * @param skeleton
-     * @returns
+     * @param skeleton - spine骨骼对象
+     * @returns Skeleton动画对象
      */
-    createSkeleton(skeleton: sp.Skeleton): FW.Skeleton;
+    createSkeleton(skeleton: sp.Skeleton): Skeleton;
 
-    /**
-     * 暂停所有动画
-     */
+    /** 暂停所有动画 */
     pauseAll(): void;
-    /**
-     * 恢复所有动画
-     * */
+
+    /** 恢复所有动画 */
     resumeAll(): void;
   };
 
+  /**
+   * Tween动画对象 - 用于创建和控制缓动动画
+   */
   type Tween = {
+    /** 动画名称 */
     animationName: string;
+
+    /** Cocos Creator原生Tween对象 */
     animation: cc.Tween;
+
+    /** 初始化回调函数（可选） */
     onInit?(): void;
+
+    /**
+     * 暂停动画
+     * @returns 当前Tween对象，支持链式调用
+     */
     pause(): FW.Tween;
+
+    /**
+     * 恢复动画
+     * @returns 当前Tween对象，支持链式调用
+     */
     resume(): FW.Tween;
+
+    /**
+     * 设置动画时间缩放比例
+     * @param scale - 时间缩放比例，1为正常速度，大于1加快，小于1减慢
+     * @returns 当前Tween对象，支持链式调用
+     */
     timeScale(scale: number): FW.Tween;
+
+    /**
+     * 开始播放动画
+     * @returns 当前Tween对象，支持链式调用
+     */
     start(): FW.Tween;
+
+    /**
+     * 停止动画
+     * @returns 当前Tween对象，支持链式调用
+     */
     stop(): FW.Tween;
+
+    /**
+     * 在指定时间内将属性变化到目标值
+     * @template OPTS - 选项类型
+     * @param duration - 持续时间（秒）
+     * @param props - 目标属性值
+     * @param opts - 动画选项（如缓动函数、进度回调等）
+     * @returns 当前Tween对象，支持链式调用
+     */
     to<
       OPTS extends Partial<{
         progress: Function;
@@ -1196,6 +1576,15 @@ declare namespace FW {
       props: ConstructorType<T>,
       opts?: OPTS,
     ): FW.Tween;
+
+    /**
+     * 在指定时间内将属性按照增量变化
+     * @template OPTS - 选项类型
+     * @param duration - 持续时间（秒）
+     * @param props - 属性增量值
+     * @param opts - 动画选项（如缓动函数、进度回调等）
+     * @returns 当前Tween对象，支持链式调用
+     */
     by<
       OPTS extends Partial<{
         progress: Function;
@@ -1207,50 +1596,87 @@ declare namespace FW {
       props: ConstructorType<T>,
       opts?: OPTS,
     ): FW.Tween;
+
+    /**
+     * 立即设置属性值
+     * @param props - 要设置的属性值
+     * @returns 当前Tween对象，支持链式调用
+     */
     set(props: ConstructorType<T>): FW.Tween;
   };
 
+  /**
+   * Spine骨骼动画对象 - 用于控制Spine骨骼动画的播放和设置
+   */
   type Skeleton = {
+    /**
+     * 播放动画
+     * @param args - 骨骼动画参数
+     * @returns Promise，在动画播放完成后resolve
+     */
     play(args?: FW.SkeletonArgs): Promise<void>;
+
+    /**
+     * 播放指定名称的动画
+     * @param animationName - 动画名称
+     * @param args - 骨骼动画参数
+     * @returns Promise，在动画播放完成后resolve
+     */
     play(animationName?: string, args?: FW.SkeletonArgs): Promise<void>;
-    /** 设置皮肤 */
+
+    /**
+     * 设置皮肤
+     * @param skinName - 皮肤名称
+     */
     setSkin(skinName: string);
-    /** 更新数据 */
+
+    /**
+     * 更新骨骼数据
+     * @param data - 新的骨骼数据
+     */
     updateSkeletonData(data: sp.SkeletonData);
 
+    /**
+     * 获取当前轨道条目
+     * @returns 轨道条目对象
+     */
     getTrackEntry();
+
     /**
-     * 是否存在动画名
-     * @param animName
-     * @returns
+     * 检查是否存在指定名称的动画
+     * @param animName - 动画名称
+     * @returns 是否存在该动画
      */
     hasAnimation(animName: string);
+
     /**
      * 获取所有动画
-     * @returns
+     * @returns 动画列表
      */
     getAnimations();
 
     /**
-     * 获取所有动画名字
-     * @returns
+     * 获取所有动画名称
+     * @returns 动画名称数组
      */
     getAnimationNames(): string[];
 
-    /** 速度缩放 */
-    timeScale(timeScale: number);
     /**
-     * 暂停
+     * 设置时间缩放比例
+     * @param timeScale - 时间缩放比例
      */
+    timeScale(timeScale: number);
+
+    /** 暂停动画 */
     pause(): void;
-    /**
-     * 恢复
-     */
+
+    /** 恢复动画 */
     resume(): void;
+
     /**
-     * 添加spine挂点
-     * @param boneName
-     * @param node
+     * 添加骨骼挂点
+     * @param boneName - 骨骼名称
+     * @param node - 要挂载的节点
      */
     addBone(boneName: string, node: cc.Node);
   };
@@ -1384,29 +1810,40 @@ declare namespace FW {
     onUpdate(dt?: number): void;
   };
 
+  /**
+   * 状态机 - 管理不同状态之间的转换和执行
+   */
   type StateMachine = {
+    /** 当前状态 */
     state: number;
 
-    enter(stateType: number, ...args: any): void;
-    /**
-     * 暂停状态机
-     * */
-    pause();
     /**
-     * 恢复状态机
+     * 进入指定状态
+     * @param stateType - 状态类型
+     * @param args - 传递给状态的参数
      */
+    enter(stateType: number, ...args: any): void;
+
+    /** 暂停状态机 */
+    pause();
+
+    /** 恢复状态机 */
     resume();
+
     /**
-     * 注册
-     * @param type
-     * @param state
+     * 注册状态
+     * @template T - 状态基类类型
+     * @param state - 状态机注册参数
      */
     register<T extends FWStateBase>(state: FW.StateMachineRegisterArgs<T>);
+
     /**
-     * 注销
-     * @param type
+     * 注销状态
+     * @param stateType - 状态类型
      */
     unRegister(stateType: number);
+
+    /** 销毁方法 */
     onDestroy();
   };
 
@@ -1424,62 +1861,72 @@ declare namespace FW {
     stateConstructor: { new (): T };
   };
 
+  /**
+   * 音频管理器 - 负责游戏中背景音乐和音效的播放控制
+   */
   type AudioManager = {
     /**
      * 播放背景音乐
-     * @param path
-     * @param volume
-     * @param loop
+     * @param path - 音频资源路径
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为true
      */
     playMusic(path: string, volume?: number, loop?: boolean): void;
+
     /**
      * 播放背景音乐
-     * @param music
-     * @param volume
-     * @param loop
+     * @param music - 音频剪辑对象
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为true
      */
     playMusic(music: cc.AudioClip, volume?: number, loop?: boolean);
+
     /**
      * 播放背景音乐
-     * @param assetProperty
-     * @param volume
-     * @param loop
+     * @param assetProperty - 资源属性
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为true
      */
     playMusic(assetProperty: AssetProperty, volume?: number, loop?: boolean): void;
-    /**
-     * 停止背景音乐
-     */
+
+    /** 停止背景音乐 */
     stopMusic(): void;
-    /**
-     * 暂停背景音乐
-     */
+
+    /** 暂停背景音乐 */
     pauseMusic(): void;
-    /**
-     * 恢复背景音乐
-     */
+
+    /** 恢复背景音乐 */
     resumeMusic(): void;
+
     /**
-     * 设置背景音效是否静音
-     * @param mute
+     * 设置背景音乐是否静音
+     * @param mute - 是否静音
      */
     setMusicMute(mute: boolean): void;
+
     /**
-     * 停止
-     * @param id
+     * 停止指定ID的音频
+     * @param id - 音频ID
      */
     stop(id: number): void;
+
     /**
      * 播放音效
-     * @param path
-     * @param volume
-     * @param loop
+     * @param path - 音频资源路径
+     * @param cb - 回调函数，参数为播放的音频ID
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为false
+     * @returns Promise<number> 音频ID
      */
     play(path: string, cb?: (id: number) => void, volume?: number, loop?: boolean): Promise<number>;
+
     /**
      * 播放音效
-     * @param audio
-     * @param volume
-     * @param loop
+     * @param audio - 音频剪辑对象
+     * @param cb - 回调函数，参数为播放的音频ID
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为false
+     * @returns Promise<number> 音频ID
      */
     play(
       audio: cc.AudioClip,
@@ -1487,11 +1934,14 @@ declare namespace FW {
       volume?: number,
       loop?: boolean,
     ): Promise<number>;
+
     /**
      * 播放音效
-     * @param assetProperty
-     * @param volume
-     * @param loop
+     * @param assetProperty - 资源属性
+     * @param cb - 回调函数，参数为播放的音频ID
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为false
+     * @returns Promise<number> 音频ID
      */
     play(
       assetProperty: AssetProperty,
@@ -1499,21 +1949,19 @@ declare namespace FW {
       volume?: number,
       loop?: boolean,
     ): Promise<number>;
-    /**
-     * 暂停所有
-     */
+
+    /** 暂停所有音频 */
     pauseAll(): void;
-    /**
-     * 恢复所有
-     */
+
+    /** 恢复所有音频 */
     resumeAll(): void;
-    /**
-     * 停止所有
-     */
+
+    /** 停止所有音频 */
     stopAll(): void;
+
     /**
-     * 设置播放音效是否静音
-     * @param mute
+     * 设置音效是否静音
+     * @param mute - 是否静音
      */
     setSoundMute(mute: boolean): void;
   };
@@ -1712,43 +2160,47 @@ declare namespace FW {
   };
 
   /**
-   * 任务
+   * 任务对象 - 代表一个可控制的异步任务
    */
   type Task = {
-    /** id */
+    /** 任务ID */
     readonly id: number;
+
     /**
      * 获取当前任务状态
+     * @returns 任务状态
      */
     getStatus(): FW.SystemDefine.FWTaskStatus;
+
     /**
-     * 任务开始
-     * @param generator
+     * 启动任务
+     * @param generator - 任务生成器函数
+     * @returns 当前Task对象，支持链式调用
      */
     start(generator: TaskFunction): Task;
+
     /**
      * 添加任务
-     * @param generator
+     * @param generator - 任务生成器函数
+     * @returns 当前Task对象，支持链式调用
      */
     add(generator: TaskFunction): Task;
-    /**
-     * 任务暂停
-     */
+
+    /** 暂停任务 */
     pause(): void;
-    /**
-     * 任务恢复
-     */
+
+    /** 恢复任务 */
     resume(): void;
-    /**
-     * 重置
-     */
+
+    /** 重置任务 */
     reset(): void;
-    /**
-     * 停止任务
-     */
+
+    /** 停止任务 */
     stop(): void;
+
     /**
      * 获取任务性能报告
+     * @returns 任务性能报告
      */
     getPerformanceReport(): TaskPerformanceReport;
   };
@@ -1837,8 +2289,6 @@ declare namespace FW {
     retryCondition?: (error: any, retryCount: number) => boolean;
   };
 
-  type Promise = (resolve: (value: any) => void, reject: (reason?: any) => void) => void;
-
   type PromiseAllResult<T = any> = {
     success: Array<{ id: number; value: T }>;
     failed: Array<{ id: number; reason: any }>;
@@ -1926,8 +2376,18 @@ declare namespace FW {
     createRegistry(bundleName: string): Registry;
     destroyRegistry(bundleName: string): void;
     register(data: RegisterFramework): void;
+    /**
+     * 注销组件
+     * @param data
+     */
     unRegister(data: RegisterFramework): void;
+    /**
+     * 重启框架
+     */
     restart(): void;
+    /**
+     * 获取已注册的组件
+     */
     getRegisteredComponents(): Map<string, RegisterFramework[]>;
   };
   declare let Framework: Framework;
@@ -1941,18 +2401,45 @@ declare namespace FW {
     public config?: FW.AssetConfig;
     public sender?: FW.Sender;
     public handle?: FW.Handle;
+
+    /**
+     * 调用Promise函数 并捕获性能数据
+     * @param operation
+     * @param operationName
+     */
     public invoke<T>(operation: Promise<T>, operationName: string = 'unknown'): Promise<T>;
+    /**
+     * 获取逻辑组件
+     */
     public getLogic<T extends FW.Logic = FWLogic>();
+    /**
+     * 获取数据组件
+     */
     public getData<T extends FW.Data = FWData>();
+    /**
+     * 获取发送组件
+     */
     public getSender<T extends FW.Sender>();
+    /**
+     * 获取处理组件
+     */
     public getHandle<T extends FW.Handle>();
+    /**
+     * 获取配置组件
+     */
     public getConfig<T extends FW.AssetConfig>();
+    /**
+     * 初始化依赖
+     */
     public initializeDependencies(): void;
   }
 }
 
 declare namespace FW {
   namespace SystemDefine {
+    /**
+     * 绑定标签
+     */
     export class FWBindTag {
       static LOGIC = 0;
       static DATA = 1;
@@ -1962,6 +2449,9 @@ declare namespace FW {
       static SUB_LOGIC = 5;
     }
 
+    /**
+     * 对象类型
+     */
     export class FWObjectType {
       static ACTIVE = 0;
       static OPACITY = 1;
@@ -1998,10 +2488,25 @@ declare namespace FW {
       static POPUP_DISPOSABLE = 3;
     }
 
+    /**
+     * 任务状态
+     */
     export class FWTaskStatus {
+      /**
+       * 待处理
+       */
       static IDLE = 'IDLE';
+      /**
+       * 运行中
+       */
       static RUNNING = 'RUNNING';
+      /**
+       * 暂停中
+       */
       static PAUSED = 'PAUSED';
+      /**
+       * 完成
+       */
       static COMPLETED = 'COMPLETED';
     }
 
@@ -2059,29 +2564,44 @@ declare namespace FW {
       static ANIMATION = 'ANIMATION';
     }
 
+    /**
+     * 滚动视图模板类型
+     */
     export class FWScrollViewTemplateType {
       static NODE = 0;
       static PREFAB = 1;
     }
 
+    /**
+     * 滚动视图滑动类型
+     */
     export class FWScrollViewSlideType {
       static NORMAL = 0;
       static ADHERING = 1;
       static PAGE = 2;
     }
 
+    /**
+     * 滚动视图选中类型
+     */
     export class FWScrollViewSelectedType {
       static NONE = 0;
       static SINGLE = 1;
       static MULTIPLE = 2;
     }
 
+    /**
+     * 语言资源类型
+     */
     export class FWLanguageAssetType {
       static LABEL = 'label';
       static SPRITE = 'sprite';
       static SKELETON = 'skeleton';
     }
 
+    /**
+     * Promise状态
+     */
     export class FWPromiseStatus {
       static PENDING = 'pending';
       static FULFILLED = 'fulfilled';
@@ -2089,6 +2609,9 @@ declare namespace FW {
       static CANCELLED = 'cancelled';
     }
 
+    /**
+     * 层状态
+     */
     export class FWLayerState {
       static CLOSED = 'closed';
       static OPENING = 'opening';
@@ -2096,6 +2619,9 @@ declare namespace FW {
       static CLOSING = 'closing';
     }
 
+    /**
+     * 音频类型
+     */
     export class FWAudioType {
       static MUSIC = 0;
       static SOUND = 1;
@@ -2130,11 +2656,20 @@ declare namespace FW {
       static ON_HIDE = 'ON_HIDE';
     }
   }
+  /**
+   * 系统定义
+   */
   export const SystemDefine: SystemDefine;
+  /**
+   * 事件定义
+   */
   export const EventDefine: EventDefine;
 }
 
 declare namespace FW {
+  /**
+   * layer基类
+   */
   export class Layer extends cc.Component {
     node: cc.Node;
     ctr: LayerController;
@@ -2147,6 +2682,9 @@ declare namespace FW {
     public lateUpdate(dt: number): void;
   }
 
+  /**
+   * layer控制器基类
+   */
   export class LayerController extends FrameworkBase {
     readonly entry: FW.Entry;
     logic?: Logic;
@@ -2203,9 +2741,16 @@ declare namespace FW {
         prototype: T;
       },
     ): T;
+    /**
+     * 注册事件
+     * @param args
+     */
     registerEvent(args: RegisterArgs): void;
+    /** 注销事件 */
     unRegisterEvent(args: RegisterArgs);
+    /** 注销所有事件 */
     unRegisterAll(): void;
+    /** 注销指定对象所有事件 */
     unRegisterTarget(target: TargetType);
     /** 暂停事件 */
     pauseEvent();
@@ -2213,11 +2758,18 @@ declare namespace FW {
     resumeEvent();
     /** 关闭layer */
     close();
+    /**
+     * 添加外部引用
+     * @param cb
+     */
     addExternalReference?(cb?: (ctr: any) => void);
   }
 }
 
 declare namespace FW {
+  /**
+   * 注册类
+   */
   export abstract class Registry {
     /**
      * bundle名字
@@ -2256,37 +2808,60 @@ declare namespace FW {
      */
     readonly handle?: Newable<SocketHandle>;
 
+    /**
+     * 注册
+     */
     register(): void;
+    /**
+     * 卸载
+     */
     unRegister(): void;
-
+    /**
+     * 启用bundle
+     */
     bundleEnabled(enable?: boolean);
   }
 }
 
 declare namespace FW {
+  /**
+   * 系统配置
+   */
   export const SystemConfig;
-
+  /**
+   * 场景
+   */
   export class Scene extends cc.Component {
     onLoad(): void;
     update(dt: number);
     onDestroy(): void;
   }
-
+  /**
+   * 逻辑
+   */
   export class Logic extends FrameworkBase {
     public initialize?(): void;
     public onDestroy?(): void;
   }
-
+  /**
+   * 数据
+   */
   export class Data extends FrameworkBase {
     public initialize?(): void;
     public onDestroy?(): void;
   }
 
+  /**
+   * 资源配置
+   */
   export abstract class AssetConfig {
     abstract preLoad: LoadConfig;
     abstract demandLoad: LoadConfig;
   }
 
+  /**
+   * socket发送者
+   */
   export abstract class Sender extends FrameworkBase {
     initialize?();
     onDestroy?();
@@ -2296,54 +2871,83 @@ declare namespace FW {
     getProtocolKey?(msg: any): string;
     send(msg: any);
   }
-
+  /**
+   * socket处理者
+   */
   export abstract class Handle extends FrameworkBase {
     initialize?();
     onDestroy?();
     onWeakNetWork?(): void;
-    abstract onMessage(msg: any): void;
     onHeart?(msg: any): Promise<boolean>;
     onClose?(): void;
     onOpen?(): void;
     onError?(msg: any): void;
     onTimeout?(): void;
+    abstract onMessage(msg: any): void;
     abstract getProtocolKey?(msg: any): string;
     abstract onBeforeReceivingMessage?(msg: any): Promise<FW.SocketMessage>;
   }
 }
 
 declare namespace FW {
+  /**
+   * 服务
+   */
   export abstract class Service extends FrameworkBase {
     public abstract initialize(): void;
     public abstract onDestroy(): void;
   }
-  export class Http extends FWService {
+  /**
+   * http服务
+   */
+  export class Http extends Service {
     public initialize() {}
     public onDestroy(): void {}
-
+    /**
+     * get请求
+     * @param url
+     * @param params
+     * @param cb
+     * @param tag
+     */
     async getMessage(
       url: string,
       params?: string,
       cb?: (response: string) => void,
       tag?: string,
     ): Promise<string>;
-
+    /**
+     * post请求
+     * @param url
+     * @param params
+     * @param cb
+     * @param tag
+     */
     async postMessage(
       url: string,
       params?: string,
       cb?: (response: string) => void,
       tag?: string,
     ): Promise<string>;
-
+    /**
+     * 请求错误
+     * @param err
+     */
     onError?(err: any);
+    /**
+     * 请求超时
+     */
     onTimeout?();
   }
 }
 
 declare namespace FW {
+  /**
+   * 模拟socket
+   */
   export class SocketMock {
-    static createMockData<T>(msgId: string, data: T);
-    public static start(mockResponses: {}): void;
+    public static start(): void;
     public static stop(): void;
+    public static updateMockResponses(mockResponses: {});
   }
 }