@ives_xxz/framework 1.0.0

package/FW.d.ts

@@ -0,0 +1,1845 @@
+declare namespace FW {
+  type Newable<TInstance = unknown, TArgs extends unknown[] = any[]> = new (
+    ...args: TArgs
+  ) => TInstance;
+  type Abstract<T> = {
+    prototype: T;
+  };
+
+  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;
+    socketMgr: SocketManager;
+    objectMgr: ObjectManager;
+    uiMgr: UiManager;
+    componentMgr: ComponentManager;
+    languageMgr: LanguageManager;
+    evtMgr: EventManager;
+    engineMgr: EngineManager;
+    taskMgr: TaskManager;
+    hotUpdateMgr: HotUpdateManager;
+    scene: Scene;
+    bundleName: string;
+    getComponent<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T;
+    getComponents<T>(serviceIdentifier?: FW.ServiceIdentifier<T>): T[];
+    launchScene(bundleName: string): void;
+    register(data: RegisterBundle): void;
+    getSceneName(bundleName: string): string;
+    getDepend(bundleName: string): string[];
+    update(dt: number): void;
+    initialize(): void;
+    onDestroy(): void;
+  };
+
+  type LanguageManager = {
+    registerLanguagePackageEnum(
+      bundleName: string,
+      language: any,
+      getter: (key: string, language?: string) => string,
+    ): void;
+    getSupportedLanguages(): string[];
+    setSupportedLanguages(languages: string[]): void;
+    getBundles(): string[];
+    getLanguage(): string;
+    getLanguageIndex(): number;
+    getLanguagePackageValue(bundleName: string, key: string, language?: string): string;
+    getLanguagePackageEnumKeys(bundleName: string): string[];
+    getLanguagePackageEnumValues(bundleName: string): string[];
+    getLanguagePackageEnum<K extends keyof ILanguageBundleAccessor>(
+      bundleName: K,
+    ): ILanguageBundleAccessor[K];
+    initializeLanguage(language: string);
+  };
+
+  type Language = {
+    onRefresh(): void;
+  };
+
+  type ComponentManager = {
+    bindVirtualViewComponent(args: FW.VirtualViewComponentArgs);
+  };
+
+  type Scene = {
+    node: cc.Node;
+  };
+
+  type Sender = {
+    readonly entry: FW.Entry;
+    initialize?();
+    onDestroy?();
+    send(msg: any);
+  };
+  type Handle = {
+    readonly entry: FW.Entry;
+    initialize?();
+    onDestroy?();
+    /** 消息处理 */
+    onMessage(msg: any);
+    /** 超时处理 */
+    onTimeout();
+    /** 错误处理 */
+    onError(msg: any);
+    /** 连接打开 */
+    onOpen();
+    /** 连接关闭 */
+    onClose();
+    /** 心跳 */
+    onHeart?(msg: any): Promise<boolean>;
+    /** 弱网 */
+    onWeakNetWork?(): void;
+  };
+
+  type ObjectManager = {
+    /** 创建一个对象池 */
+    createObjectPool<T extends FWObject = FWObject>(
+      node: cc.Node,
+      parent: cc.Node,
+      tag?: string,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FWObject = FWObject>(
+      prefab: cc.Prefab,
+      parent: cc.Node,
+      tag?: string,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FWObject = FWObject>(
+      assetProperty: FW.AssetProperty,
+      parent: cc.Node,
+      tag?: string,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FWObject = FWObject>(
+      node: cc.Node,
+      parent: cc.Node,
+      type?: number,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FWObject = FWObject>(
+      prefab: cc.Prefab,
+      parent: cc.Node,
+      type?: number,
+    ): Promise<ObjectPool<T>>;
+    createObjectPool<T extends FWObject = FWObject>(
+      assetProperty: FW.AssetProperty,
+      parent: cc.Node,
+      type?: number,
+    ): Promise<ObjectPool<T>>;
+    /** 获取已经创建的对象池 */
+    getObjectPool(tag: string): ObjectPool;
+
+    /** 销毁一个对象池 */
+    destroyObjectPool(tag: string): void;
+  };
+
+  type ObjectPool = {
+    getEnableObjectMap();
+    getDisableObjectMap();
+    getAllObjectMap();
+    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();
+  };
+  type SocketManager = {
+    createSocket(
+      tag: string,
+      address: string,
+      sender: SocketSender,
+      handle: SocketHandle,
+      config: {
+        heartTimeout?: number;
+        heartWeakTime?: number;
+        heartInternal?: number;
+        maxReconnectTimes?: number;
+        reconnectInternal?: number;
+      },
+    ): Promise<Socket>;
+    /**
+     * 获取socket
+     * @param type
+     * @returns
+     */
+    getSocket(tag?: string): Socket;
+
+    getSocketMap(): Map<string, Socket>;
+    /** 暂停消息处理 */
+    pauseMessageHandle(): void;
+
+    /** 恢复消息处理 */
+    resumeMessageHandle(): void;
+    /**
+     * 关闭
+     * @param fs
+     * @returns
+     */
+    closeSocket(fs: Socket): void;
+  };
+
+  type ScrollViewComponent = {
+    /**
+     * 模板类型,1:cc.Node,2.cc.prefab
+     */
+    templateType: number;
+    /**
+     * 滑动类型 1.无 2.粘性模式,强制关闭不自动滑动,3.页面模式,强制关闭不自动滑动
+     */
+    slideType: number;
+    /**
+     * 是否是虚拟列表
+     */
+    virtual: boolean;
+  };
+
+  type SocketPromiseProxy = {
+    promise: Function;
+    socket: FW.Socket;
+  };
+
+  type Socket = {
+    public onDestroy(): void;
+    /**
+     * 获取tag
+     * */
+    public getTag(): string;
+    /**
+     * 获取地址
+     * @returns
+     */
+    getAddress(): string;
+
+    /**
+     * 获取socket状态
+     * @returns
+     */
+    getReadyState(): number;
+
+    /**
+     * 关闭连接
+     */
+    close();
+    /**
+     * 暂停消息处理
+     */
+    pauseMessageHandle();
+    /**
+     * 恢复消息处理
+     */
+    resumeMessageHandle();
+
+    send(msg);
+
+    createSocket(
+      address: string,
+      tag: string,
+      sender: FWSocketSender,
+      handle: FWSocketHandle,
+      config: {
+        heartInternal: number;
+        heartTimeout: number;
+        heartWeakTime: number;
+        maxReconnectTimes: number;
+      },
+    ): SocketPromiseProxy;
+  };
+
+  /**
+   * 观察者
+   */
+  type Observer = {
+    priority: number;
+    intercept: 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 UiManager = {
+    registerButtonEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]);
+    pauseEvent<T extends TargetType>(target: T);
+    resumeEvent<T extends TargetType>(target: T);
+    hasRegister(eventName: string, target: FW.TargetType): boolean;
+    unRegisterEvent(args: FW.RegisterEventArgs);
+    unRegisterTarget(target: TargetType);
+    unRegisterAll();
+    buttonEnable(target: TargetType);
+    buttonDisable(target: TargetType);
+  };
+
+  type TimeManager = {
+    initialize(): void;
+    onDestroy(): void;
+
+    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;
+    /**
+     * 自定义调度器
+     * */
+    schedule(
+      cb?: () => void,
+      time?: number,
+      repeat?: number,
+      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
+     */
+    resumeSchedule(tag: string): void;
+    resumeSchedule(target: TargetType): void;
+    resumeSchedule(id: number): void;
+    /**
+     * 每一帧更新
+     * @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;
+    onUpdate(dt: number): void;
+  };
+
+  type EventManager = {
+    initialize(): void;
+    onDestroy(): void;
+    /**
+     * 注册事件
+     * @param eventName
+     * @param cb
+     * @param target
+     */
+    register(
+      eventName: string | number,
+      cb: (any) => void,
+      target: TargetType,
+      options?: {
+        priority?: FWSystemDefine.FWPriorityOrder;
+        intercept?: boolean;
+      },
+    );
+    /**
+     * 派发事件
+     * @param eventName
+     * @param args1
+     * @param args2
+     * @param args3
+     * @param args4
+     * @param args5
+     * @param args6
+     * @param args7
+     * @param args8
+     * @param args9
+     * @param args10
+     */
+    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
+     */
+    unRegister(eventName: string | number, target: TargetType): void;
+
+    /**
+     * 注销所有事件
+     * @param eventName
+     */
+    eventOff(eventName: string | number): void;
+
+    /**
+     * 注销目标所有事件
+     * @param target
+     */
+    targetOff(target: TargetType): void;
+
+    /**
+     * 目标对象是否注册了指定事件
+     * @param eventName
+     * @param target
+     */
+    has(eventName: string | number, target: Comment | Object): boolean;
+
+    /**
+     * 暂停目标身上注册事件
+     * @param target
+     */
+    targetPause(target: TargetType): void;
+    /**
+     * 恢复目标身上注册事件
+     * @param target
+     */
+    targetResume(target: TargetType);
+  };
+
+  /**
+   * 事件管理参数
+   */
+  type EventManagerArgs = string | number | object | [];
+
+  /**
+   * 层级打开参数
+   */
+  type LayerOpenArgs<T> = {
+    /**
+     * 控制器类型
+     */
+    type: new () => T;
+    /**
+     * 父节点
+     */
+    parent?: cc.Node;
+    /**
+     * 坐标
+     */
+    position?: cc.Vec3;
+    /**
+     * 传递参数
+     */
+    args?: any;
+  };
+
+  /**
+   * 层级数据
+   */
+  type LayerData<T> = {
+    /**
+     * 外部引用
+     */
+    externalReference?: Set<(ref: LayerController | null) => void> = new Set();
+    /**
+     * 构造类
+     */
+    layerConstructor: new () => T;
+    /**
+     * 唯一id
+     */
+    uuid: string;
+    /**
+     * layer名字
+     */
+    layerName: string;
+    /**
+     * layer
+     */
+    layer: FWLayer;
+    /**
+     * layer资源属性
+     */
+    layerAssetProperty: AssetProperty;
+    /**
+     * layer类型
+     */
+    layerType: FWSystemDefine.FWLayerType;
+    /**
+     * layer渲染顺序
+     */
+    layerRenderOrder: FWSystemDefine.FWLayerRenderOrder;
+    /**
+     * layer控制器名字
+     */
+    controllerName: string;
+    /**
+     * layer控制器
+     */
+    controller: FWLayerController;
+    /**
+     * 是否加载完成
+     */
+    loaded: boolean;
+    /**
+     * layer父节点
+     */
+    layerParent?: cc.Node;
+    /**
+     * 坐标
+     */
+    layerPosition?: Vec3;
+  };
+
+  /**
+   * 层级管理器
+   */
+  type LayerManager = {
+    initialize(): void;
+    onDestroy(): void;
+    clear(): void;
+
+    /**
+     * 异步打开layer
+     * @param data
+     */
+    openAsync<Ctr extends FWLayerController = FWLayerController>(
+      data: LayerOpenArgs<Ctr>,
+    ): Promise<Ctr>;
+
+    /**
+     * 同步打开layer
+     * @param data
+     */
+    openSync<Ctr extends FWLayerController = FWLayerController>(data: LayerOpenArgs<Ctr>): Ctr;
+    /**
+     * 显示常驻layer
+     * @param layer
+     */
+    displayLayer<Ctr extends FWLayerController = FWLayerController>(ctr: Ctr): Ctr;
+    /**
+     * 隐藏常驻layer
+     * @param layer
+     */
+    hideLayer<Ctr extends FWLayerController = FWLayerController>(ctr: Ctr): Ctr;
+    /**
+     * 关闭layer
+     * @param layer
+     */
+    close<Ctr extends FWLayerController = FWLayerController>(ctr: Ctr): FWLayerController;
+
+    /**
+     * 从栈关闭
+     */
+    closeFromStack(count?: number): void;
+    /**
+     * 通过名字关闭
+     * @param name
+     */
+    closeFromLayerName(name: string | string[]);
+
+    getLayerMap(): Map<string, 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;
+    /**
+     * 资源引用计数
+     */
+    refCount: number;
+  };
+
+  type ResManager = {
+    assetMgr: AssetManager;
+    bundleMgr: BundleManager;
+    initialize(): void;
+    onDestroy(): void;
+
+    /**
+     * 加载包
+     * @param bundleName
+     */
+    loadBundle(bundleName: string): Promise<cc.AssetManager.Bundle>;
+    /**
+     * 获取包
+     * @param bundleName
+     */
+    getBundle(bundleName: string): cc.AssetManager.Bundle;
+    /**
+     * 获取所有bundle
+     */
+    getBundleMap(): Map<string, cc.AssetManager.Bundle>;
+    /**
+     * 释放包
+     * @param bundleName
+     */
+    releaseBundle(bundleName: string): void;
+    /**
+     * 包是否存在
+     * @param bundleName
+     */
+    hasBundle(bundleName: string): boolean;
+    /**
+     * 加载远程资源
+     * @param url
+     * @param cb
+     */
+    loadRemote<T extends cc.Asset = cc.Asset>(url: string, cb?: (asset: cc.Asset) => T): Promise<T>;
+    /**
+     * 从远程加载spine动画
+     * @param data
+     */
+    loadSpineDataFromRemote(data: {
+      img: string;
+      ske: string;
+      atlas: string;
+      bin?: boolean;
+    }): Promise<sp.SkeletonData>;
+
+    /**
+     * 加载资源返回数据
+     * @param assetProperty
+     */
+    loadAssetData<T extends cc.Asset>(assetProperty: AssetProperty): Promise<AssetData>;
+
+    /**
+     * 加载资源
+     * @param assetProperty
+     */
+    loadAsset<T extends cc.Asset>(assetProperty: AssetProperty, cb?: () => void): Promise<T>;
+
+    /**
+     * 获取资源
+     * @param assetProperty
+     */
+    getAssetData<T extends cc.Asset>(assetProperty: AssetProperty): AssetData;
+
+    /**
+     * 获取资源
+     * @param assetProperty
+     */
+    getAsset<T extends cc.Asset = cc.Asset>(assetProperty: AssetProperty): T;
+    /**
+     * 释放资源
+     * @param assetProperty
+     */
+    releaseAsset(assetProperty: AssetProperty): void;
+
+    /**
+     * 资源是否存在
+     * @param assetProperty
+     */
+    hasAsset(assetProperty: AssetProperty): boolean;
+  };
+
+  type RemoteBundleConfig = {
+    bundleName: string;
+    url: string;
+    hash: 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): void;
+    update(localManifest: cc.Asset): void;
+  };
+
+  type HotUpdateListener = {
+    versionCompareHandle: (currentVersion: string, newVersion: string) => void;
+    checkHotUpdateHandle: (code: string) => void;
+    hotUpdatingHandle: (code: string, param: HotUpdatingParam) => void;
+    completedHandle: () => void;
+    retryHandle: () => void;
+  };
+
+  type HotUpdatingParam = {
+    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, cb?: (asset: cc.Asset) => T): Promise<T>;
+    /**
+     * 从远程加载spine动画
+     * @param data
+     */
+    loadSpineDataFromRemote(data: {
+      img: string;
+      ske: string;
+      atlas: string;
+      bin?: boolean;
+    }): Promise<sp.SkeletonData>;
+
+    /**
+     * 加载资源
+     * @param asset
+     */
+    load(assetProperty: AssetProperty): Promise<AssetData>;
+
+    loadDir(assetProperty: FW.AssetProperty): Promise<FW.AssetData[]>;
+
+    /**
+     * 获取资源
+     * @param asset
+     */
+    get(assetProperty: FW.AssetProperty): AssetData;
+
+    /**
+     * 释放资源
+     */
+    release(assetProperty: AssetProperty): void;
+
+    /**
+     * 获取资源引用计数
+     * @param assetProperty
+     */
+    getReferenceCount(assetProperty: AssetProperty): number;
+
+    /**
+     * 是否已经加载
+     * @param uuid
+     */
+    has(assetProperty: AssetProperty): boolean;
+  };
+
+  type EngineManager = {
+    debug: boolean;
+    getMemory(): void;
+  };
+
+  type Layer = {
+    readonly entry: FW.Entry;
+    onLoad(): void;
+    start(): void;
+    onEnable(): void;
+    onDisable(): void;
+    onDestroy(): void;
+    update(dt: number): void;
+    lateUpdate(dt: number): void;
+  };
+  type LayerController = {
+    readonly entry: FW.Entry;
+
+    layerData: FWLayerData;
+    /** uuid */
+    uuid: string;
+    /** 渲染顺序 */
+    renderOrder: number;
+    /** 当前layer */
+    layer: FWLayer;
+    /** layer类型 */
+    layerType: FWSystemDefine.FWLayerType;
+    /** 资源地址 */
+    layerAssetProperty: FW.AssetProperty;
+    /** 关闭后是否自动释放资源 */
+    autoRelease: boolean;
+    /** 是否允许重复打开 */
+    isRepeatOpen: boolean;
+
+    /** 生命周期函数 */
+    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;
+    /** 指定注册CC事件 */
+    registerCCEvent(eventName: string, event: FW.CCEvent | FW.CCEvent[]): void;
+
+    /** 指定注册框架自定义事件 */
+    registerFWEvent(eventName: string, event: FW.FWEvent | FW.FWEvent[]): void;
+
+    registerEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]): void;
+
+    unRegisterEvent(args: FW.RegisterEventArgs);
+    unRegisterAll(): void;
+    unRegisterTarget(target: TargetType);
+    /** 暂停事件 */
+    pauseEvent();
+    /** 恢复事件 */
+    resumeEvent();
+    /** 关闭layer */
+    close();
+  };
+  type Logic = {
+    readonly entry: FW.Entry;
+    initialize?(): void;
+    onDestroy?(): void;
+  };
+  type Data = {
+    readonly entry: FW.Entry;
+    initialize?(): void;
+    onDestroy?(): void;
+  };
+
+  type CCEvent = {
+    cb: (...args: any) => void;
+    target: TargetType;
+    pause?: boolean;
+  };
+
+  type FWEvent = {
+    cb: (...args: any) => void;
+    target: any;
+    pause?: boolean;
+  };
+
+  type RegisterEventArgs = {
+    /** 事件名字 */
+    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
+     *
+     * frameBudget?: number; 每帧最大执行时间
+     * tasksFrameCount?: number; 每帧最多执行的任务个数
+     */
+
+    createTask(options: FW.TaskOptions): FW.Task;
+    /**
+     * 获取任务
+     * @param taskId
+     */
+    getTask(taskId: number): FW.Task | undefined;
+    /**
+     * 移除任务
+     * @param taskId
+     */
+    removeTask(taskId: number): void;
+    /**
+     * 获取所有任务
+     */
+    getAllTasks(): FW.Task[];
+  };
+
+  type StateManager = {
+    initialize(): void;
+    onDestroy(): void;
+    /**
+     * 创建一个状态机
+     * @param stateMachineName
+     */
+    createStateMachine(stateMachineName?: string): StateMachine;
+    /**
+     * 移除一个状态机
+     * @param stateMachineName
+     * @returns
+     */
+    removeStateMachine(stateMachineName?: string);
+    /**
+     * 暂停一个状态机
+     * @param stateMachineName
+     * @returns
+     */
+    pauseStateMachine(stateMachineName?: string);
+    /**
+     * 恢复状态机
+     * @param stateMachineName
+     * @returns
+     */
+    resumeStateMachine(stateMachineName?: string);
+    /**
+     * 注册状态进指定状态机
+     * @param stateMachineName
+     * @param state
+     * @returns
+     */
+    register(
+      state: FW.StateMachineRegisterArgs | FW.StateMachineRegisterArgs[],
+      stateMachineName?: string,
+    );
+    /**
+     * 注销指定状态机的某个状态
+     * @param stateMachineName
+     * @param stateType
+     */
+    unRegister(stateType: number, stateMachineName?: string);
+  };
+
+  type AnimationManager = {
+    initialize(): void;
+    onDestroy(): void;
+
+    /**
+     * 创建一个tween动画
+     * @param args
+     * @returns
+     */
+    createTween(args?: FW.TweenArgs): FW.Tween;
+    /**
+     * 创建一个skeleton动画
+     * @param skeleton
+     * @returns
+     */
+    createSkeleton(skeleton: sp.Skeleton): FW.Skeleton;
+    /**
+     * 获取一个skeleton动画
+     * @param animationName
+     * @returns
+     */
+    getSkeleton(animationName: string): FW.Skeleton;
+
+    /**
+     * 暂停一个skeleton动画
+     * @param animationName
+     * @returns
+     */
+    pauseSkeleton(animationName: string): void;
+
+    /**
+     * 恢复一个skeleton动画
+     * @param animationName
+     * @returns
+     */
+    resumeSkeleton(animationName: string): void;
+
+    /**
+     * 移除一个skeleton动画
+     * @param animationName
+     * @returns
+     */
+    removeSkeleton(animationName: string): void;
+
+    /**
+     * 暂停所有动画
+     */
+    pauseAll(): void;
+    /**
+     * 恢复所有动画
+     * */
+    resumeAll(): void;
+    /**
+     * 创建动画机
+     * @param animationMachineName
+     * @returns
+     */
+    createAnimationMachine(animationMachineName: string): void;
+
+    /**
+     * 移除动画机
+     * @param animationMachineName
+     * @returns
+     */
+    removeAnimationMachine(animationMachineName: string): void;
+  };
+
+  type Tween = {
+    animationName: string;
+    animation: cc.Tween;
+    onInit?(): void;
+    pause(): FW.Tween;
+    resume(): FW.Tween;
+    timeScale(scale: number): FW.Tween;
+    start(): FW.Tween;
+    stop(): FW.Tween;
+    to<
+      OPTS extends Partial<{
+        progress: Function;
+        easing: Function | String;
+        onUpdate: Function;
+      }>,
+    >(
+      duration: number,
+      props: ConstructorType<T>,
+      opts?: OPTS,
+    ): FW.Tween;
+    by<
+      OPTS extends Partial<{
+        progress: Function;
+        easing: Function | String;
+        onUpdate: Function;
+      }>,
+    >(
+      duration: number,
+      props: ConstructorType<T>,
+      opts?: OPTS,
+    ): FW.Tween;
+    set(props: ConstructorType<T>): FW.Tween;
+  };
+
+  type Skeleton = {
+    play(args?: FW.SkeletonArgs): Promise<void>;
+    play(animationName?: string, args?: FW.SkeletonArgs): Promise<void>;
+    /** 设置皮肤 */
+    setSkin(skinName: string);
+    /** 更新数据 */
+    updateSkeletonData(data: sp.SkeletonData);
+
+    getTrackEntry();
+    /**
+     * 是否存在动画名
+     * @param animName
+     * @returns
+     */
+    hasAnimation(animName: string);
+    /**
+     * 获取所有动画
+     * @returns
+     */
+    getAnimations();
+
+    /**
+     * 获取所有动画名字
+     * @returns
+     */
+    getAnimationNames(): string[];
+
+    /** 速度缩放 */
+    timeScale(timeScale: number);
+    /**
+     * 暂停
+     */
+    pause(): void;
+    /**
+     * 恢复
+     */
+    resume(): void;
+    /**
+     * 添加spine挂点
+     * @param boneName
+     * @param node
+     */
+    addBone(boneName: string, node: cc.Node);
+  };
+
+  /**
+   * spine动画参数
+   */
+  type SkeletonArgs = {
+    loop?: boolean;
+    timeScale?: number;
+    progress?: number;
+    cb?: () => void;
+  };
+  /**
+   * tween动画参数
+   */
+  type TweenArgs = {
+    id?: number;
+    tag?: string;
+    target?: Component | Node;
+    timeScale?: number;
+  };
+
+  /**
+   * 时间对象
+   */
+
+  type Timer = {
+    /**
+     * 状态改变调用
+     */
+    resolve: Function;
+    /**
+     * 是否暂停
+     * */
+    pause: boolean;
+    /**
+     * id
+     */
+    id: number;
+    /**
+     * 重复次数
+     */
+    repeat: number;
+    /**
+     * 目标对象
+     */
+    target: TargetType;
+    /**
+     * 执行间隔
+     */
+    internal?: number;
+    /**
+     * 标签
+     */
+    tag?: string;
+
+    /**
+     *  执行时间
+     */
+    executeTime: number;
+    /**
+     * 回调函数
+     * @returns
+     */
+    cb?: () => void;
+  };
+
+  type Config = {
+    preLoad?: LoadConfig;
+    demandLoad?: LoadConfig;
+  };
+
+  type RegisterInitialize = {
+    initialize();
+    destroy();
+  };
+
+  type RegisterBundle = {
+    bundleName: string;
+    sceneName?: string;
+    depend?: string[];
+    autoRelease?: boolean;
+  };
+
+  type RegisterFramework = {
+    /**
+     * bundle名字
+     */
+    bundleName: string;
+    /**
+     * 逻辑
+     */
+    logic?: Newable<Logic>;
+    /**
+     * 数据
+     */
+    data?: Newable<Data>;
+    /**
+     * 资源配置
+     */
+    config?: Newable<Config>;
+    /**
+     * socket发送者
+     */
+    sender?: Newable<Sender>;
+    /**
+     * socket处理者
+     */
+    handle?: Newable<Handle>;
+  };
+
+  /**
+   * 状态机
+   */
+  type State = {
+    /**
+     * 进入状态
+     */
+    onEnter(args: any): void;
+    /**
+     * 退出状态
+     */
+    onExit(): void;
+    /**
+     * 初始化
+     */
+    onInit(): void;
+    /**
+     * 销毁状态
+     */
+    onDestroy(): void;
+    /**
+     * 状态每一帧更新
+     */
+    onUpdate(dt?: number): void;
+  };
+
+  type StateMachine = {
+    state: number;
+
+    enter(stateType: number, ...args: any): void;
+    /**
+     * 暂停状态机
+     * */
+    pause();
+    /**
+     * 恢复状态机
+     */
+    resume();
+    /**
+     * 注册
+     * @param type
+     * @param state
+     */
+    register<T extends FWStateBase>(state: FW.StateMachineRegisterArgs<T>);
+    /**
+     * 注销
+     * @param type
+     */
+    unRegister(stateType: number);
+    onDestroy();
+  };
+
+  /**
+   * 状态机注册参数
+   */
+  type StateMachineRegisterArgs<T extends FWStateBase = FWStateBase> = {
+    /**
+     * 状态类型
+     */
+    stateType: number;
+    /**
+     * 状态构造类
+     */
+    stateConstructor: { new (): T };
+  };
+
+  type AudioManager = {
+    /**
+     * 播放背景音乐
+     * @param path
+     * @param volume
+     * @param loop
+     */
+    playMusic(path: string, volume?: number, loop?: boolean): void;
+    /**
+     * 播放背景音乐
+     * @param music
+     * @param volume
+     * @param loop
+     */
+    playMusic(music: cc.AudioClip, volume?: number, loop?: boolean);
+    /**
+     * 播放背景音乐
+     * @param assetProperty
+     * @param volume
+     * @param loop
+     */
+    playMusic(assetProperty: AssetProperty, volume?: number, loop?: boolean): void;
+    /**
+     * 停止背景音乐
+     */
+    stopMusic(): void;
+    /**
+     * 暂停背景音乐
+     */
+    pauseMusic(): void;
+    /**
+     * 恢复背景音乐
+     */
+    resumeMusic(): void;
+    /**
+     * 设置背景音效是否静音
+     * @param mute
+     */
+    setMusicMute(mute: boolean): void;
+    /**
+     * 停止
+     * @param id
+     */
+    stop(id: number): void;
+    /**
+     * 播放音效
+     * @param path
+     * @param volume
+     * @param loop
+     */
+    play(path: string, cb?: (id: number) => void, volume?: number, loop?: boolean);
+    /**
+     * 播放音效
+     * @param audio
+     * @param volume
+     * @param loop
+     */
+    play(audio: cc.AudioClip, cb?: (id: number) => void, volume?: number, loop?: boolean);
+    /**
+     * 播放音效
+     * @param assetProperty
+     * @param volume
+     * @param loop
+     */
+    play(assetProperty: AssetProperty, cb?: (id: number) => void, volume?: number, loop?: boolean);
+    /**
+     * 暂停所有
+     */
+    pauseAll(): void;
+    /**
+     * 恢复所有
+     */
+    resumeAll(): void;
+    /**
+     * 停止所有
+     */
+    stopAll(): void;
+    /**
+     * 设置播放音效是否静音
+     * @param mute
+     */
+    setSoundMute(mute: boolean): void;
+    /**
+     * 播放音效
+     * @param path
+     * @param loop
+     */
+    playEffect(path: string, loop?: boolean): Promise<number>;
+    /**
+     * 播放音效
+     * @param audio
+     * @param loop
+     */
+    playEffect(audio: cc.AudioClip, loop?: boolean): Promise<number>;
+    /**
+     * 播放音效
+     * @param assetProperty
+     * @param loop
+     */
+    playEffect(assetProperty: FW.AssetProperty, loop?: boolean): Promise<number>;
+    /**
+     * 停止音效
+     * @param audioID
+     */
+    stopEffect(audioID: number): void;
+    /**
+     * 设置音效音量
+     * @param volume
+     */
+    setEffectsVolume(volume: number): void;
+    /**
+     * 停止全部音效
+     */
+    stopAllEffects(): void;
+    /**
+     * 设置音效是否静音
+     * @param mute
+     */
+    setEffectsMute(mute: boolean): void;
+  };
+
+  type Object = {
+    /** 是否已经初始化 */
+    initialize: boolean;
+    /** 对象唯一id */
+    uniqueId: number;
+    /** 对象是否启用 */
+    enable: boolean;
+    onGet(...args: any);
+    onPut();
+    onInit();
+    onDestroy();
+  };
+
+  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;
+    initOpacity?: number;
+    targetOpacity: number;
+    cb?: () => void;
+  };
+
+  type ScaleAnimationArgs = {
+    target: cc.Node;
+    duration: number;
+    initScale?: number;
+    targetScale: number;
+    easing?: cc.Easing;
+    cb?: () => void;
+  };
+
+  type PositionAnimationArgs = {
+    target: cc.Node;
+    duration: number;
+    initPosition?: Vec3;
+    targetPosition: Vec3;
+    cb?: () => void;
+  };
+
+  type Vec3 = {
+    x?: number;
+    y?: number;
+    z?: number;
+  };
+
+  type Vec2 = {
+    x?: number;
+    y?: number;
+  };
+
+  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 = {
+    taskId?: number;
+    /**
+     * 每帧最大执行时间(ms)，默认16ms (60fps) 帧预算
+     */
+    frameBudget?: number;
+    /**
+     * 每帧最多执行的任务个数
+     */
+    tasksFrameCount?: number;
+    /**
+     * 是否打印日志
+     */
+    log?: boolean;
+  };
+
+  type TaskEvent = {
+    taskId?: string;
+    type: string;
+    progress?: number;
+    message?: string;
+  };
+  /**
+   * 生产器
+   */
+  type TaskGenerator = AsyncGenerator<TaskEvent, void, unknown>;
+  /**
+   * 任务函数
+   */
+  type TaskFunction = () => TaskGenerator;
+
+  type PerformanceReport = {
+    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;
+    /**
+     * 获取当前任务状态
+     */
+    getStatus(): FWSystemDefine.FWTaskStatus;
+    /**
+     * 任务开始
+     * @param generator
+     */
+    start(generator: TaskFunction): Promise<Task>;
+    /**
+     * 添加任务
+     * @param generator
+     */
+    add(generator: TaskFunction): Promise<Task>;
+    /**
+     * 任务暂停
+     */
+    pause(): void;
+    /**
+     * 任务恢复
+     */
+    resume(): void;
+    /**
+     * 重置
+     */
+    reset(): void;
+    /**
+     * 获取任务性能报告
+     */
+    getPerformanceReport(): PerformanceReport;
+  };
+
+  type FrameDetail = {
+    /**
+     * 帧开始时间
+     */
+    frameStart: string;
+    /**
+     * 帧结束时间
+     */
+    frameEnd: string;
+    /**
+     * 总耗时
+     */
+    frameTime: number;
+    /**
+     * 本帧处理的任务数
+     */
+    tasksProcessed: number;
+    /**
+     * 本帧处理的任务详情
+     */
+    tasks: TaskExecutionRecord[];
+    /**
+     * 帧预算时间
+     */
+    frameBudget: number;
+    /**
+     * 预算使用率
+     */
+    frameBudgetUsed: number;
+  };
+
+  type TaskExecutionRecord = {
+    /**
+     * 任务唯一标识
+     */
+    taskId: string;
+    /**
+     * 任务结果
+     */
+    result: string;
+    /**
+     * 消息
+     */
+    message?: string;
+  };
+
+  declare function timeScale(scale: number);
+  declare let Entry: Entry;
+}