@kkarum/framework 2.3.17

package/types/FW.d.ts

@@ -0,0 +1,3016 @@
+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<
+    TInstance,
+    TArgs
+  >;
+  type CommonServiceIdentifier<TInstance = unknown> = ServiceIdentifierData<TInstance>;
+
+  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;
+    /** 通用工具类 */
+    utils: Utils;
+    /** 场景组件 */
+    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名称
+     * @param forceRelease - 是否强制释放当前包资源
+     */
+    launchScene(bundleName: string,forceRelease?:boolean): 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,
+        reject: (reason?: any) => void,
+        signal?: AbortSignal,
+        reason?: any,
+      ) => 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);
+  };
+
+  type Language = {
+    onRefresh(): void;
+  };
+
+  type ComponentManager = {
+    bindVirtualViewComponent(args: FW.VirtualViewComponentArgs);
+  };
+
+  type ObjectManager = {
+    /** 创建一个对象池 */
+    createObjectPool<T extends FW.Object = FWObject>(
+      node: cc.Node,
+      parent: cc.Node,
+      tag?: string,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FW.Object = FWObject>(
+      prefab: cc.Prefab,
+      parent: cc.Node,
+      tag?: string,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FW.Object = FWObject>(
+      assetProperty: FW.AssetProperty,
+      parent: cc.Node,
+      tag?: string,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FW.Object = FWObject>(
+      node: cc.Node,
+      parent: cc.Node,
+      type?: number,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FW.Object = FWObject>(
+      prefab: cc.Prefab,
+      parent: cc.Node,
+      type?: number,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FW.Object = FWObject>(
+      assetProperty: FW.AssetProperty,
+      parent: cc.Node,
+      type?: number,
+    ): Promise<ObjectPool<T>>;
+    /** 获取已经创建的对象池 */
+    getObjectPool(tag: string): ObjectPool;
+
+    /** 销毁一个对象池 */
+    destroyObjectPool(tag: string): void;
+    /** 获取对象池状态 */
+    getPoolStats(): { total: number; tags: string[] };
+    /** 清理所有对象池 */
+    clearAllPools(): void;
+  };
+
+  type ObjectPool = {
+    getEnableObjectMap();
+    getDisableObjectMap();
+    getAllObjectMap();
+    isEmpty():boolean;
+    findObjectProperty(node: cc.Node);
+    findObjectProperty(component: FW.Object);
+    findObjectProperty(uniqueId: number);
+    get(...args: any): FW.ObjectProperty;
+    put(node: cc.Node);
+    put(component: FW.Object);
+    put(uniqueId: number);
+    onDestroy();
+  };
+
+  /**
+   * Socket管理器 - 负责WebSocket连接的管理
+   */
+  type SocketManager = {
+    /**
+     * 创建Socket连接
+     * @param tag - 标识符
+     * @param address - 地址
+     * @param sender - 发送器
+     * @param handle - 处理器
+     * @param config - 配置
+     * @returns Socket实例的Promise
+     */
+    createSocket(
+      tag: string,
+      address: string,
+      sender: Sender,
+      handle: Handle,
+      config: SocketConfig,
+    ): Promise<Socket>;
+
+    /**
+     * 获取Socket实例
+     * @param tag - 标识符（可选）
+     * @returns Socket实例
+     */
+    getSocket(tag?: string): Socket;
+
+    /**
+     * 获取所有Socket映射
+     * @returns Socket映射表
+     */
+    getSocketMap(): Map<string, Socket>;
+    /** 关闭所有Socket连接 */
+    closeAll():void;
+    /** 暂停消息处理 */
+    pauseMessageHandle(): void;
+    /** 恢复消息处理 */
+    resumeMessageHandle(): void;
+
+    /**
+     * 关闭Socket连接
+     * @param fs - Socket实例
+     */
+    closeSocket(fs: Socket): void;
+  };
+
+  type ScrollViewComponent = {
+    /**
+     * 模板类型,1:cc.Node,2.cc.prefab
+     */
+    templateType: number;
+    /**
+     * 滑动类型 1.无 2.粘性模式,强制关闭不自动滑动,3.页面模式,强制关闭不自动滑动
+     */
+    slideType: number;
+    /**
+     * 是否是虚拟列表
+     */
+    virtual: boolean;
+  };
+
+  type SocketPromiseProxy = {
+    promise: Promise<FW.Socket>;
+    resolve: Function;
+    socket: FW.Socket;
+  };
+
+  type ProtocolPolling = {
+    msg: string;
+    schedule: TimerSchedule;
+  };
+
+  /**
+   * Socket连接对象
+   */
+  type Socket = {
+    /** 销毁方法 */
+    public onDestroy(): void;
+
+    /**
+     * 获取标识符
+     * @returns 标识符字符串
+     */
+    public getTag(): string;
+
+    /**
+     * 获取地址
+     * @returns 地址字符串
+     */
+    getAddress(): string;
+
+    /**
+     * 获取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,
+      sender: Sender,
+      handle: SocketHandle,
+      config: SocketConfig,
+    ): SocketPromiseProxy;
+  };
+
+  /**
+   * Socket配置
+   */
+  type SocketConfig = Partial<{
+    /** 心跳间隔 */
+    heartInternal: number;
+    /** 心跳超时时间 */
+    heartTimeout: number;
+    /** 心跳弱网时间 */
+    heartWeakTime: number;
+    /** 最大重连次数 */
+    maxReconnectTimes: number;
+    /** 重连间隔 */
+    reconnectInternal: number;
+    /** 协议符号 */
+    protocolSymbol: Symbol;
+    /** 协议轮询时间 */
+    protocolPollingTime: number;
+    /** 证书（可选） */
+    certificate: cc.Asset;
+  }>;
+
+  /**
+   * 观察者
+   */
+  type Observer = {
+    priority: number;
+    intercept: boolean;
+    once: boolean;
+    /**
+     * 事件通知
+     */
+    notify(
+      args1?: FW.EventManagerArgs,
+      args2?: FW.EventManagerArgs,
+      args3?: FW.EventManagerArgs,
+      args4?: FW.EventManagerArgs,
+      args5?: FW.EventManagerArgs,
+      args6?: FW.EventManagerArgs,
+      args7?: FW.EventManagerArgs,
+      args8?: FW.EventManagerArgs,
+      args9?: FW.EventManagerArgs,
+      args10?: FW.EventManagerArgs,
+    );
+    /**
+     * 比较目标
+     */
+    compar(target: TargetType);
+    /**
+     * 获取事件名字
+     */
+    getEventName(): string | number;
+    /**
+     * 暂停观察
+     */
+    pauseObserver(): void;
+    /**
+     * 恢复观察
+     */
+    resumeObserver(): void;
+  };
+
+  type TargetType = cc.Component | Record<string, any> | cc.Node;
+
+  type Symbol = string | number;
+
+  type UiManager = {
+    register(args: RegisterArgs);
+    find(path: string, referenceNode: cc.Node): cc.Node;
+    pauseEvent<T extends TargetType>(target: T);
+    resumeEvent<T extends TargetType>(target: T);
+    hasRegister(eventName: string, target: FW.TargetType): boolean;
+    unRegisterEvent(args: RegisterArgs);
+    unRegisterTarget(target: TargetType);
+    unRegisterAll();
+    buttonEnable(target: TargetType);
+    buttonDisable(target: TargetType);
+  };
+
+  /**
+   * 时间管理器 - 负责游戏中的定时器和更新循环
+   */
+  type TimeManager = {
+    /** 初始化方法 */
+    initialize(): void;
+
+    /** 销毁方法 */
+    onDestroy(): void;
+
+    /**
+     * 获取当前时间字符串
+     * @returns 时间字符串
+     */
+    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,
+      repeat?: number,
+      target?: TargetType,
+      tag?: string,
+    ): TimerSchedule;
+
+    /**
+     * 暂停调度器
+     * @param tag
+     */
+    pauseSchedule(tag: string);
+    /**
+     * 暂停调度器
+     * @param target
+     */
+    pauseSchedule(target: FW.TargetType);
+    /**
+     * 暂停调度器
+     * @param id
+     */
+    pauseSchedule(id: number);
+
+    /**
+     * 停止调度器
+     * @param tag
+     */
+    unSchedule(tag: string);
+    /**
+     * 停止调度器
+     * @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;
+
+    /**
+     * 更新处理方法
+     * @param dt - 帧时间间隔
+     */
+    onUpdate(dt: number): void;
+  };
+
+  /**
+   * 事件管理器 - 负责全局事件的注册、派发和管理
+   */
+  type EventManager = {
+    /** 初始化方法 */
+    initialize(): void;
+
+    /** 销毁方法 */
+    onDestroy(): void;
+
+    /**
+     * 注册事件监听器
+     * @param eventName - 事件名称
+     * @param cb - 回调函数
+     * @param target - 目标对象
+     * @param options - 选项配置
+     */
+    register(
+      eventName: string | number,
+      cb: (
+        args1?: EventManagerArgs,
+        args2?: EventManagerArgs,
+        args3?: EventManagerArgs,
+        args4?: EventManagerArgs,
+        args5?: EventManagerArgs,
+        args6?: EventManagerArgs,
+        args7?: EventManagerArgs,
+        args8?: EventManagerArgs,
+        args9?: EventManagerArgs,
+        args10?: EventManagerArgs,
+      ) => void,
+      target: TargetType,
+      options?: {
+        priority?: FW.SystemDefine.FWPriorityOrder;
+        intercept?: boolean;
+      },
+    );
+
+    /**
+     * 注册一次性事件监听器
+     * @param eventName - 事件名称
+     * @param cb - 回调函数
+     * @param target - 目标对象
+     * @param options - 选项配置
+     */
+    registerOnce(
+      eventName: string | number,
+      cb: (
+        args1?: EventManagerArgs,
+        args2?: EventManagerArgs,
+        args3?: EventManagerArgs,
+        args4?: EventManagerArgs,
+        args5?: EventManagerArgs,
+        args6?: EventManagerArgs,
+        args7?: EventManagerArgs,
+        args8?: EventManagerArgs,
+        args9?: EventManagerArgs,
+        args10?: EventManagerArgs,
+      ) => void,
+      target: TargetType,
+      options?: {
+        priority?: number;
+        intercept?: boolean;
+      },
+    ): void;
+
+    /**
+     * 获取事件监听器数量
+     * @param eventName - 事件名
+     * @returns 监听器数量
+     */
+    getListenerCount(eventName: string | number): number;
+
+    /**
+     * 派发事件
+     * @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,
+      args1?: FW.EventManagerArgs,
+      args2?: FW.EventManagerArgs,
+      args3?: FW.EventManagerArgs,
+      args4?: FW.EventManagerArgs,
+      args5?: FW.EventManagerArgs,
+      args6?: FW.EventManagerArgs,
+      args7?: FW.EventManagerArgs,
+      args8?: FW.EventManagerArgs,
+      args9?: FW.EventManagerArgs,
+      args10?: FW.EventManagerArgs,
+    ): void;
+
+    /**
+     * 注销事件监听器
+     * @param eventName - 事件名称
+     * @param target - 目标对象
+     */
+    unRegister(eventName: string | number, target: TargetType): void;
+
+    /**
+     * 注销所有指定事件的监听器
+     * @param eventName - 事件名称
+     */
+    eventOff(eventName: string | number): void;
+
+    /**
+     * 注销目标对象上的所有事件监听器
+     * @param target - 目标对象
+     */
+    targetOff(target: TargetType): void;
+
+    /**
+     * 检查目标对象是否注册了指定事件
+     * @param eventName - 事件名称
+     * @param target - 目标对象
+     * @returns 是否已注册
+     */
+    has(eventName: string | number, target: Comment | Object): boolean;
+
+    /**
+     * 暂停目标对象上的所有事件监听
+     * @param target - 目标对象
+     */
+    targetPause(target: TargetType): void;
+
+    /**
+     * 恢复目标对象上的所有事件监听
+     * @param target - 目标对象
+     */
+    targetResume(target: TargetType);
+  };
+  /**
+   * 事件管理参数
+   */
+  type EventManagerArgs = string | number | object | void | boolean | [];
+
+  /**
+   * 层级打开参数
+   */
+  type LayerOpenArgs = {
+    /**
+     * 控制器类型
+     */
+    type: new () => LayerController;
+    /**
+     * 父节点
+     */
+    parent?: cc.Node;
+    /**
+     * 坐标
+     */
+    position?: Vec3;
+    /**
+     * 传递参数
+     */
+    args?: any;
+  };
+
+  type Vec3 = {
+    x: number;
+    y: number;
+  };
+
+  /**
+   * 层级数据
+   */
+  type LayerData = {
+    /**
+     * 外部引用
+     */
+    externalReference?: Set<(ref: LayerController | null) => void> = new Set();
+    /**
+     * 构造类
+     */
+    controllerConstructor: new () => FW.LayerController;
+    /**
+     * 唯一id
+     */
+    uuid: string;
+    /**
+     * layer名字
+     */
+    layerName: string;
+    /**
+     * layer
+     */
+    layer: FWLayer;
+    /**
+     * layer资源属性
+     */
+    layerAssetProperty: AssetProperty;
+    /**
+     * layer类型
+     */
+    layerType: FW.SystemDefine.FWLayerType;
+    /**
+     * layer渲染顺序
+     */
+    layerRenderOrder: FW.SystemDefine.FWLayerRenderOrder;
+    /**
+     * layer控制器名字
+     */
+    controllerName: string;
+    /**
+     * layer控制器
+     */
+    controller: LayerController;
+    /**
+     * 是否加载完成
+     */
+    loaded: boolean;
+    /**
+     * layer父节点
+     */
+    layerParent?: cc.Node;
+    /**
+     * 坐标
+     */
+    layerPosition?: Vec3;
+    /**
+     * 代理
+     */
+    controllerProxy: LayerController;
+  };
+
+  /**
+   * 层级管理器 - 负责游戏界面层级的管理，包括打开、关闭、显示和隐藏等操作
+   */
+  type LayerManager = {
+    /** 初始化方法 */
+    initialize(): void;
+
+    /** 销毁方法 */
+    onDestroy(): void;
+
+    /** 清理方法 */
+    clear(): void;
+    /** 开启调试 */
+    openDebug():void;
+    /** 是否开启调试 */
+    isDebug():boolean;
+
+    /**
+     * 异步打开layer
+     * @template Ctr - LayerController类型
+     * @param data - 层级打开参数
+     * @returns Promise返回打开的控制器实例
+     */
+    openAsync<Ctr extends FW.LayerController = FWLayerController>(
+      data: LayerOpenArgs<Ctr>,
+    ): Promise<Ctr>;
+
+    /**
+     * 同步打开layer
+     * @template Ctr - LayerController类型
+     * @param data - 层级打开参数
+     * @returns 打开的控制器实例
+     */
+    openSync<Ctr extends FW.LayerController = FWLayerController>(data: LayerOpenArgs<Ctr>): Ctr;
+
+    /**
+     * 显示常驻layer
+     * @template Ctr - LayerController类型
+     * @param ctr - 控制器实例
+     * @returns 控制器实例
+     */
+    displayLayer<Ctr extends FW.LayerController = FWLayerController>(ctr: Ctr): Ctr;
+
+    /**
+     * 隐藏常驻layer
+     * @template Ctr - LayerController类型
+     * @param ctr - 控制器实例
+     * @returns 控制器实例
+     */
+    hideLayer<Ctr extends LayerController = LayerController>(ctr: Ctr): Ctr;
+
+    /**
+     * 关闭layer
+     * @template Ctr - LayerController类型
+     * @param ctr - 控制器实例
+     * @returns LayerController实例
+     */
+    close<Ctr extends LayerController = LayerController>(ctr: Ctr): Promise<Ctr>;
+
+    /**
+     * 从栈关闭指定数量的layer
+     * @param count - 关闭层数量，默认为1
+     */
+    closeFromStack(count?: number): void;
+
+    /**
+     * 通过名字关闭layer
+     * @param name - layer名称或名称数组
+     */
+    closeFromLayerName(name: string | string[]);
+
+    /**
+     * 移除指定节点的所有子Layer
+     * @param node - 父节点
+     */
+    removeAllChildren(node: cc.Node);
+
+    /**
+     * 获取Layer映射表
+     * @returns Map<控制器构造函数, LayerData>
+     */
+    getLayerMap(): Map<new () => LayerController, LayerData>;
+  };
+  /**
+   * 资源数据
+   */
+  type AssetData = {
+    /** 资源 */
+    asset: T;
+    /**
+     * 资源id
+     */
+    uuid: string;
+    /**
+     * 资源使用者
+     */
+    user: string;
+    /**
+     * 资源依赖
+     */
+    depend: string[];
+    /**
+     * 资源引用
+     */
+    reference: string[];
+    /**
+     * 资源类型
+     */
+    type: typeof cc.Asset;
+    /**
+     * 所属bundle
+     */
+    dependentBundle: string;
+    /**
+     * 是否加载完成
+     */
+    loaded: boolean;
+    /**
+     * 释放时是否从bundle内释放
+     */
+    autoRelease: boolean;
+    /**
+     * 资源属性
+     */
+    assetProperty: AssetProperty;
+  };
+
+  type ResRejectHandlerListener = {
+    loadResHandler:(err: Error | null, asset: AssetProperty | string | null) => void;
+    loadBundleHandler:(err: Error | null, bundle: string | null) => void;
+  }
+  /**
+   * 资源管理器 - 负责游戏资源的加载、获取和释放等操作
+   */
+  type ResManager = {
+    /** 初始化方法 */
+    initialize(): void;
+
+    /** 销毁方法 */
+    onDestroy(): void;
+    /** 注册拒绝处理器 */
+    registerRejectHandler(listener: ResRejectHandlerListener): void;
+    /**
+     * 加载指定bundle
+     * @param bundleName - bundle名称
+     * @returns Promise返回加载的bundle对象
+     */
+    loadBundle(bundleName: string): Promise<cc.AssetManager.Bundle>;
+
+    /**
+     * 获取指定bundle
+     * @param bundleName - bundle名称
+     * @returns bundle对象
+     */
+    getBundle(bundleName: string): cc.AssetManager.Bundle;
+
+    /**
+     * 获取所有bundle映射表
+     * @returns Map<bundle名称, bundle对象>
+     */
+    getBundleMap(): Map<string, cc.AssetManager.Bundle>;
+
+    /**
+     * 释放指定bundle
+     * @param bundleName - bundle名称
+     */
+    releaseBundle(bundleName: string): void;
+
+    /**
+     * 检查是否已加载指定bundle
+     * @param bundleName - bundle名称
+     * @returns 是否已加载
+     */
+    hasBundle(bundleName: string): boolean;
+
+    /**
+     * 预加载资源
+     * @param assetProperty - 资源属性或资源属性数组
+     */
+    preLoad(assetProperty: FW.AssetProperty | FW.AssetProperty[]);
+
+    /**
+     * 加载远程资源
+     * @template T - 资源类型
+     * @param url - 资源URL
+     * @param cb - 回调函数
+     * @returns Promise返回加载的资源
+     */
+    loadRemote<T extends cc.Asset = cc.Asset>(url: string, options?: {
+      ext?: string;
+      enableCache?: boolean;
+      maxRetryCount?: number;
+      texture?:boolean;
+      cb?: (asset: T) => void;
+    },): Promise<T>;
+
+    /**
+     * 从远程加载spine动画数据
+     * @param data - spine资源信息
+     * @returns Promise返回spine骨骼数据
+     */
+    loadSpineDataFromRemote(data: {
+      img: string;
+      ske: string;
+      atlas: string;
+      bin?: boolean;
+    }): Promise<sp.SkeletonData>;
+
+    /**
+     * 加载资源并返回资源数据
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @returns Promise返回资源数据
+     */
+    loadAssetData<T extends cc.Asset>(assetProperty: AssetProperty): Promise<AssetData>;
+
+    /**
+     * 加载资源
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @param cb - 回调函数
+     * @returns Promise返回加载的资源
+     */
+    loadAsset<T extends cc.Asset>(assetProperty: AssetProperty, texture?: boolean): Promise<T>;
+
+    /**
+     * 获取资源数据
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @returns 资源数据
+     */
+    getAssetData<T extends cc.Asset>(assetProperty: AssetProperty, texture?: boolean): AssetData;
+
+    /**
+     * 获取资源
+     * @template T - 资源类型
+     * @param assetProperty - 资源属性
+     * @returns 资源对象
+     */
+    getAsset<T extends cc.Asset = cc.Asset>(assetProperty: AssetProperty, texture?: boolean): T;
+
+    /**
+     * 释放资源
+     * @param assetProperty - 资源属性
+     */
+    releaseAsset(assetProperty: AssetProperty): void;
+
+    /**
+     * 检查资源是否存在
+     * @param assetProperty - 资源属性
+     * @returns 资源是否存在
+     */
+    hasAsset(assetProperty: AssetProperty): boolean;
+
+    /**
+     * 初始化远程bundle配置
+     * @param config - 远程bundle配置
+     */
+    initializeRemoteBundleConfig(config: RemoteBundleConfig): void;
+  };
+
+  type RemoteBundleConfig = {
+    bundleName: string;
+    url: string;
+    version: string;
+  };
+
+  type BundleManager = {
+    initialize();
+    onDestroy();
+    /**
+     * 初始化远程包配置
+     * @param config
+     */
+    initializeRemoteBundleConfig(config: FW.RemoteBundleConfig): void;
+
+    getBundleMap(): Map<string, cc.AssetManager.Bundle>;
+    /**
+     * 加载包
+     * @param bundleName
+     */
+    load(bundleName: string): Promise<AssetManager.Bundle>;
+
+    /**
+     * 获取包
+     * @param bundleName
+     */
+    get(bundleName: string): AssetManager.Bundle;
+
+    /**
+     * 释放包
+     * @param bundleName
+     */
+    release(bundleName: string): void;
+
+    /**
+     * 是否已经加载某个bundle
+     * @param bundleName
+     */
+    has(bundleName: string): boolean;
+  };
+
+  type AssetProperty = {
+    /**
+     * 资源id
+     */
+    resourceId?: number;
+    /**
+     * 所在bundle
+     */
+    bundle?: string;
+    /**
+     * 资源路径
+     */
+    path: string;
+    /**
+     * 资源类型
+     */
+    type?: typeof Asset;
+    /**
+     * 加载完成回调
+     * @param asset
+     * @returns
+     */
+    cb?: (asset: AssetData | AssetData[]) => void;
+    /**
+     * 进度回调
+     * @param finish
+     * @param total
+     * @param item
+     * @returns
+     */
+    progress?: (finish: number, total: number, item: RequestItem) => void;
+    /**
+     * 资源使用者
+     */
+    user?: string;
+    /**
+     * 是否需要自动释放
+     */
+    autoRelease?: boolean;
+    /**
+     * 是否优先加载
+     */
+    priorityLoaded?: boolean;
+  };
+
+  type HotUpdateManager = {
+    setListener(listener: HotUpdateListener): HotUpdateManager;
+    update(localManifest: cc.Asset): void;
+  };
+
+  type HotUpdateListener = {
+    versionCompareHandle: (currentVersion: string, newVersion: string) => void;
+    checkHotUpdateHandle: (code: string) => void;
+    hotUpdatingHandle: (code: string, param: HotUpdatingParam) => void;
+    completedHandle: (version: string) => void;
+    retryHandle: () => void;
+  };
+
+  type HotUpdatingParam = Partial<{
+    downloadedFiles: number;
+    totalFiles: number;
+    downloadedBytes: number;
+    totalBytes: number;
+    percent: number;
+    convertDownloadedBytes: string;
+    convertTotalBytes: string;
+  }>;
+
+  type AssetManager = {
+    initialize();
+    onDestroy();
+    /**
+     * 加载远程资源
+     * @param url
+     * @param cb
+     */
+    loadRemote<T extends cc.Asset = cc.Asset>(url: string, options?: {
+      ext?: string;
+      enableCache?: boolean;
+      maxRetryCount?: number;
+      cb?: (asset: T) => void;
+    }): Promise<T>;
+    /**
+     * 从远程加载spine动画
+     * @param data
+     */
+    loadSpineDataFromRemote(data: {
+      img: string;
+      ske: string;
+      atlas: string;
+      bin?: boolean;
+    }): Promise<sp.SkeletonData>;
+    preLoad(assetProperty: FW.AssetProperty | FW.AssetProperty[]);
+    /**
+     * 加载资源
+     * @param asset
+     */
+    load(assetProperty: AssetProperty): Promise<AssetData>;
+
+    loadDir(assetProperty: AssetProperty): Promise<FW.AssetData[]>;
+
+    /**
+     * 获取资源
+     * @param asset
+     */
+    get(assetProperty: AssetProperty): AssetData;
+
+    /**
+     * 释放资源
+     */
+    release(assetProperty: AssetProperty): void;
+
+    /**
+     * 获取资源引用计数
+     * @param assetProperty
+     */
+    getReferenceCount(assetProperty: AssetProperty): number;
+
+    /**
+     * 是否已经加载
+     * @param uuid
+     */
+    has(assetProperty: AssetProperty): boolean;
+  };
+
+  type EngineManager = {
+    debug: boolean;
+    getMemory(): void;
+    restart(): void;
+  };
+
+  type CCEvent = {
+    cb: (...args: any) => void;
+    target: TargetType;
+  } & Partial<{
+    eventName: string;
+    responseInterval: number;
+    pause: boolean;
+    enable: boolean;
+    responseTime: number;
+    lastResponseTimestamp: number;
+    data: any;
+  }>;
+
+  type FWEvent = {
+    cb: (...args: any) => void;
+  } & Partial<{
+    eventName: string;
+    responseTime: number;
+    responseInterval: number;
+    lastResponseTimestamp: number;
+    options: {
+      priority?: number;
+      intercept?: boolean;
+      pause?: boolean;
+      enable?: boolean;
+    };
+  }>;
+
+  type RegisterArgs = {
+    target?: any;
+    CCEvent?: CCEvent[];
+    FWEvent?: FWEvent[];
+  };
+
+  type RegisterEventArgs = Partial<{
+    /** 事件名字 */
+    eventName?: string;
+    /**
+     * CC事件
+     */
+    CCEvent?: CCEvent;
+    /**
+     * 注册事件对象
+     */
+    target?: any;
+    /**
+     * 自定义事件
+     */
+    FWEvent?: FWEvent;
+    /**
+     * 上一次响应时间戳
+     */
+    lastResponseTimestamp?: number;
+    /**
+     * 响应间隔
+     */
+    responseInterval?: number;
+    /**
+     * 参数
+     */
+    data?: any;
+    /**
+     * 是否启用
+     */
+    enable?: boolean;
+  }>;
+
+  /**
+   * 时间调度器
+   */
+  type TimerSchedule = {
+    /**
+     * 时间对象
+     */
+    timer: Timer;
+    /**
+     * promise
+     */
+    promise?: Promise<void>;
+    /**
+     * 取消调度器
+     */
+    unSchedule(): void;
+    /**
+     * 暂停
+     */
+    pauseSchedule(): void;
+    /**
+     * 恢复
+     */
+    resumeSchedule(): void;
+  };
+
+  type TaskManager = {
+    /**
+     * 创建任务
+     * @param options - 任务选项
+     * @returns Task对象
+     */
+    createTask(options?: Partial<FW.TaskOptions>): FW.Task;
+
+    /**
+     * 获取指定ID的任务
+     * @param taskId - 任务ID
+     * @returns Task对象或undefined
+     */
+    getTask(taskId: number): FW.Task | undefined;
+
+    /**
+     * 停止指定ID的任务
+     * @param taskId - 任务ID
+     */
+    stopTask(taskId: number): void;
+
+    /**
+     * 获取所有任务
+     * @returns Task数组
+     */
+    getAllTasks(): FW.Task[];
+
+    /** 销毁方法 */
+    onDestroy();
+  };
+
+  /**
+   * 状态管理器 - 负责创建和管理系统状态机
+   */
+  type StateManager = {
+    /** 初始化方法 */
+    initialize(): void;
+
+    /** 销毁方法 */
+    onDestroy(): void;
+
+    /**
+     * 创建一个状态机
+     * @param stateMachineName - 状态机名称（可选）
+     * @returns StateMachine对象
+     */
+    createStateMachine(stateMachineName?: string): StateMachine;
+
+    /**
+     * 移除一个状态机
+     * @param stateMachineName - 状态机名称（可选）
+     */
+    removeStateMachine(stateMachineName?: string);
+
+    /**
+     * 暂停一个状态机
+     * @param stateMachineName - 状态机名称（可选）
+     */
+    pauseStateMachine(stateMachineName?: string);
+
+    /**
+     * 恢复状态机
+     * @param stateMachineName - 状态机名称（可选）
+     */
+    resumeStateMachine(stateMachineName?: string);
+
+    /**
+     * 注册状态进指定状态机
+     * @param state - 状态机注册参数
+     * @param stateMachineName - 状态机名称（可选）
+     */
+    register(
+      state: FW.StateMachineRegisterArgs | FW.StateMachineRegisterArgs[],
+      stateMachineName?: string,
+    );
+
+    /**
+     * 注销指定状态机的某个状态
+     * @param stateType - 状态类型
+     * @param stateMachineName - 状态机名称（可选）
+     */
+    unRegister(stateType: number, stateMachineName?: string);
+  };
+
+  type SocketMessage = {
+    data: any;
+    error: boolean;
+  };
+
+  /**
+   * 动画管理器 - 负责游戏中的动画创建和管理
+   */
+  type AnimationManager = {
+    /** 初始化方法 */
+    initialize(): void;
+
+    /** 销毁方法 */
+    onDestroy(): void;
+
+    /**
+     * 创建一个tween动画
+     * @param args - tween动画参数
+     * @returns Tween动画对象
+     */
+    createTween(args?: FW.TweenArgs): Tween;
+
+    /**
+     * 创建一个skeleton动画
+     * @param skeleton - spine骨骼对象
+     * @returns 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;
+        easing: Function | String;
+        onUpdate: Function;
+      }>,
+    >(
+      duration: number,
+      props: ConstructorType<T>,
+      opts?: OPTS,
+    ): FW.Tween;
+
+    /**
+     * 在指定时间内将属性按照增量变化
+     * @template OPTS - 选项类型
+     * @param duration - 持续时间（秒）
+     * @param props - 属性增量值
+     * @param opts - 动画选项（如缓动函数、进度回调等）
+     * @returns 当前Tween对象，支持链式调用
+     */
+    by<
+      OPTS extends Partial<{
+        progress: Function;
+        easing: Function | String;
+        onUpdate: Function;
+      }>,
+    >(
+      duration: number,
+      props: ConstructorType<T>,
+      opts?: OPTS,
+    ): FW.Tween;
+
+    /**
+     * 立即设置属性值
+     * @param props - 要设置的属性值
+     * @returns 当前Tween对象，支持链式调用
+     */
+    set(props: ConstructorType<T>): FW.Tween;
+  };
+
+  /**
+   * Spine骨骼动画对象 - 用于控制Spine骨骼动画的播放和设置
+   */
+  type Skeleton = {
+    animation: sp.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 是否存在该动画
+     */
+    hasAnimation(animName: string);
+
+    /**
+     * 获取所有动画
+     * @returns 动画列表
+     */
+    getAnimations();
+
+    /**
+     * 获取所有动画名称
+     * @returns 动画名称数组
+     */
+    getAnimationNames(): string[];
+
+    /**
+     * 设置时间缩放比例
+     * @param timeScale - 时间缩放比例
+     */
+    timeScale(timeScale: number);
+
+    /** 暂停动画 */
+    pause(): void;
+
+    /** 恢复动画 */
+    resume(): void;
+
+    /**
+     * 添加骨骼挂点
+     * @param boneName - 骨骼名称
+     * @param node - 要挂载的节点
+     */
+    addBone(boneName: string, node: cc.Node);
+  };
+
+  /**
+   * spine动画参数
+   */
+  type SkeletonArgs = Partial<{
+    loop: boolean;
+    timeScale: number;
+    progress: number;
+    cb: () => void;
+  }>;
+  /**
+   * tween动画参数
+   */
+  type TweenArgs = Partial<{
+    id: number;
+    tag: string;
+    target: Component | Node;
+    timeScale: number;
+  }>;
+
+  /**
+   * 时间对象
+   */
+
+  type Timer = {
+    /**
+     * 状态改变调用
+     */
+    resolve: Function;
+    /**
+     * 是否暂停
+     * */
+    pause: boolean;
+    /**
+     * id
+     */
+    id: number;
+    /**
+     * 重复次数
+     */
+    repeat: number;
+    /**
+     * 目标对象
+     */
+    target: TargetType;
+
+    /**
+     *  执行时间
+     */
+    executeTime: number;
+  } & Partial<{
+    /**
+     * 执行间隔
+     */
+    internal: number;
+    /**
+     * 标签
+     */
+    tag: string;
+    /**
+     * 回调函数
+     * @returns
+     */
+    cb: () => void;
+  }>;
+
+  type RegisterInitialize = {
+    initialize();
+    destroy();
+  };
+
+  type RegisterBundle = {
+    bundleName: string;
+    sceneName?: string;
+    depend?: string[];
+    autoRelease?: boolean;
+  };
+
+  type RegisterFrameworkBundle = {
+    /**
+     * bundle名字
+     */
+    bundleName: string;
+  };
+
+  type RegisterFrameworkComponent = {
+    /**
+     * 逻辑
+     */
+    logic?: Newable<Logic>;
+    /**
+     * 数据
+     */
+    data?: Newable<Data>;
+    /**
+     * 资源配置
+     */
+    config?: Newable<Config>;
+    /**
+     * socket发送者
+     */
+    sender?: Newable<Sender>;
+    /**
+     * socket处理者
+     */
+    handle?: Newable<SocketHandle>;
+  };
+
+  type RegisterFramework = RegisterFrameworkBundle & RegisterFrameworkComponent;
+
+  /**
+   * 状态机
+   */
+  type State = {
+    /**
+     * 进入状态
+     */
+    onEnter(args: any): void;
+    /**
+     * 退出状态
+     */
+    onExit(): void;
+    /**
+     * 初始化
+     */
+    onInit(): void;
+    /**
+     * 销毁状态
+     */
+    onDestroy(): void;
+    /**
+     * 状态每一帧更新
+     */
+    onUpdate(dt?: number): void;
+  };
+
+  /**
+   * 状态机 - 管理不同状态之间的转换和执行
+   */
+  type StateMachine = {
+    /** 当前状态 */
+    state: number;
+
+    /**
+     * 进入指定状态
+     * @param stateType - 状态类型
+     * @param args - 传递给状态的参数
+     */
+    enter(stateType: number, ...args: any): void;
+
+    /** 暂停状态机 */
+    pause();
+
+    /** 恢复状态机 */
+    resume();
+
+    /**
+     * 注册状态
+     * @template T - 状态基类类型
+     * @param state - 状态机注册参数
+     */
+    register<T extends FWStateBase>(state: FW.StateMachineRegisterArgs<T>);
+
+    /**
+     * 注销状态
+     * @param stateType - 状态类型
+     */
+    unRegister(stateType: number);
+
+    /** 销毁方法 */
+    onDestroy();
+  };
+
+  /**
+   * 状态机注册参数
+   */
+  type StateMachineRegisterArgs<T extends FWStateBase = FWStateBase> = {
+    /**
+     * 状态类型
+     */
+    stateType: number;
+    /**
+     * 状态构造类
+     */
+    stateConstructor: { new (): T };
+  };
+
+  /**
+   * 音频管理器 - 负责游戏中背景音乐和音效的播放控制
+   */
+  type AudioManager = {
+    /**
+     * 播放背景音乐
+     * @param path - 音频资源路径
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为true
+     */
+    playMusic(path: string, volume?: number, loop?: boolean): void;
+
+    /**
+     * 播放背景音乐
+     * @param music - 音频剪辑对象
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为true
+     */
+    playMusic(music: cc.AudioClip, volume?: number, loop?: boolean);
+
+    /**
+     * 播放背景音乐
+     * @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 - 是否静音
+     */
+    setMusicMute(mute: boolean): void;
+
+    /**
+     * 停止指定ID的音频
+     * @param id - 音频ID
+     */
+    stop(id: number): void;
+
+    /**
+     * 播放音效
+     * @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 cb - 回调函数，参数为播放的音频ID
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为false
+     * @returns Promise<number> 音频ID
+     */
+    play(
+      audio: cc.AudioClip,
+      cb?: (id: number) => void,
+      volume?: number,
+      loop?: boolean,
+    ): Promise<number>;
+
+    /**
+     * 播放音效
+     * @param assetProperty - 资源属性
+     * @param cb - 回调函数，参数为播放的音频ID
+     * @param volume - 音量（0-1），默认为1
+     * @param loop - 是否循环播放，默认为false
+     * @returns Promise<number> 音频ID
+     */
+    play(
+      assetProperty: AssetProperty,
+      cb?: (id: number) => void,
+      volume?: number,
+      loop?: boolean,
+    ): Promise<number>;
+
+    /** 暂停所有音频 */
+    pauseAll(): void;
+
+    /** 恢复所有音频 */
+    resumeAll(): void;
+
+    /** 停止所有音频 */
+    stopAll(): void;
+
+    /**
+     * 设置音效是否静音
+     * @param mute - 是否静音
+     */
+    setSoundMute(mute: boolean): void;
+  };
+
+  type PerformanceManager = {
+    recordOperationMetric(manager: string, operation: string, duration: number): void;
+    getModuleReport(manager: string): PerformanceReport;
+    getAllReports(): Map<string, FW.PerformanceReport>;
+  };
+
+  type ObjectProperty<T extends Object = Object> = {
+    /** 对象节点 */
+    node?: cc.Node;
+    /** 唯一id */
+    uniqueId: number;
+    /** 节点组件继承自FW.Object */
+    component?: T;
+    /** 是否启用 */
+    enable?: boolean;
+  };
+
+  type LoadConfig = {
+    prefab?: {};
+    texture?: {};
+    animation?: {};
+    font?: {};
+    audio?: {};
+    config?: {};
+  };
+
+  type OpacityAnimationArgs = {
+    target: cc.Node;
+    duration: number;
+  } & Partial<{
+    initOpacity: number;
+    targetOpacity: number;
+    cb: () => void;
+  }>;
+
+  type ScaleAnimationArgs = {
+    target: cc.Node;
+    duration: number;
+  } & Partial<{
+    initScale: number;
+    targetScale: number;
+    easing: cc.Easing;
+    cb: () => void;
+  }>;
+
+  type PositionAnimationArgs = {
+    target: cc.Node;
+    duration: number;
+  } & Partial<{
+    initPosition: Vec3;
+    targetPosition: Vec3;
+    cb: () => void;
+  }>;
+
+  type Vec3 = {
+    x?: number;
+    y?: number;
+    z?: number;
+  };
+
+  type Vec2 = {
+    x?: number;
+    y?: number;
+  };
+
+
+  type VirtualScrollViewListener = 
+  {
+    onRender(element:ObjectProperty,index: number,...args:any);
+    onTouchElement(element:ObjectProperty,index: number,...args:any);
+  }
+
+  type VirtualScrollViewConfig = {
+    /**
+     * 列表个数
+     */
+    count: number;
+    rollingDirection: cc.Enum<FW.SystemDefine.FWVirtualScrollViewDirection>;
+    /**
+     * 预制体
+     */
+    prefab: cc.Prefab;
+    /**
+     * 列表容器
+     */
+    container:cc.Node;
+  }
+
+
+  type VirtualViewListener = (item: cc.Node, id: number, ...data: any) => void;
+  type VirtualViewComponentArgs = {
+    /**
+     * 列表个数
+     */
+    count: number;
+    /**
+     * 渲染事件
+     */
+    onRender?: VirtualViewListener;
+    /**
+     * 页面更改事件
+     */
+    onPageChange?: VirtualViewListener;
+    /**
+     * 选择事件
+     */
+    onSelected?: VirtualViewListener;
+    /**
+     * 注册目标
+     */
+    target: any;
+    /**
+     * 虚拟列表组件
+     */
+    virtualView: VirtualViewComponent;
+    /**
+     * 预制体
+     */
+    templatePrefab?: cc.Prefab;
+    /**
+     * 节点
+     */
+    templateNode?: cc.Node;
+  };
+
+  type VirtualViewComponent = {
+    /**
+     * 列表个数
+     */
+    count: number;
+    /**
+     * 渲染事件
+     */
+    onRender?: VirtualViewListener;
+    /**
+     * 页面更改事件
+     */
+    onPageChange?: VirtualViewListener;
+    /**
+     * 选择事件
+     */
+    onSelected?: VirtualViewListener;
+    /**
+     * 预制体
+     */
+    templatePrefab?: cc.Prefab;
+    /**
+     * 节点
+     */
+    templateNode?: cc.Node;
+  };
+
+  interface ILanguageBundleAccessor {
+    [bundleName: string]: any;
+    getString: <T extends string>(key: string) => T;
+  }
+
+  type TaskOptions = Partial<{
+    taskId: number;
+    /**
+     * 每帧最大执行时间(ms)，默认16ms (60fps) 帧预算
+     */
+    frameBudget: number;
+    /**
+     * 每帧最多执行的任务个数
+     */
+    tasksFrameCount: number;
+    /**
+     * 是否打印日志
+     */
+    log: boolean;
+  }> & {
+    taskId: number;
+  };
+
+  type TaskEvent = {
+    taskId?: string;
+    type: string;
+    progress?: number;
+    message?: string;
+  };
+  /**
+   * 生产器
+   */
+  type TaskGenerator = AsyncGenerator<TaskEvent, void, unknown>;
+  /**
+   * 任务函数
+   */
+  type TaskFunction = () => TaskGenerator;
+
+  type TaskPerformanceReport = {
+    startTime: string;
+    endTime: string;
+    totalTasks: number;
+    avgFrameTime: number;
+    longestFrame: number;
+    shortestFrame: number;
+    totalFrames: number;
+    frameJitter: number;
+    budgetUsage: number;
+    totalDuration: number;
+    frameDetails: FrameDetail[];
+    timeline: Array<{
+      type: string;
+      progress?: number;
+      message?: string;
+    }>;
+  };
+
+  /**
+   * 任务对象 - 代表一个可控制的异步任务
+   */
+  type Task = {
+    /** 任务ID */
+    readonly id: number;
+
+    /**
+     * 获取当前任务状态
+     * @returns 任务状态
+     */
+    getStatus(): FW.SystemDefine.FWTaskStatus;
+
+    /**
+     * 启动任务
+     * @param generator - 任务生成器函数
+     * @returns 当前Task对象，支持链式调用
+     */
+    start(generator: TaskFunction): Task;
+
+    /**
+     * 添加任务
+     * @param generator - 任务生成器函数
+     * @returns 当前Task对象，支持链式调用
+     */
+    add(generator: TaskFunction): Task;
+
+    /** 暂停任务 */
+    pause(): void;
+
+    /** 恢复任务 */
+    resume(): void;
+
+    /** 重置任务 */
+    reset(): void;
+
+    /** 停止任务 */
+    stop(): void;
+
+    /**
+     * 获取任务性能报告
+     * @returns 任务性能报告
+     */
+    getPerformanceReport(): TaskPerformanceReport;
+  };
+
+  type FrameDetail = {
+    /**
+     * 帧开始时间
+     */
+    frameStart: string;
+    /**
+     * 帧结束时间
+     */
+    frameEnd: string;
+    /**
+     * 总耗时
+     */
+    frameTime: number;
+    /**
+     * 本帧处理的任务数
+     */
+    tasksProcessed: number;
+    /**
+     * 本帧处理的任务详情
+     */
+    tasks: TaskExecutionRecord[];
+    /**
+     * 帧预算时间
+     */
+    frameBudget: number;
+    /**
+     * 预算使用率
+     */
+    frameBudgetUsed: number;
+  };
+
+  type TaskExecutionRecord = {
+    /**
+     * 任务唯一标识
+     */
+    taskId: string;
+    /**
+     * 任务结果
+     */
+    result: string;
+    /**
+     * 消息
+     */
+    message?: string;
+  };
+
+  // 颜色分段配置接口
+  type AssemblerLabelColorSegment = {
+    color: cc.Color;
+    position: number;
+  };
+
+  type AssemblerLabelColorConfig = {
+    color: cc.Color;
+    percentages: number;
+  };
+
+  type PromiseProxy<T = Promise> = {
+    id: number;
+    status: any;
+    promise?: Promise<T>;
+    abort?: (reason?: any) => void;
+    addAbortEventListener?: (
+      listener: (this: AbortSignal, ev: Event) => any,
+      options?: boolean | AddEventListenerOptions,
+    ) => void;
+  };
+
+  type PromiseExcutor<T> = (
+    resolve: (value: T | PromiseLike<T>) => void,
+    reject: (reason?: any) => void,
+    signal: AbortSignal,
+    reason?: any,
+  ) => void;
+
+  type PromiseExecuteOptions = Partial<{
+    reason: any;
+    timeout: number;
+    retryCount: number;
+    retryInterval: number;
+    retryCondition: (error: any, retryCount: number) => boolean;
+  }>;
+
+  type PromiseAllResult<T = any> = {
+    success: Array<{ id: number; value: T }>;
+    failed: Array<{ id: number; reason: any }>;
+    cancelled: number[];
+  };
+
+  type PromiseStatus = 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
+
+  /**
+   * 性能管理器配置
+   */
+  type PerformanceModuleOptions = Partial<{
+    /** 是否自动收集性能数据 */
+    autoCollect: boolean;
+    /** 性能数据保留时间（毫秒） */
+    dataRetentionTime: number;
+    /** 采样率（0-1） */
+    samplingRate: number;
+    /** 性能警告阈值（毫秒） */
+    warningThreshold: number;
+  }>;
+
+  /**
+   * 性能统计报告
+   */
+  type PerformanceReport = {
+    module: string;
+    totalOperations: number;
+    averageDuration: number;
+    minDuration: number;
+    maxDuration: number;
+    recentMetrics: FWPerformanceMetric[];
+  };
+
+  /**
+   * 性能指标数据
+   */
+  type PerformanceMetric = {
+    module: string;
+    operation: string;
+    duration: number;
+    timestamp: number;
+  };
+
+  type ManagerOptions = Partial<{
+    /** 是否启用调试日志 */
+    debug: boolean;
+    /** 管理器名称（默认使用类名） */
+    name: string;
+  }>;
+
+  type PropertyDecorator = (
+    $class: Record<string, any>,
+    $propertyKey: string | symbol,
+    $descriptorOrInitializer?: any,
+  ) => void;
+
+  type Utils = {
+    getFileName(url: string): string;
+  }
+
+  declare function timeScale(scale: number);
+  declare let Entry: Entry;
+}
+
+declare namespace FW {
+  export type Log = {
+    get debug();
+    get send();
+    get receive();
+    get request();
+    get response();
+    get system();
+    get warn();
+    get error();
+  };
+  declare let Log: Log;
+}
+
+declare namespace FW {
+  export type Framework = {
+    initialize(): void;
+    addRegistry(bundleName: string, registry: new () => Registry): void;
+    getContainer(): any;
+    getComponent<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+    getComponents<T>(serviceIdentifier: ServiceIdentifier<T>): T[];
+    hasRegistry(bundleName: string): boolean;
+    getRegistry(bundleName: string): Registry;
+    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;
+}
+
+declare namespace FW {
+  export abstract class FrameworkBase {
+    public readonly entry: FW.Entry = FW.Entry;
+
+    /**
+     * 调用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;
+      static CONFIG = 2;
+      static SENDER = 3;
+      static HANDLE = 4;
+      static SUB_LOGIC = 5;
+    }
+
+    export class FWVirtualScrollViewDirection{
+      static VERTICAL = 0;
+      static HORIZONTAL = 1;
+    }
+
+    /**
+     * 对象类型
+     */
+    export class FWObjectType {
+      static ACTIVE = 0;
+      static OPACITY = 1;
+    }
+
+    /** Layer渲染顺序 */
+    export class FWLayerRenderOrder {
+      static SCENE = 0;
+      static PERMANENT = 10;
+      static UI = 100;
+      static POPUP = 1000;
+      static MAX = 10000;
+    }
+
+    /**
+     * layer类型
+     */
+    export class FWLayerType {
+      /**
+       * 常驻
+       */
+      static PERMANENT = 0;
+      /**
+       * 可重复打开
+       */
+      static REPEAT = 1;
+      /**
+       * 弹出式(需要加入队列)
+       */
+      static POPUP_QUEUE = 2;
+      /**
+       * 弹出式(一次性,无需加入队列)
+       */
+      static POPUP_DISPOSABLE = 3;
+    }
+
+    /**
+     * 任务状态
+     */
+    export class FWTaskStatus {
+      /**
+       * 待处理
+       */
+      static IDLE = 'IDLE';
+      /**
+       * 运行中
+       */
+      static RUNNING = 'RUNNING';
+      /**
+       * 暂停中
+       */
+      static PAUSED = 'PAUSED';
+      /**
+       * 完成
+       */
+      static COMPLETED = 'COMPLETED';
+    }
+
+    export class FWPriorityOrder {
+      /**
+       * 优先级高
+       */
+      static HIGHT = 0;
+      /**
+       * 优先级普通
+       */
+      static NORMAL = 1;
+      /**
+       * 优先级低
+       */
+      static LOW = 2;
+    }
+
+    /**
+     * 日志类型
+     */
+    export class FWLogType {
+      /** 调试信息 */
+      static DEBUG = 0;
+      /** socket请求 */
+      static SOCKET_SEND = 1;
+      /** socket接收 */
+      static SOCKET_RECEIVE = 2;
+      /** 请求信息 */
+      static REQUEST = 3;
+      /** 响应信息 */
+      static RESPONSE = 4;
+      /** 警告信息 */
+      static WARN = 5;
+      /** 错误信息 */
+      static ERROR = 6;
+      /** 系统信息 */
+      static SYSTEM = 7;
+    }
+
+    /**
+     * HTTP请求类型
+     */
+    export class FWHttpRequestType {
+      static GET = 'GET';
+      static POST = 'POST';
+    }
+
+    /**
+     * 动画机类型
+     */
+    export class FWAnimationMachineType {
+      static TWEEN = 'TWEEN';
+      static SKELETON = 'SKELETON';
+      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';
+      static REJECTED = 'rejected';
+      static CANCELLED = 'cancelled';
+    }
+
+    /**
+     * 层状态
+     */
+    export class FWLayerState {
+      static LOADING = 'loading';
+      static LOADED = 'loaded';
+      static CLOSED = 'closed';
+      static OPENING = 'opening';
+      static OPENED = 'opened';
+      static CLOSING = 'closing';
+    }
+
+    /**
+     * 音频类型
+     */
+    export class FWAudioType {
+      static MUSIC = 0;
+      static SOUND = 1;
+    }
+  }
+  namespace EventDefine {
+    export class LanguageEvent {
+      /** 语言变更 */
+      static LANGUAGE_CHANGE = 'LANGUAGE_CHANGE';
+    }
+
+    export class TaskEvent {
+      static START = 'START';
+      static PROGRESS = 'PROGRESS';
+      static COMPLETE = 'COMPLETE';
+      static YIELDED = 'YIELDED';
+      static PAUSE = 'PAUSE';
+      static RESUME = 'RESUME';
+      static FRAME_START = 'FRAME_START';
+      static FRAME_END = 'FRAME_END';
+      static QUEUE = 'QUEUE';
+      static ALL_COMPLETE = 'ALL_COMPLETE';
+      static ERROR = 'ERROR';
+    }
+
+    export class SystemEvent {
+      static SYSTEM_RESTART = 'SYSTEM_RESTART';
+      static SYSTEM_EVENT_TIRGGER = 'SYSTEM_EVENT_TIRGGER';
+    }
+
+    export class CCEvent {
+      static ON_SHOW = 'ON_SHOW';
+      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;
+    public onLoad(): void;
+    public start(): void;
+    public onEnable(): void;
+    public onDisable(): void;
+    public onDestroy(): void;
+    public update(dt: number): void;
+    public lateUpdate(dt: number): void;
+  }
+
+  /**
+   * layer控制器基类
+   */
+  export class LayerController extends FrameworkBase {
+    readonly entry: FW.Entry;
+    logic?: Logic;
+    config?: Config;
+    data?: Data;
+    sender?: Sender;
+    handle?: SocketHandle;
+    layerData: LayerData;
+    /** uuid */
+    uuid: string;
+    /** 渲染顺序 */
+    renderOrder: number;
+    /** 当前layer */
+    layer: FWLayer;
+    /** layer类型 */
+    layerType: FW.SystemDefine.FWLayerType;
+    /** 资源地址 */
+    get layerAssetProperty(): FW.AssetProperty;
+    /** 关闭后是否自动释放资源 */
+    get autoRelease(): boolean;
+    /** 是否允许重复打开 */
+    get isRepeatOpen(): boolean;
+    initialize?();
+    destroy?();
+    /** 生命周期函数 */
+    onInit?(...args: any);
+    onLoad?();
+    onStart?();
+    onUpdate?(dt?: number);
+    onLateUpdate?(dt?: number);
+    onEnable?();
+    onDisable?();
+    onDestroy?();
+    onClose?();
+
+    /**
+     * 查找节点
+     * @param path
+     * @param referenceNode
+     * @returns
+     */
+    find(path: string, referenceNode: cc.Node): cc.Node;
+    /**
+     * 查找组件
+     * @param path
+     * @param referenceNode
+     * @param type
+     * @returns
+     */
+    findComponent<T extends cc.Component = cc.Component>(
+      path: string,
+      referenceNode: cc.Node,
+      type?: {
+        prototype: T;
+      },
+    ): T;
+    /**
+     * 注册事件
+     * @param args
+     */
+    registerEvent(args: RegisterArgs): void;
+    /** 注销事件 */
+    unRegisterEvent(args: RegisterArgs);
+    /** 注销所有事件 */
+    unRegisterAll(): void;
+    /** 注销指定对象所有事件 */
+    unRegisterTarget(target: TargetType);
+    /** 暂停事件 */
+    pauseEvent();
+    /** 恢复事件 */
+    resumeEvent();
+    /** 关闭layer */
+    close();
+    /**
+     * 添加外部引用
+     * @param cb
+     */
+    addExternalReference?(cb?: (ctr: any) => void);
+
+    cc(
+      target: cc.Node,
+      cb: (event: cc.Event) => void,
+      responseInterval?: number,
+      eventName?: string,
+    ): LayerController;
+
+    fw(
+      eventName: string,
+      cb: (event: cc.Event) => void,
+      target?: cc.Node,
+      responseInterval?: number,
+    ): LayerController;
+  }
+}
+
+declare namespace FW {
+  /**
+   * 注册类
+   */
+  export abstract class Registry {
+    /**
+     * bundle名字
+     */
+    abstract readonly bundleName: string;
+    /**
+     * 逻辑
+     */
+    readonly logic?: Newable<Logic>;
+    /**
+     * 数据
+     */
+    readonly data?: Newable<Data>;
+    /**
+     * 资源配置
+     */
+    readonly config?: Newable<Config>;
+    /**
+     * socket发送者
+     */
+    readonly sender?: Newable<Sender>;
+    /**
+     * socket处理者
+     */
+    readonly handle?: Newable<SocketHandle>;
+
+    /**
+     * 注册
+     */
+    register(): void;
+    /**
+     * 卸载
+     */
+    unRegister(): void;
+  }
+}
+
+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?();
+    sendHeart();
+    onHeart?(msg: any): Promise<boolean>;
+    onBeforeSendingMessage?(msg: any): Promise<FW.SocketMessage>;
+    getProtocolKey?(msg: any): string;
+    send(msg: any);
+  }
+  /**
+   * socket处理者
+   */
+  export abstract class Handle extends FrameworkBase {
+    initialize?();
+    onDestroy?();
+    onWeakNetWork?(): 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;
+  }
+  /**
+   * 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 {
+    public static start(): void;
+    public static stop(): void;
+    public static updateMockResponses(mockResponses: {});
+  }
+}
+
+declare namespace FW {
+  export abstract class Object extends cc.Component {
+    /** 是否已经初始化 */
+    initialize: boolean;
+    /** 对象唯一id */
+    uniqueId: number;
+    /** 对象是否启用 */
+    enable: boolean;
+    onGet(...args: any);
+    onPut();
+    onInit();
+    onDestroy();
+  }
+}