@zhongguo168a/yxeditor-common 0.0.2 → 0.0.9

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, ISchedulable, Node, Vec2, EventTouch, EventMouse, Prefab, Component, Color, Vec3, Vec4, AssetManager, SpriteAtlas } from 'cc';
+import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, Prefab, Node, Component, ISchedulable, AssetManager, Asset, SpriteAtlas, Vec2, Vec3, Vec4 } from 'cc';
+import { Dispatcher as Dispatcher$1 } from 'db://assets/core/libs/event';
+import { List as List$1 } from 'db://assets/core/libs/ds';
+import { AssetURI as AssetURI$1 } from 'db://assets/core/libs/loader/AssetManager';
 
 interface error {
     isCancel(): boolean;
@@ -206,386 +209,22 @@ declare class Timer {
     dispose(): void;
 }
 
-declare const timer: Timer;
-
-/**
- * Endian 类中包含一些值，它们表示用于表示多字节数字的字节顺序。
- * 字节顺序为 bigEndian（最高有效字节位于最前）或 littleEndian（最低有效字节位于最前）。
- */
-declare class Endian {
-    /**
-     * 表示多字节数字的最低有效字节位于字节序列的最前面。
-     * 十六进制数字 0x12345678 包含 4 个字节（每个字节包含 2 个十六进制数字）。最高有效字节为 0x12。最低有效字节为 0x78。（对于等效的十进制数字 305419896，最高有效数字是 3，最低有效数字是 6）。
-     */
-    static LITTLE_ENDIAN: string;
-    /**
-     * 表示多字节数字的最高有效字节位于字节序列的最前面。
-     * 十六进制数字 0x12345678 包含 4 个字节（每个字节包含 2 个十六进制数字）。最高有效字节为 0x12。最低有效字节为 0x78。（对于等效的十进制数字 305419896，最高有效数字是 3，最低有效数字是 6）。
-     */
-    static BIG_ENDIAN: string;
-}
-declare const enum EndianConst {
-    LITTLE_ENDIAN = 0,
-    BIG_ENDIAN = 1
-}
-/**
- * ByteArray 类提供用于优化读取、写入以及处理二进制数据的方法和属性。
- * 注意：ByteArray 类适用于需要在字节层访问数据的高级开发人员。
- */
-declare class ByteArray {
-    /**
-     * @private
-     */
-    protected bufferExtSize: number;
-    protected data: DataView;
-    protected _bytes: Uint8Array;
-    /**
-     * @private
-     */
-    protected _position: number;
-    /**
-     *
-     * 已经使用的字节偏移量
-     */
-    protected write_position: number;
-    /**
-     * 更改或读取数据的字节顺序；egret.EndianConst.BIG_ENDIAN 或 egret.EndianConst.LITTLE_ENDIAN。
-     */
-    get endian(): string;
-    set endian(value: string);
-    protected $endian: EndianConst;
-    constructor(buffer?: ArrayBuffer | Uint8Array, bufferExtSize?: number);
-    /**
-     * @deprecated
-     * @version Egret 2.4
-     * @platform Web,Native
-     */
-    setArrayBuffer(buffer: ArrayBuffer): void;
-    /**
-     * 可读的剩余字节数
-     * @returns
-     */
-    get readAvailable(): number;
-    get buffer(): ArrayBuffer;
-    get rawBuffer(): ArrayBuffer;
-    /**
-     * @private
-     */
-    set buffer(value: ArrayBuffer);
-    get bytes(): Uint8Array;
-    /**
-     * @private
-     */
-    get dataPage(): DataView;
-    /**
-     * @private
-     */
-    set dataPage(value: DataView);
-    /**
-     * @private
-     */
-    get bufferOffset(): number;
-    /**
-     * 将文件指针的当前位置（以字节为单位）移动或返回到 ByteArray 对象中。下一次调用读取方法时将在此位置开始读取，或者下一次调用写入方法时将在此位置开始写入。
-     */
-    get position(): number;
-    set position(value: number);
-    /**
-     * ByteArray 对象的长度（以字节为单位）。
-     * 如果将长度设置为大于当前长度的值，则用零填充字节数组的右侧。
-     * 如果将长度设置为小于当前长度的值，将会截断该字节数组。
-     */
-    get length(): number;
-    set length(value: number);
-    protected _validateBuffer(value: number): void;
-    /**
-     * 可从字节数组的当前位置到数组末尾读取的数据的字节数。
-     * 每次访问 ByteArray 对象时，将 bytesAvailable 属性与读取方法结合使用，以确保读取有效的数据。
-     */
-    get bytesAvailable(): number;
-    /**
-     * 清除字节数组的内容，并将 length 和 position 属性重置为 0。
-     */
-    clear(): void;
-    /**
-     * 从字节流中读取布尔值。读取单个字节，如果字节非零，则返回 true，否则返回 false
-     * @return 如果字节不为零，则返回 true，否则返回 false
-     */
-    readBool(): boolean;
-    /**
-     * 从字节流中读取带符号的字节
-     * @return 介于 -128 和 127 之间的整数
-     */
-    readByte(): number;
-    /**
-     * 从字节流中读取 length 参数指定的数据字节数。从 offset 指定的位置开始，将字节读入 bytes 参数指定的 ByteArray 对象中，并将字节写入目标 ByteArray 中
-     * @param bytes 要将数据读入的 ByteArray 对象
-     * @param offset bytes 中的偏移（位置），应从该位置写入读取的数据
-     * @param length 要读取的字节数。默认值 0 导致读取所有可用的数据
-     */
-    readBytes(bytes: ByteArray, offset?: number, length?: number): void;
-    /**
-     * 从字节流中读取一个 IEEE 754 双精度（64 位）浮点数
-     * @return 双精度（64 位）浮点数
-     */
-    readFloat64(): number;
-    /**
-     * 从字节流中读取一个 IEEE 754 单精度（32 位）浮点数
-     * @return 单精度（32 位）浮点数
-     */
-    readFloat32(): number;
-    /**
-     * 从字节流中读取一个带符号的 32 位整数
-     * @return 介于 -2147483648 和 2147483647 之间的 32 位带符号整数
-     */
-    readInt32(): number;
-    /**
-     * 从字节流中读取一个带符号的 32 位整数数组
-     */
-    readInt32Array(): number[];
-    /**
-     * 从字节流中读取一个带符号的 16 位整数
-     * @return 介于 -32768 和 32767 之间的 16 位带符号整数
-     */
-    readInt16(): number;
-    /**
-     * 从字节流中读取无符号的字节
-     * @return 介于 0 和 255 之间的无符号整数
-     */
-    readInt8(): number;
-    /**
-     * 从字节流中读取无符号的字节
-     * @return 介于 0 和 255 之间的无符号整数
-     */
-    readUint8(): number;
-    /**
-     * 从字节流中读取一个无符号的 32 位整数
-     * @return 介于 0 和 4294967295 之间的 32 位无符号整数
-     */
-    readUint32(): number;
-    /**
-     * 从字节流中读取一个无符号的 16 位整数
-     * @return 介于 0 和 65535 之间的 16 位无符号整数
-     */
-    readUint16(): number;
-    /**
-     * 从字节流中读取一个 UTF-8 字符串。假定字符串的前缀是无符号的短整型（以字节表示长度）
-     * @return UTF-8 编码的字符串
-     */
-    readUTF(): string;
-    /**
-     * 从字节流中读取一个由 length 参数指定的 UTF-8 字节序列，并返回一个字符串
-     * @param length 指明 UTF-8 字节长度的无符号短整型数
-     * @return 由指定长度的 UTF-8 字节组成的字符串
-     */
-    readUTFBytes(length: number): string;
-    /**
-     * 写入布尔值。根据 value 参数写入单个字节。如果为 true，则写入 1，如果为 false，则写入 0
-     * @param value 确定写入哪个字节的布尔值。如果该参数为 true，则该方法写入 1；如果该参数为 false，则该方法写入 0
-     */
-    writeBool(value: boolean): void;
-    /**
-     * 在字节流中写入一个字节
-     * 使用参数的低 8 位。忽略高 24 位
-     * @param value 一个 32 位整数。低 8 位将被写入字节流
-     */
-    writeByte(value: number): void;
-    /**
-     * 将指定字节数组 bytes（起始偏移量为 offset，从零开始的索引）中包含 length 个字节的字节序列写入字节流
-     * 如果省略 length 参数，则使用默认长度 0；该方法将从 offset 开始写入整个缓冲区。如果还省略了 offset 参数，则写入整个缓冲区
-     * 如果 offset 或 length 超出范围，它们将被锁定到 bytes 数组的开头和结尾
-     * @param bytes ByteArray 对象
-     * @param offset 从 0 开始的索引，表示在数组中开始写入的位置
-     * @param length 一个无符号整数，表示在缓冲区中的写入范围
-     */
-    writeBytes(bytes: ByteArray, offset?: number, length?: number): void;
-    /**
-     * 在字节流中写入一个 IEEE 754 双精度（64 位）浮点数
-     * @param value 双精度（64 位）浮点数
-     */
-    writeDouble(value: number): void;
-    /**
-     * 在字节流中写入一个 IEEE 754 单精度（32 位）浮点数
-     * @param value 单精度（32 位）浮点数
-     */
-    writeFloat(value: number): void;
-    /**
-     * 在字节流中写入一个带符号的 32 位整数
-     * @param value 要写入字节流的整数
-     */
-    writeInt(value: number): void;
-    /**
-     * 在字节流中写入一个 16 位整数。使用参数的低 16 位。忽略高 16 位
-     * @param value 32 位整数，该整数的低 16 位将被写入字节流
-     */
-    writeShort(value: number): void;
-    /**
-     * 在字节流中写入一个无符号的 32 位整数
-     * @param value 要写入字节流的无符号整数
-     */
-    writeUnsignedInt(value: number): void;
-    /**
-     * 在字节流中写入一个无符号的 16 位整数
-     * @param value 要写入字节流的无符号整数
-     */
-    writeUnsignedShort(value: number): void;
-    /**
-     * 将 UTF-8 字符串写入字节流。先写入以字节表示的 UTF-8 字符串长度（作为 16 位整数），然后写入表示字符串字符的字节
-     * @param value 要写入的字符串值
-     */
-    writeUTF(value: string): void;
-    /**
-     * 将 UTF-8 字符串写入字节流。类似于 writeUTF() 方法，但 writeUTFBytes() 不使用 16 位长度的词为字符串添加前缀
-     * @param value 要写入的字符串值
-     */
-    writeUTFBytes(value: string): void;
-    /**
-     * @returns
-     */
-    toString(): string;
-    /**
-     * @private
-     * 将 Uint8Array 写入字节流
-     * @param bytes 要写入的Uint8Array
-     * @param validateBuffer
-     */
-    _writeUint8Array(bytes: Uint8Array | ArrayLike<number>, validateBuffer?: boolean): void;
-    /**
-     * @param len
-     * @returns
-     */
-    validate(len: number): boolean;
-    /**********************/
-    /**********************/
-    /**
-     * @private
-     * @param len
-     * @param needReplace
-     */
-    protected validateBuffer(len: number): void;
-    /**
-     * @private
-     * UTF-8 Encoding/Decoding
-     */
-    private encodeUTF8;
-    /**
-     * @private
-     *
-     * @param data
-     * @returns
-     */
-    private decodeUTF8;
-    /**
-     * @private
-     *
-     * @param code_point
-     */
-    private encoderError;
-    /**
-     * @private
-     *
-     * @param fatal
-     * @param opt_code_point
-     * @returns
-     */
-    private decoderError;
-    /**
-     * @private
-     */
-    private EOF_byte;
-    /**
-     * @private
-     */
-    private EOF_code_point;
-    /**
-     * @private
-     *
-     * @param a
-     * @param min
-     * @param max
-     */
-    private inRange;
-    /**
-     * @private
-     *
-     * @param n
-     * @param d
-     */
-    private div;
-    /**
-     * @private
-     *
-     * @param string
-     */
-    private stringToCodePoints;
-}
-
-declare enum ConnectState {
-    Wait = 0,
-    Closed = 1,
-    Connecting = 2,
-    Connected = 3
-}
-declare enum ValidState {
-    Unknown = 0,
-    Validing = 1,
-    Valid = 2
-}
-declare enum NetIdent {
-    Send = "Send"
-}
-declare enum NetSub {
-    All = 0,
-    NotConnected = 1,
-    Invalid = 2
-}
-declare enum ResponseSub {
-    All = 0,
-    Succeed = 1,
-    Failed = 2,
-    Timeout = 3
-}
-declare enum SerializeMode {
-    JSON = 0,
-    JSON_REF = 1,
-    BYTE = 2
-}
-declare enum PushTag {
-    Unknown = 0,
-    Response = 1,
-    Push = 2,
-    Event = 3,
-    Command = 4,
-    SyncCreate = 5,
-    SyncUpdate = 6,
-    SyncDelete = 7
-}
-declare enum HttpResponseType {
-    /**
-     * 返回字符串。HttpRequest.responseType属性的默认值。
-     */
-    TEXT = "text",
-    /**
-     * 返回二进制的ArrayBuffer对象。
-     */
-    ARRAY_BUFFER = "arraybuffer",
-    BLOB = "blob",
-    DOCUMENT = "document",
-    JSON = "json"
-}
-declare enum HttpMethod {
-    GET = "GET",
-    POST = "POST"
-}
-declare enum WebSocketType {
-    /**
-     * 以字符串格式发送和接收数据
-     */
-    STRING = "webSocketTypeString",
-    /**
-     * 以二进制格式发送和接收数据
-     */
-    BINARY = "webSocketTypeBinary"
+declare class ControllerSet {
+    constructor(mod: IModule);
+    has(name: string): boolean;
+    add(controller: IController): void;
+    createAndEnable(name: string, ...args: any[]): void;
+    create(name: string, ...args: any[]): void;
+    remove(name: string): void;
+    disable(name: string): void;
+    enable(name: string): void;
+    enableAll(): void;
+    disableAll(): void;
+    dispose(): void;
+    registerCreator(name: string, creator: (...args: any[]) => IController): void;
+    protected _creator: {};
+    protected _mod: IModule;
+    private data;
 }
 
 /**
@@ -730,671 +369,466 @@ declare class EventManager implements IEventManager {
  */
 declare const eventmgr: EventManager;
 
-declare class Caller<ARGS = any, RESULT = any> extends EventManager {
-    protocol: string;
-    constructor(protocol: string);
-    newArgs(): ARGS;
-    /**
-     * 获取参数的方法或者直接赋值
-     * @param val
-     */
-    argsGetter(val: (ctx: Caller<ARGS, RESULT>) => void): this;
-    argsCondition(val: (ctx: Caller<ARGS, RESULT>) => error): this;
-    setConn(key: string): this;
-    setTimeout(val?: number): this;
-    noValid(): this;
-    onSimulate(val: (ctx: Caller<ARGS, RESULT>) => void): this;
-    /**
-     * 添加响应返回时的处理函数
-     * @param val
-     */
-    onResponse(val: (ctx: Caller<ARGS, RESULT>) => void): this;
-    send(): this;
-    /**
-     * 等待发送的结果
-     * 如果返回 null，表示主动取消 [cancel]
-     */
-    wait(): Promise<this>;
-    protected _send(): LinkError;
-    protected get connection(): IConn;
-    response(data: any, err: LinkError): void;
-    cancel(): void;
+/**
+ * 一个简单的功能/库模块
+ */
+interface IModuleSample {
+}
+interface IModule {
+    controllers: ControllerSet;
+}
+declare class Module extends EventManager implements IModule {
+    constructor();
+    get controllers(): ControllerSet;
+    private _controllers;
+}
+
+interface IController {
+    get name(): string;
+    get module(): IModule;
+    init(core: IModule): any;
+    enable(): any;
+    disable(): any;
+    dispose(): any;
+}
+declare class Controller {
+    constructor(name: string);
+    init(core: IModule): void;
+    enable(): void;
+    disable(): void;
     dispose(): void;
-    protected timeoutHandler(): void;
-    get hasResponse(): boolean;
-    /**
-     * 连接的名字
-     */
-    protected _conn: string;
-    /**
-     * 无需验证
-     */
-    protected _noValid: boolean;
-    protected _onSimulate: Function;
-    protected _argsGetter: Function | any;
-    protected _argsCondition: Function;
-    private _hasResponse;
-    protected _seq: number;
-    /**
-     * 消息额参数
-     */
-    args: ARGS;
-    result: RESULT;
-    error: LinkError;
-    get timeout(): number;
-    protected _timeout: number;
+    get name(): string;
+    get module(): IModule;
+    get isEnable(): boolean;
+    protected _module: IModule;
+    protected _name: string;
+    protected _enabled: boolean;
 }
 
-interface IConn {
-    key: string;
-    token: string;
-    send(caller: Caller): any;
-    connected: boolean;
-    isValid(): boolean;
-    update(): any;
-    lastSeqResp: number;
-    lastSeqSend: number;
-    seqToCaller: {
-        [key: string]: Caller;
-    };
+interface IModel {
+    get module(): IModule;
+}
+declare class SimpleModel {
+    constructor(mod: IModule);
+    get core(): IModule;
+    protected _mod: any;
+}
+declare class Model extends EventManager {
+    constructor(core?: IModule);
+    get module(): IModule;
+    protected _module: any;
+}
+
+interface IExtend {
+    get module(): IModule;
 }
 
-declare class SyncHandler {
-    create: (key: string, obj: any) => void;
-    update: (key: string, obj: any) => void;
-    remove: (key: string, obj: any) => void;
+declare class Factory {
+    _controllers: {
+        [key: string]: (mod: IModule) => IController;
+    };
+    _extends: {
+        [key: string]: (mod: IModule, ...args: any) => IExtend;
+    };
+    registerController(name: string, creator: (mod: IModule, ...args: any) => IController): void;
+    registerExtend(name: string, creator: (mod: IModule, ...args: any) => IExtend): void;
+    createController(name: string, mod: IModule): IController;
+    createExtend(name: string, mod: IModule, ...args: any[]): IExtend;
 }
-declare class NetManager extends EventManager {
-    init(): void;
+
+/**
+ * 视图的路由值, 保存视图的信息
+ * 规则: path/search
+ * path = /a/b/c
+ * search = ?key=val&key=val
+ */
+declare class Route {
+    constructor(route: string);
+    recycle(): void;
     /**
-     * 创建一个socket链接
-     * 可通过SendMessageCtrl.SetConn指定
-     * @param key
-     * @param addr
+     * 获取调用链
+     * 例如 a/b/c，返回 a/b/c -> a/b -> a
      */
-    createSocket(key: string, addr: string): IConn;
-    /**
-     * 创建一个http链接
-     * 可通过SendMessageCtrl.SetConn指定
-     * @param key
-     * @param addr
-     */
-    createHttp(key: string, addr: string): IConn;
-    /**
-     * 设置默认的链接
-     * ctrlz.SendMessageAction默认使用此链接
-     * 一个游戏可能包括多个链接：主socket，战斗socket，聊天socket，功能http
-     * @param key
-     */
-    setDefault(key: string): void;
-    /**
-     * 获取链接
-     * @param key
-     */
-    getConn(key: string): IConn;
+    getLink(): Route[];
+    protected static data: any;
+    static getData(route: string): Route;
+    toLoaction(): Location;
     /**
-     * 获取默认的链接
+     * @constructor
      */
-    getDefault(): IConn;
+    NewRoute(): Route;
     /**
-     * 注册Caller的创建函数
-     * 通常在打开界面的时候注册
-     * ```
-     * netmgr.register(this.uuid, rg_opt.Http.S数据表创建, ()=>{
-     *             return new Caller(rg_opt.Http.S数据表读取)
-     *                 .argsGetter((caller?) => {
-     *                     return null;
-     *                 })
-     *                 .argsCondition((caller) => {
-     *                     return null;
-     *                 })
-     *                 .onResponse((caller) => {
-     *
-     *                 })
-     *         })
-     * ```
-     * @param group
-     * @param id
-     * @param creator
+     * @constructor
      */
-    register(group: string, id: string, creator: Function): void;
+    NewRoutePath(): Route;
     /**
-     * 如果有全局调用的需求，可以设置group为 "global"
-     * @param id
-     * @param creator
+     * 新建一个带参数的路由
+     * @param params
      */
-    registerGlobal(id: string, creator: Function): void;
+    NewRouteParam(params: any): Route;
+    toString(): string;
+    get path(): string;
+    get parentPath(): string;
+    get params(): any;
+    get search(): string;
+    set search(value: string);
+    get name(): string;
     /**
-     * 获取调用者
-     * @param group
-     * @param id
+     * path/search
      */
-    getCaller(group: string, id: string): Caller;
-    getCallerGlobal(id: string): Caller;
-    protected getCallerCreator(group: string, id: string): any;
-    removeGroup(group: string): void;
-    removeGroupGlobal(): void;
-    removeAll(): void;
-    registerCommandPriority(handler: (cmd: any, args: any) => void): void;
-    registerCommand(cmd: string, handler: (args: any) => void): void;
-    executeCommand(key: string, args: any): void;
-    registerSyncHandler(handler: SyncHandler): void;
-    useSimulate(): void;
-    isSimulate(): boolean;
-    protected _syncHandler: SyncHandler;
-    protected _cmdHandlers: {
-        [key: string]: (args: any) => void;
-    };
-    protected _cmdPriority: Function;
-    protected _callerCreator: any[];
-    protected _simulate: boolean;
-    conns: {
-        [key: string]: IConn;
-    };
-    defaultKey: string;
-    serialMode: SerializeMode;
+    get key(): string;
+    private _path;
+    private _parentPath;
+    private _search;
+    private _name;
+    private _params;
+    protected _route: string;
 }
-declare var netmgr: NetManager;
 
-declare class HttpRequest {
-    constructor();
+declare class TreeIterator {
+    break(): void;
+    isBreak(): boolean;
+    protected _isBreak: any;
+}
+interface ITreeListItem {
     /**
-     * @private
+     * 路径
      */
-    private _xhr;
+    path: string;
     /**
-     *
+     * 自定义数据
      */
-    timeout: number;
+    data?: any;
     /**
-     *
+     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
      */
-    onError: (request: HttpRequest) => void;
+    tags?: {
+        [key: string]: any;
+    };
     /**
-     *
+     * 是否树叶
      */
-    onComplete: (request: HttpRequest) => void;
+    isLeaf: boolean;
+}
+declare class TreeNode<T = any> {
+    get root(): TreeRoot;
     /**
-     *
+     * 根节点
      */
-    onProgress: (request: HttpRequest, event: any) => void;
+    protected _root: TreeRoot;
     /**
-     * 出现错误时的错误信息
+     * 编号
      */
-    error: error;
+    uuid: string;
     /**
-     * @private
-     * 本次请求返回的数据，数据类型根据responseType设置的值确定。
+     * 编号
      */
-    get response(): any;
+    id: string;
     /**
-     * @private
+     * 自定义数据
      */
-    private _responseType;
+    data: T;
     /**
-     * @private
-     * 设置返回的数据格式，请使用 HttpResponseType 里定义的枚举值。设置非法的值或不设置，都将使用HttpResponseType.TEXT。
+     * 是否树叶
      */
-    get responseType(): HttpResponseType;
-    set responseType(value: HttpResponseType);
+    isLeaf: boolean;
     /**
-     * @private
+     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
      */
-    private _withCredentials;
+    tags: {
+        [key: string]: any;
+    };
     /**
-     * @private
-     * 表明在进行跨站(cross-site)的访问控制(Access-Control)请求时，是否使用认证信息(例如cookie或授权的header)。 默认为 false。(这个标志不会影响同站的请求)
+     * 深度
      */
-    get withCredentials(): boolean;
-    set withCredentials(value: boolean);
+    get depth(): number;
+    private _depth;
     /**
-     * @private
+     * 父节点
      */
-    private _url;
-    private _method;
+    parent: TreeNode;
     /**
-     * @private
-     *
-     * @returns
+     * 子节点
      */
-    private getXHR;
+    children: TreeNode[];
     /**
-     * @private
-     * 初始化一个请求.注意，若在已经发出请求的对象上调用此方法，相当于立即调用abort().
-     * @param url 该请求所要访问的URL该请求所要访问的URL
-     * @param method 请求所使用的HTTP方法， 请使用 HttpMethod 定义的枚举值.
+     * 设置根
+     * @param val
      */
-    open(url: string, method?: HttpMethod): void;
+    setRoot(val: TreeRoot): void;
+    getTags(): {
+        [key: string]: any;
+    };
+    getTag(name: string): any;
+    removeTag(name: string): void;
+    setTag(name: string, value: any): void;
+    constructor(id: string, isLeaf?: boolean);
+    addChild(val: TreeNode): void;
+    getChildIndex(val: TreeNode): number;
+    insertChild(val: TreeNode, index: number): void;
+    removeChild(val: TreeNode): void;
+    removeChildren(): void;
+    get name(): string;
+    setDepth(val: number): void;
+    containsById(id: string): boolean;
     /**
-     * @private
-     * 发送请求.
-     * @param data 需要发送的数据
+     * 通过编号获取子节点
+     * @param id
      */
-    send(data?: any): void;
+    getChildById(id: string): TreeNode;
     /**
-     * @private
-     * 如果请求已经被发送,则立刻中止请求.
+     * 返回相邻的上一个节点
      */
-    abort(): void;
+    prevNode(): TreeNode;
     /**
-     * @private
-     * 返回所有响应头信息(响应头名和值), 如果响应头还没接受,则返回"".
+     * 返回相邻的下一个节点
      */
-    getAllResponseHeaders(): string;
-    private headerObj;
+    nextNode(): TreeNode;
     /**
-     * @private
-     * 给指定的HTTP请求头赋值.在这之前,您必须确认已经调用 open() 方法打开了一个url.
-     * @param header 将要被赋值的请求头名称.
-     * @param value 给指定的请求头赋的值.
+     * 如果返回true则删除节点，包含当前节点
+     * @param f
      */
-    setRequestHeader(header: string, value: string): void;
+    walkRemove(f: (node: TreeNode) => boolean): void;
+    private _walkRemove;
     /**
-     * @private
-     * 返回指定的响应头的值, 如果响应头还没被接受,或该响应头不存在,则返回"".
-     * @param header 要返回的响应头名称
+     * 如果返回true则继续，包含当前节点
+     * @param f
+     * @param inChild
      */
-    getResponseHeader(header: string): string;
+    walk(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): void;
+    private _walk;
     /**
-     * @private
+     * 从当前节点（包括）遍历父节点链，包含当前节点
+     * @param f
      */
-    private onTimeout;
-    private callOnError;
-    private callOnProgress;
-    private callOnComplete;
+    walkParent(f: (node: TreeNode) => boolean): boolean;
     /**
-     * @private
+     * 从当前节点往前遍历（深度），包含当前节点
+     * @param f
+     * @param inChild
      */
-    private onReadyStateChange;
+    walkPrev(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): any;
+    private _walkPrev;
+    dump(): void;
     /**
-     * @private
+     * 遍历节点，查找指定编号的节点
      */
-    private updateProgress;
+    findById(id: string): TreeNode;
     /**
-     * @private
+     * 如果返回true则继续
+     * @param f
      */
-    private onload;
+    findOne(f: (node: TreeNode) => boolean): TreeNode;
+    private _findOne;
     /**
-     * @private
+     * 通过路径获取节点
+     * 格式为 /path1/path2/...
+     * 如果 path == "/"，则返回自身
+     * @param path
      */
-    private onerror;
-}
-declare class NetHttp {
+    getNodeByPath(path: string): TreeNode;
+    protected getNodeByPathArr(pathArr: string[]): TreeNode;
+    getName(): string;
+    getPath(): string;
     /**
-     * 地址
+     * 如果返回true则继续
+     * @param f
      */
-    addr: string;
-    key: string;
-    token: string;
-    lastSeqResp: number;
-    lastSeqSend: number;
-    seqToCaller: any;
-    valid: ValidState;
-    constructor();
-    isValid(): boolean;
-    send(caller: Caller): Caller<any, any>;
-    update(): void;
-    get connected(): boolean;
+    find(f: (node: TreeNode) => boolean): TreeNode[];
+    private _find;
+    toRoot(): TreeRoot;
+    clone(): TreeNode;
+    protected cloneChildrenTo(node: TreeNode): void;
+    fixDepthAndRoot(depth: number, root: TreeRoot): void;
+    toString(): string;
 }
-
-declare function parseData(mode: number, data: any | ByteArray, route?: string): [any, error];
-declare function receiveData(conn: IConn, ba: ByteArray, endian: string): void;
-
-/**
- *
- */
-
-/**
- * egret.WebSocket 类启用代码以建立传输控制协议 (TCP) 套接字连接，用于发送和接收字符串或二进制数据。
- * 要使用 egret.WebSocket 类的方法，请先使用构造函数 new egret.WebSocket 创建一个 egret.WebSocket 对象。
- * 套接字以异步方式传输和接收数据。
- */
-declare class FrameWebSocket {
+declare class TreeRoot<NODE = any> extends EventManager {
     /**
-     * 以字符串格式发送和接收数据
+     * 添加数据节点
+     * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
      */
-    static TYPE_STRING: string;
+    static EVENT_ADD: string;
     /**
-     * 以二进制格式发送和接收数据
+     * 移除数据节点
+     * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
      */
-    static TYPE_BINARY: string;
-    private _writeMessage;
-    private _readMessage;
-    private _connected;
-    private _connecting;
-    private _socket;
-    private _url;
+    static EVENT_REMOVE: string;
     /**
-     * 出现错误时的错误信息
+     * 插入数据节点
+     * dispatchParams = {node:TreeNode, before:TreeNode}
      */
-    error: error;
+    static EVENT_INSERT: string;
     /**
-     * 根据提供的url连接
-     * @param url 全地址。如ws://echo.websocket.org:80
+     * 刷新数据节点
+     * dispatchParams = {node:TreeNode}
      */
-    constructor(url?: string);
-    onOpen: (socket: FrameWebSocket) => void;
-    onClose: (socket: FrameWebSocket) => void;
-    onMessage: (socket: FrameWebSocket) => void;
-    onError: (socket: FrameWebSocket) => void;
-    private callOnOpen;
-    private callOnClose;
-    private callOnMessage;
-    private callOnError;
+    static EVENT_REFRESH: string;
     /**
-     * 根据提供的url连接
-     * @param url 全地址。如ws://echo.websocket.org:80
+     * 设置数据时触发
+     * dispatchParams = {node:TreeNode}
      */
-    connect(url: string): void;
+    static EVENT_DATA_SET: string;
     /**
-     * 关闭套接字
+     * 设置数据时触发
+     * dispatchParams = {node:TreeNode, tag:string, value:any}
      */
-    close(): void;
+    static EVENT_TAGS_SET: string;
+    static create(): TreeRoot<any>;
     /**
-     * 对套接字输出缓冲区中积累的所有数据进行刷新
+     * 通过列表生成一个树结构
+     * @param items
+     * @param existed 列表将添加的已经存在的树结构
      */
-    flush(): void;
-    private _isReadySend;
+    static createByList(items: ITreeListItem[], existed?: TreeRoot): TreeRoot;
+    static sortChildrenByName(node: TreeNode, des?: boolean): void;
+    constructor();
+    setNodeData(node: TreeNode, data: any): void;
+    setNodeTags(node: TreeNode, tag: string, value: any, force?: boolean): void;
+    getNodeByPath(path: string): TreeNode;
+    makeNodeByPath(path: string): TreeNode;
     /**
-     * 将字符串数据写入套接字
-     * @param message 要写入套接字的字符串
+     * 添加节点，按照 node.path 添加到正确的位置
+     * @param node
+     * @param parentPath 如果父节点路径为 "", 则添加到起源节点
+     * @param autoCreateParent 如果父节点不存在，自动创建
      */
-    writeUTF(message: string): void;
+    addNode(node: TreeNode, parentPath?: string, autoCreateParent?: boolean): void;
+    removeNode(node: TreeNode): void;
+    removeChildren(node: TreeNode): void;
+    insertNode(node: TreeNode, before: TreeNode, resetId?: boolean): void;
+    walk(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): void;
+    walkPrev(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): void;
     /**
-     * 从套接字读取一个 UTF-8 字符串
-     * @returns {string}
+     * 派发 refresh 消息
+     * @param node
      */
-    readUTF(): string;
-    private _readByte;
-    private _writeByte;
-    private _bytesWrite;
+    refresh(node: TreeNode): void;
     /**
-     * 从指定的字节数组写入一系列字节。写入操作从 offset 指定的位置开始。
-     * 如果省略了 length 参数，则默认长度 0 将导致该方法从 offset 开始写入整个缓冲区。
-     * 如果还省略了 offset 参数，则写入整个缓冲区。
-     * @param bytes 要从中读取数据的 ByteArray 对象
-     * @param offset ByteArray 对象中从零开始的偏移量，应由此开始执行数据写入
-     * @param length 要写入的字节数。默认值 0 导致从 offset 参数指定的值开始写入整个缓冲区
-
+     * 克隆当前的树结
+     * * 新的tags克隆旧的data
+     * * 新的data指向旧的data
      */
-    writeBytes(bytes: ByteArray, offset?: number, length?: number): void;
+    clone(): TreeRoot;
+    toString(): string;
+    createNode(id: string, isLeaf?: boolean): TreeNode;
     /**
-     * 从套接字读取 length 参数指定的数据字节数。从 offset 所表示的位置开始，将这些字节读入指定的字节数组
-     * @param bytes 要将数据读入的 ByteArray 对象
-     * @param offset 数据读取的偏移量应从该字节数组中开始
-     * @param length 要读取的字节数。默认值 0 导致读取所有可用的数据
+     * origin的第一个child
      */
-    readBytes(bytes: ByteArray, offset?: number, length?: number): void;
+    get firstNode(): TreeNode;
+    origin: TreeNode;
+}
+declare class TreeRootPlugin {
+    root: TreeRoot;
+}
+declare class TreeNodePlugin {
+    node: TreeNode;
+}
+
+interface IListItem {
     /**
-     * 表示此 Socket 对象目前是否已连接
+     * 编号
      */
-    get connected(): boolean;
+    id: string;
     /**
-     * @private
+     * 自定义数据
      */
-    private _type;
+    data?: any;
     /**
-     * 发送和接收数据的格式，默认是字符串格式
+     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
      */
-    get type(): WebSocketType;
-    set type(value: WebSocketType);
-    static URI: "ws://" | "wss://";
-}
-declare class NetSocket extends EventManager {
-    static EVENT_CONNECTED: string;
-    static EVENT_CLOSED: string;
-    static EVENT_TIMEOUT: string;
-    /**
-     * 连接校验失败，并超过重试次数
-     */
-    static EVENT_VALID_FAIL: string;
-    /**
-     * 连接校验成功
-     */
-    static EVENT_VALID: string;
-    key: string;
-    protected reconnectMax: number;
-    protected reconnectCount: number;
-    protected reconnectSpace: number;
-    addr: string;
-    state: ConnectState;
-    valid: ValidState;
-    private lastReconnectTime;
-    lastSeqSend: number;
-    lastSeqResp: number;
-    seqToCaller: {
-        [key: string]: Caller;
+    tags?: {
+        [key: string]: any;
     };
-    endian: string;
-    protected _socket: FrameWebSocket;
-    token: string;
-    serialMode: SerializeMode;
-    constructor();
-    get connected(): boolean;
-    isValid(): boolean;
-    update(): void;
-    protected createVerifyConnectionCaller(): Caller;
-    protected createHeartBeatCaller(): Caller;
-    protected updateValid(): void;
-    protected _validCaller: Caller;
-    protected _validMax: number;
-    protected _validCount: number;
-    getReconnectSpace(): number;
-    reconnect(): void;
-    connect(): void;
-    close(): void;
-    waitConnect(): Promise<boolean>;
-    waitValid(): Promise<boolean>;
-    /**
-     *
-     * @param caller
-     */
-    send(caller: Caller): Caller;
-    protected _onOpen(e: any): void;
-    protected _流量: number;
-    reset流量(): void;
-    protected _流量时间: number;
-    protected _count: number;
-    protected _onMessage(): void;
-    protected _onClose(e: any): void;
-    protected _onError(e: any): void;
 }
-
-declare class RequestProtocol {
+declare class ListNode {
+    static create(id: string, data?: any): ListNode;
+    constructor();
+    root: ListSource;
+    uuid: string;
     id: string;
-    seq: number;
-    serialMode: number;
-    token: string;
     data: any;
-    pack(writer: ByteArray): void;
+    tags: {};
+    getTags(): {
+        [key: string]: any;
+    };
+    setTags(tags: {
+        [key: string]: any;
+    }): void;
+    getTag(name: string): any;
+    setTag(name: string, value: any): void;
 }
-declare class ResponseProtocol {
-    seq: number;
-    serialMode: number;
-    error: string;
-    data: ByteArray;
-    unpack(reader: ByteArray, endian: string): void;
-}
-declare class PushProtocol {
-    serialMode: number;
-    data: any;
-    unpack(reader: ByteArray): void;
-}
-declare class CreateProtocol {
-    key: string;
-    serialMode: number;
-    data: any;
-    unpack(reader: ByteArray): void;
-}
-declare class UpdateProtocol {
-    key: string;
-    serialMode: number;
-    data: any;
-    unpack(reader: ByteArray): void;
-}
-declare class DeleteProtocol {
-    key: string;
-    unpack(reader: ByteArray): void;
-}
-declare class EventProtocol {
-    key: string;
-    serialMode: number;
-    data: any;
-    unpack(reader: ByteArray): void;
-}
-declare class CommandProtocol {
-    key: string;
-    serialMode: number;
-    data: any;
-    unpack(reader: ByteArray): void;
-}
-
-declare class ListIterator {
-    break(): void;
-    isBreak(): boolean;
-    protected _isBreak: any;
-}
-declare class List<T = any> {
-    constructor();
-    onSet(caller: any, handler: (value: T) => void): void;
-    onDelete(caller: any, handler: (value: T) => void): void;
-    firstByCondition(conf: (index: number, item: T) => boolean): [number, T];
-    lastByCondition(conf: (index: number, item: T) => boolean): [number, T];
-    forEach(handler: (index: number, item: T, iterator: ListIterator) => void): ListIterator;
-    /**
-     * 移除符合条件的项, 从后往前遍历
-     * @param cond 可以使用【iterator】中断遍历
-     * @param removedList 设置后，可获得被移除的项
-     */
-    removeByCondition(cond: (index: number, val: T, iterator: ListIterator) => boolean, removedList?: List): this;
-    /**
-     * 查找符合条件的项保存到【target】对象中，并返回【target】对象
-     * @param cond 可以使用【iterator】中断遍历
-     * @param target 存到目标对象中
-     */
-    findByCondition(cond: (index: number, val: T, iterator: ListIterator) => boolean, target: List): this;
-    pop(): T;
-    shift(): T;
-    first(): T;
-    last(): T;
-    removeAt(index: number): void;
-    remove(item: T): void;
+declare class ListSource extends EventManager {
     /**
-     * 把【other】的项合并到自身
-     * @param other
+     * 通过数组创建 ListSource。ListSource的id自动生成。如果需要指定编号，可设置 idCreator
+     * @param arr
+     * @param idCreator
      */
-    removeList(other: List<T>): void;
-    sort(compareFn?: (a: T, b: T) => number): void;
-    reverse(): void;
-    clear(): void;
+    static createByArray(arr: any[], idCreator?: (item: any) => string): ListSource;
+    static createByListItem(arr: IListItem[], target?: ListSource): any;
     /**
-     * 克隆自身所有项到【target】对象，并返回【target】对象
-     * @param target
+     * 设置数据时触发
+     * dispatchParams = {node:ListNode}
      */
-    clone(target: this): this;
-    get length(): number;
-    insertAt(index: number, ...item: T[]): void;
+    static EVENT_ADD: string;
     /**
-     * @param beforeItem
-     * @param item
+     * 设置数据时触发
+     * dispatchParams = {node:ListNode, index:number}
      */
-    insertBefore(beforeItem: T, ...item: T[]): void;
+    static EVENT_REMOVE: string;
     /**
-     * @param afterItem
-     * @param item
+     * 设置数据时触发
      */
-    insertAfter(afterItem: T, ...item: T[]): void;
-    at(index: number): T;
-    set(index: number, item: T): void;
-    indexOf(item: T): number;
-    has(item: T): boolean;
-    push(item: T): void;
+    static EVENT_REMOVE_ALL: string;
     /**
-     * 把【other】的项合并到自身
-     * @param other
+     * 刷新数据节点
+     * dispatchParams = {node:ListNode}
      */
-    pushList(other: List<T>): void;
-    getData(): T[];
-    resetData(val: T[]): void;
+    static EVENT_REFRESH: string;
     /**
-     * 随机获取【count】个项，并返回【target】对象
-     * @param count
-     * @param enableRepeat 允许重复
-     * @param target
+     * 设置数据时触发
+     * dispatchParams = nodes: [ListNode], indexs: [number]
      */
-    random(count: number, enableRepeat?: boolean, target?: List<T>): List<T>;
-    protected callPush(value: any): void;
-    protected callRemove(value: any): void;
-    protected _data: any[];
-    private _onSet;
-    private _onDelete;
-    private _onSetCaller;
-    private _onDeleteCaller;
-}
-
-/**
- * 事件字符串分隔符
- */
-
-/**
- * 回调列表
- */
-declare class CallbackList<PARAMS = any> {
-    constructor();
-    addListener(listener: Listener): void;
-    removeListener(listener: Listener): void;
+    static EVENT_SWAP: string;
     /**
+     * 设置数据时触发
+     * dispatchParams = {node:ListNode, data:any}
      */
-    create(): Listener<PARAMS>;
+    static EVENT_DATA_SET: string;
     /**
-     * 如果监听器已经不存在，则创建
-     * @param ident
+     * 设置数据时触发
+     * dispatchParams = {node:ListNode, tag:string, value:any}
      */
-    createByIdent(ident: any): Listener<PARAMS>;
-    removeByIdent(ident: any): void;
-    removeByCaller(caller: any): void;
-    getByIdent(ident: any): Listener;
+    static EVENT_TAGS_SET: string;
+    protected _identFunc: (node: ListNode) => boolean;
+    at(index: number): ListNode;
+    first(): ListNode;
+    last(): ListNode;
+    length(): number;
     /**
-     * 派发事件
-     * @param params 事件参数
-     * @param subIdent
+     * 添加项，无法添加相同的项
+     * @param node
+     * @param enableDispatch 默认为true
      */
-    dispatch(params?: PARAMS, subIdent?: string): void;
-    protected _data: List<Listener<any>>;
-    protected _indexIdent: {};
-}
-
-declare class Listener<PARAMS = any> {
-    static create(ident?: string): Listener<any>;
-    constructor(ident?: string);
-    getCaller(): any;
-    setCaller(caller: any): this;
-    setSubIdent(val: string): this;
-    setCondition(condition: (listener: Listener<PARAMS>) => boolean): this;
-    setHandler(handler: (listener: Listener<PARAMS>) => void): this;
-    setOnParams(val: any): this;
-    getIdent(): string;
-    on(): this;
-    off(): this;
-    isOn(): boolean;
-    remove(): void;
+    add(node: ListNode, enableDispatch?: boolean): void;
+    getById(id: string): ListNode;
+    remove(node: ListNode): void;
+    removeAll(): void;
+    swap(a: ListNode, b: ListNode): void;
+    contains(node: ListNode): boolean;
+    containsById(id: string): boolean;
+    indexOf(node: ListNode): number;
+    indexOfById(id: string): number;
+    setData(node: ListNode, data: any): void;
+    setNodeTags(node: ListNode, tag: string, value: any): void;
     /**
-     * 内部使用
-     * @param params
-     * @param subIdent 子编号
+     * 派发 refresh 消息
+     * @param node
      */
-    _dispatch(params: PARAMS, subIdent?: string): void;
-    getOnParams(): any;
-    getParams(): PARAMS;
-    protected onParams: any;
-    protected params: PARAMS;
-    protected ident: string;
-    protected _subIdent: string;
-    protected source: CallbackList;
-    protected _handler: (any: any) => void;
-    protected _condition: (any: any) => boolean;
-    protected caller: any;
-    protected _isOn: boolean;
+    refresh(node: ListNode): void;
+    walk(f: (node: ListNode) => boolean): boolean;
+    walkPrev(node: ListNode, f: (node: ListNode) => boolean): boolean;
+    get data(): any[];
+    private _data;
 }
 
 declare class DictIterator {
@@ -1478,2358 +912,534 @@ declare class Dictionary<K = string, V = any> {
     private _onDeleteCaller;
 }
 
-/**
- * 事件字符串分隔符
- */
-
-/**
- * 事件派发器
- */
-declare class Dispatcher implements ISchedulable {
-    constructor(name?: string);
-    dispose(): void;
-    create(type: string, listener: Listener): void;
-    remove(type: string, listener: Listener): void;
-    getByIdent(type: string, ident: string): Listener;
-    /**
-     * @param type
-     * @param ident
-     */
-    createByIdent(type: string, ident: string): Listener;
+declare class DictNode {
+    static create(id: string, data?: any): DictNode;
+    constructor();
+    uuid: string;
+    id: string;
+    data: any;
+    tags: {};
+    getTags(): {
+        [key: string]: any;
+    };
+    getTag(name: string): any;
+    setTag(name: string, value: any): void;
     /**
-     * 派发事件
-     * @param eventType 事件类型
-     * @param params 事件参数
+     * 清理【data】和【tags】
      */
-    dispatch(eventType: string, params?: any): void;
-    protected getList(type: string): CallbackList;
-    id?: string;
-    uuid?: string;
-    name: string;
-    protected isDispose: boolean;
-    protected typeToList: Dictionary<string, CallbackList<any>>;
+    clean(): void;
 }
-
-interface ITriggerEvent extends ISchedulable {
-    /**
-     *
-     * @param val
-     */
-    callback(val: (event: this) => void): this;
-    /**
-     * 执行触发器
-     */
-    execute(): any;
-    /**
-     * 允许触发器
-     */
-    enable(): any;
-    /**
-     * 禁止触发器
-     */
-    disable(): any;
-    /**
-     * 重置触发器
-     */
-    reset(): any;
+declare class DictSource extends Dictionary<string, DictNode> {
     /**
-     * 释放触发器
+     * 刷新数据节点
+     * dispatchParams = {node:ListNode}
      */
-    dispose(): any;
+    static EVENT_REFRESH: string;
     /**
-     * 设置触发后，下一帧再执行
-     * @param val
+     * 设置数据时触发
+     * dispatchParams = {node:ListNode, tag:string, value:any}
      */
-    setCallLater(val: boolean): this;
-}
-
-/**
- * 触发器
- */
-declare class TriggerEvent implements ITriggerEvent {
-    id?: string;
-    uuid?: string;
-    protected _enable: boolean;
-    protected _callback: Function;
-    protected _args: any | Function;
-    protected _ident: string;
-    protected _condition: Function;
-    private _isNextFrame;
-    constructor();
-    reset(): void;
-    setCondition(val: (event: this) => boolean): this;
-    /**
-     * 可通过ident直接控制触发器
-     */
-    setIdent(ident?: string): this;
-    /**
-     * 设置触发后，下一帧再执行
-     * @param val
-     */
-    setCallLater(val: boolean): this;
-    /**
-     * @param val
-     */
-    callback(val: (event: this) => void): this;
-    execute(): void;
-    enable(): void;
-    disable(): void;
-    dispose(): void;
-    /**
-     * 用于异步函数, 等待事件
-     */
-    wait(): Promise<ITriggerEvent>;
+    static EVENT_TAGS_SET: string;
+    setNodeTags(node: DictNode, tag: string, value: any): void;
+    refreshNode(node: DictNode): void;
+    get dispatcher(): EventManager;
+    protected _dispatcher: EventManager;
 }
 
-/**
- * 事件触发器
- * 注意: 列表项中监听全局的事件容易导致所有项都进行了监听.
- */
-
-/**
- * 触发器-监听框架的事件
- */
-declare class FrameEvent extends TriggerEvent {
-    dispatcher: IEventManager;
-    eventName: string;
-    static create(dispatcher: IEventManager, eventName: string): FrameEvent;
-    /**
-     * 数据发生变化时使用，默认参数为 集合的编号
-     * 可通过 event.dispatchParams 获取发生变化的配置
-     */
-    static MAP_CHANGE: string;
-    /**
-     *
-     */
-    static DATA_CHANGE: string;
-    /**
-     *
-     */
-    static CHANGED: string;
-    /**
-     * 派发的事件;
-     */
-    event: XEvent;
-    constructor(dispatcher: IEventManager, eventName: string);
-    enable(): void;
-    protected handler(event: XEvent): void;
-    disable(): void;
-    dispose(): void;
+declare class ListIterator {
+    break(): void;
+    isBreak(): boolean;
+    protected _isBreak: any;
 }
-
-/**
- * 用于扩展
- */
-
-declare class Trigger {
+declare class List<T = any> {
+    constructor();
+    onSet(caller: any, handler: (value: T) => void): void;
+    onDelete(caller: any, handler: (value: T) => void): void;
+    firstByCondition(conf: (index: number, item: T) => boolean): [number, T];
+    lastByCondition(conf: (index: number, item: T) => boolean): [number, T];
+    forEach(handler: (index: number, item: T, iterator: ListIterator) => void): ListIterator;
     /**
-     *
-     * @param group 设置所在组，通常为当前界面的uuid
-     * @param ident 默认为不用设置，如果需要对触发器进行操作，可指定ident
+     * 移除符合条件的项, 从后往前遍历
+     * @param cond 可以使用【iterator】中断遍历
+     * @param removedList 设置后，可获得被移除的项
      */
-    constructor(group: string, ident?: any);
-    enable(): void;
-    disable(): void;
-    destroy(): void;
+    removeByCondition(cond: (index: number, val: T, iterator: ListIterator) => boolean, removedList?: List): this;
     /**
-     * 把当前的行为转化为异步，等待当前行为结束
+     * 查找符合条件的项保存到【target】对象中，并返回【target】对象
+     * @param cond 可以使用【iterator】中断遍历
+     * @param target 存到目标对象中
      */
-    waitAction(): void;
+    findByCondition(cond: (index: number, val: T, iterator: ListIterator) => boolean, target: List): this;
+    pop(): T;
+    shift(): T;
+    first(): T;
+    last(): T;
+    removeAt(index: number): void;
+    remove(item: T): void;
     /**
-     * 当前行为结束，执行下一个行为
+     * 把【other】的项合并到自身
+     * @param other
      */
-    nextAction(): void;
-    protected setIdent(ident: any): this;
-    getTimer(): Timer;
-    when(val: ITriggerEvent): this;
-    protected callback(event: ITriggerEvent): void;
-    protected _when(val: ITriggerEvent, callback: (event: ITriggerEvent) => void): this;
-    action(val: (trigger: Trigger) => void | Promise<any>): this;
-    once(): this;
-    protected _isOnce: boolean;
-    protected executeNextAction(): void;
+    removeList(other: List<T>): void;
+    sort(compareFn?: (a: T, b: T) => number): void;
+    reverse(): void;
+    clear(): void;
     /**
-     * 完成时, 执行的方法
-     * @param f
+     * 克隆自身所有项到【target】对象，并返回【target】对象
+     * @param target
      */
-    onComplete(f: (action: this) => any): this;
-    complete(...args: any[]): void;
-    protected callOnComplete(...args: any[]): void;
-    get lastEvent(): ITriggerEvent;
-    get group(): string;
-    get ident(): string;
-    protected _disposed: boolean;
-    private _ident;
-    protected _events: ITriggerEvent[];
-    protected _actions: (Function | Promise<any>)[];
-    protected _actionExectuingIndex: number;
-    protected _actionWaiting: boolean;
-    protected _actionExecuting: any;
-    protected _onCompleteHandler: Function;
-    protected _runing: boolean;
-    private _lastEvent;
-    private _group;
-    protected _nodeEvent: FrameEvent;
-    id?: string;
-    uuid?: string;
-}
-
-declare class TriggerManager extends EventManager {
-    triggers: Trigger[];
-    constructor();
-    enable(group: string, ident: any): void;
-    disable(group: string, ident: any): void;
-    remove(group: string, ident: any): void;
-    removeTrigger(trigger: Trigger): void;
-    removeGroup(name: string): void;
-    removeAll(): void;
+    clone(target: this): this;
+    get length(): number;
+    insertAt(index: number, ...item: T[]): void;
     /**
-     * 当节点[node]销毁时，移除触发器组[destroyGroup]
-     * @param node
-     * @param destroyGroup
+     * @param beforeItem
+     * @param item
      */
-    removeOnNodeDestroyed(node: Node, destroyGroup: string): void;
-    register(trigger: Trigger): void;
-    getById(group: string, ident: any): Trigger;
-}
-declare const triggermgr: TriggerManager;
-
-/**
- * 触发器-定时器
- */
-declare class TimerEvent extends TriggerEvent {
-    protected _updateAtStart: boolean;
-    protected _count: number;
-    protected _countLimit: number;
-    protected _internal: number;
-    protected _handler: Function;
+    insertBefore(beforeItem: T, ...item: T[]): void;
     /**
-     *
-     * @param _internal 默认为帧频
+     * @param afterItem
+     * @param item
      */
-    constructor(_internal?: number);
-    dispose(): void;
+    insertAfter(afterItem: T, ...item: T[]): void;
+    at(index: number): T;
+    set(index: number, item: T): void;
+    indexOf(item: T): number;
+    has(item: T): boolean;
+    push(item: T): void;
     /**
-     * 设置次数
-     * @param val
+     * 把【other】的项合并到自身
+     * @param other
      */
-    setCount(val: number): TimerEvent;
+    pushList(other: List<T>): void;
+    getData(): T[];
+    resetData(val: T[]): void;
     /**
-     * 开始的时候是否执行一次update
-     * @param updateAtStart
+     * 随机获取【count】个项，并返回【target】对象
+     * @param count
+     * @param enableRepeat 允许重复
+     * @param target
      */
-    setUpdateAtStart(updateAtStart?: boolean): TimerEvent;
-    enable(): this;
-    disable(): void;
-    protected onTimerLoop(): void;
+    random(count: number, enableRepeat?: boolean, target?: List<T>): List<T>;
+    protected callPush(value: any): void;
+    protected callRemove(value: any): void;
+    protected _data: any[];
+    private _onSet;
+    private _onDelete;
+    private _onSetCaller;
+    private _onDeleteCaller;
 }
 
-/**
- * 点击目标区域后触发事件
- */
-declare class ClickEvent extends TriggerEvent {
-    get target(): Node;
-    static create(target: Node, rangeOut?: boolean): ClickEvent;
-    get position(): Vec2;
-    private _target;
-    protected _openTime: number;
-    protected _rangeOut: boolean;
-    private _position;
-    private _isButton;
+declare class UIObjectDict extends Dictionary<string, any | List> {
     /**
-     *
-     * @param target
-     * @param rangeOut 点击除去目标的区域时触发
+     * 获取唯一的
+     * @param prefab
      */
-    constructor(target: Node, rangeOut?: boolean);
-    enable(): void;
-    disable(): void;
-    dispose(): void;
-    onTarget(): void;
-    offTarget(): void;
-    onCanvas(): void;
-    offCanvas(): void;
-    protected onTargetDestroyedHandler(): void;
-    protected _parentChanged(): void;
-    protected onCanvasTouchEndHandler(evt: EventTouch): void;
-    protected onCanvasMouseDownHandler(evt: EventMouse): void;
-    protected hitTest(loc: Vec2): void;
-    protected onMouseDownHandler(e: EventMouse): void;
-    protected onMouseUpHandler(e: EventMouse): void;
-    protected onTouchStartHandler(e: EventTouch): void;
-    protected onTouchEndHandler(e: EventTouch): void;
-    protected setLastEventMouse(e: EventMouse): void;
-    get lastEventMouse(): EventMouse;
-    protected _lastEventMouse: EventMouse;
-    protected setLastEventTouch(e: EventTouch): void;
-    get lastEventTouch(): EventTouch;
-    protected _lastEventTouch: EventTouch;
-    get lastLocation(): Vec2;
-    protected _lastLocation: Vec2;
-    protected _downTarget: any;
-    get lastTarget(): Node;
-    protected _lastTarget: Node;
-    get canvas(): Node;
-    private _canvas;
-}
-
-/**
- * 事件触发器
- * 注意: 列表项中监听全局的事件容易导致所有项都进行了监听.
- */
-
-/**
- * 触发器-事件派发器
- */
-declare class NodeEvent extends TriggerEvent {
-    dispatcher: Node;
-    event: string;
-    static create(dispatcher: Node, event: string): NodeEvent;
-    args: any[];
-    constructor(dispatcher: Node, event: string);
-    enable(): void;
-    protected onHandler(...args: any): void;
-    disable(): void;
-    dispose(): void;
-    protected onTargetDestroyedHandler(): void;
+    uniqueObject(prefab: Prefab): Node;
+    removeObject(prefab: Prefab): void;
+    popObject(prefab: Prefab): any;
+    backObject(object: Node): void;
+    protected getList(key: any): List;
 }
+declare var uidict: UIObjectDict;
 
-/**
- * 触发器-缓存中的数据属性
- */
-declare class CacheObjectEvent extends TriggerEvent {
+declare class ViewController extends Component {
+    constructor(name: string);
+    open(...args: any[]): void;
+    close(): void;
+    get objectDict(): UIObjectDict;
+    protected _objectDict: UIObjectDict;
 }
-
-/**
- * 触发器-缓存中的数据痛
- */
-declare class ResponseEvent extends TriggerEvent {
-    static create(msgName: string, sub?: ResponseSub): ResponseEvent;
-    sub: ResponseSub;
-    msgName: string;
-    constructor(msgName: string, sub?: ResponseSub);
-    protected get listener(): IEventManager;
-    enable(): void;
-    disable(): void;
-    dispose(): void;
-    protected onHandler(event: XEvent): void;
+declare class ControllerDict extends Dictionary<string, ViewController> {
+    getByName(name: string): ViewController;
+    register(controller: ViewController): void;
 }
+declare var ctrlrepo: ControllerDict;
 
-/**
- * 触发器-等待直到符合条件
- */
-declare class WaitEvent extends TriggerEvent {
-    protected _updateAtStart: boolean;
-    protected _count: number;
-    protected _countLimit: number;
-    protected _internal: number;
-    protected _handler: Function;
-    constructor(util: () => boolean, frequency?: number);
-    dispose(): void;
-    enable(): this;
-    disable(): void;
-    protected onTimerLoop(): void;
+declare class PageController extends ViewController {
+    constructor(routeName: string, config?: {
+        layer?: string;
+        tags?: string[];
+        enableHistory?: boolean;
+    });
+    protected onOpening(page: Page): void;
+    protected onOpened(page: Page): void;
+    protected onClosing(page: Page): void;
+    protected onClosed(page: Page): void;
+    protected onRefresh(page: Page): void;
+    openByRoute(route: Route): Page;
+    private openPage;
+    openComplete(page: Page): void;
+    closeByRoute(route?: Route): Page;
+    private closePage;
+    closeComplete(page: Page): void;
+    refresh(): void;
+    get layer(): string;
+    hasTags(tags: string[]): boolean;
+    setLayer(name: string): this;
+    setTags(tags: string[]): this;
+    get lastPage(): Page;
+    get route(): Route;
+    get enableHistory(): boolean;
+    protected _enableHistory: boolean;
+    protected _route: Route;
+    protected _lastPage: Page;
+    protected _tags: {};
+    protected _layer: string;
 }
 
-declare class TreeIterator {
-    break(): void;
-    isBreak(): boolean;
-    protected _isBreak: any;
-}
-interface ITreeListItem {
+declare enum PageState {
     /**
-     * 路径
+     * 关闭
      */
-    path: string;
+    Closed = 0,
     /**
-     * 自定义数据
+     * 正在打开
      */
-    data?: any;
+    Opening = 1,
     /**
-     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
+     * 已打开
      */
-    tags?: {
-        [key: string]: any;
-    };
+    Opened = 2,
     /**
-     * 是否树叶
+     * 正在关闭
      */
-    isLeaf: boolean;
+    Closeing = 3
 }
-declare class TreeNode<T = any> {
-    get root(): TreeRoot;
+declare enum PageEvent {
+    Opening = "opening",
+    Opened = "opened",
+    Closeing = "closeing",
+    Closed = "closed",
+    Stop = "stop"
+}
+declare class Page extends EventManager {
+    constructor(controller: PageController, route: Route);
     /**
-     * 根节点
+     * 等待打开完成指令
      */
-    protected _root: TreeRoot;
+    waitOpenComplete(): void;
+    waitCloseComplete(): void;
+    openComplete(): void;
+    closeComplete(): void;
+    stop(reason: LinkError): void;
     /**
-     * 编号
-     */
-    uuid: string;
-    /**
-     * 编号
-     */
-    id: string;
-    /**
-     * 自定义数据
-     */
-    data: T;
-    /**
-     * 是否树叶
-     */
-    isLeaf: boolean;
-    /**
-     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
-     */
-    tags: {
-        [key: string]: any;
-    };
-    /**
-     * 深度
-     */
-    get depth(): number;
-    private _depth;
-    /**
-     * 父节点
-     */
-    parent: TreeNode;
-    /**
-     * 子节点
-     */
-    children: TreeNode[];
-    /**
-     * 设置根
-     * @param val
-     */
-    setRoot(val: TreeRoot): void;
-    getTags(): {
-        [key: string]: any;
-    };
-    getTag(name: string): any;
-    removeTag(name: string): void;
-    setTag(name: string, value: any): void;
-    constructor(id: string, isLeaf?: boolean);
-    addChild(val: TreeNode): void;
-    getChildIndex(val: TreeNode): number;
-    insertChild(val: TreeNode, index: number): void;
-    removeChild(val: TreeNode): void;
-    removeChildren(): void;
-    get name(): string;
-    setDepth(val: number): void;
-    containsById(id: string): boolean;
-    /**
-     * 通过编号获取子节点
-     * @param id
-     */
-    getChildById(id: string): TreeNode;
-    /**
-     * 返回相邻的上一个节点
-     */
-    prevNode(): TreeNode;
-    /**
-     * 返回相邻的下一个节点
-     */
-    nextNode(): TreeNode;
-    /**
-     * 如果返回true则删除节点，包含当前节点
-     * @param f
-     */
-    walkRemove(f: (node: TreeNode) => boolean): void;
-    private _walkRemove;
-    /**
-     * 如果返回true则继续，包含当前节点
-     * @param f
-     * @param inChild
-     */
-    walk(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): void;
-    private _walk;
-    /**
-     * 从当前节点（包括）遍历父节点链，包含当前节点
-     * @param f
-     */
-    walkParent(f: (node: TreeNode) => boolean): boolean;
-    /**
-     * 从当前节点往前遍历（深度），包含当前节点
-     * @param f
-     * @param inChild
-     */
-    walkPrev(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): any;
-    private _walkPrev;
-    dump(): void;
-    /**
-     * 遍历节点，查找指定编号的节点
-     */
-    findById(id: string): TreeNode;
-    /**
-     * 如果返回true则继续
-     * @param f
-     */
-    findOne(f: (node: TreeNode) => boolean): TreeNode;
-    private _findOne;
-    /**
-     * 通过路径获取节点
-     * 格式为 /path1/path2/...
-     * 如果 path == "/"，则返回自身
-     * @param path
-     */
-    getNodeByPath(path: string): TreeNode;
-    protected getNodeByPathArr(pathArr: string[]): TreeNode;
-    getName(): string;
-    getPath(): string;
-    /**
-     * 如果返回true则继续
-     * @param f
-     */
-    find(f: (node: TreeNode) => boolean): TreeNode[];
-    private _find;
-    toRoot(): TreeRoot;
-    clone(): TreeNode;
-    protected cloneChildrenTo(node: TreeNode): void;
-    fixDepthAndRoot(depth: number, root: TreeRoot): void;
-    toString(): string;
-}
-declare class TreeRoot<NODE = any> extends EventManager {
-    /**
-     * 添加数据节点
-     * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
-     */
-    static EVENT_ADD: string;
-    /**
-     * 移除数据节点
-     * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
-     */
-    static EVENT_REMOVE: string;
-    /**
-     * 插入数据节点
-     * dispatchParams = {node:TreeNode, before:TreeNode}
-     */
-    static EVENT_INSERT: string;
-    /**
-     * 刷新数据节点
-     * dispatchParams = {node:TreeNode}
-     */
-    static EVENT_REFRESH: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:TreeNode}
-     */
-    static EVENT_DATA_SET: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:TreeNode, tag:string, value:any}
-     */
-    static EVENT_TAGS_SET: string;
-    static create(): TreeRoot<any>;
-    /**
-     * 通过列表生成一个树结构
-     * @param items
-     * @param existed 列表将添加的已经存在的树结构
-     */
-    static createByList(items: ITreeListItem[], existed?: TreeRoot): TreeRoot;
-    static sortChildrenByName(node: TreeNode, des?: boolean): void;
-    constructor();
-    setNodeData(node: TreeNode, data: any): void;
-    setNodeTags(node: TreeNode, tag: string, value: any, force?: boolean): void;
-    getNodeByPath(path: string): TreeNode;
-    makeNodeByPath(path: string): TreeNode;
-    /**
-     * 添加节点，按照 node.path 添加到正确的位置
-     * @param node
-     * @param parentPath 如果父节点路径为 "", 则添加到起源节点
-     * @param autoCreateParent 如果父节点不存在，自动创建
-     */
-    addNode(node: TreeNode, parentPath?: string, autoCreateParent?: boolean): void;
-    removeNode(node: TreeNode): void;
-    removeChildren(node: TreeNode): void;
-    insertNode(node: TreeNode, before: TreeNode, resetId?: boolean): void;
-    walk(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): void;
-    walkPrev(f: (node: TreeNode) => boolean, inChild?: (node: TreeNode) => boolean): void;
-    /**
-     * 派发 refresh 消息
-     * @param node
-     */
-    refresh(node: TreeNode): void;
-    /**
-     * 克隆当前的树结
-     * * 新的tags克隆旧的data
-     * * 新的data指向旧的data
+     * 等待发送的结果
+     * 如果返回 null，表示主动取消 [cancel]
      */
-    clone(): TreeRoot;
+    wait(): Promise<this>;
     toString(): string;
-    createNode(id: string, isLeaf?: boolean): TreeNode;
-    /**
-     * origin的第一个child
-     */
-    get firstNode(): TreeNode;
-    origin: TreeNode;
-}
-declare class TreeRootPlugin {
-    root: TreeRoot;
-}
-declare class TreeNodePlugin {
-    node: TreeNode;
-}
-
-interface IListItem {
-    /**
-     * 编号
-     */
-    id: string;
-    /**
-     * 自定义数据
-     */
-    data?: any;
-    /**
-     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
-     */
-    tags?: {
-        [key: string]: any;
-    };
-}
-declare class ListNode {
-    static create(id: string, data?: any): ListNode;
-    constructor();
-    root: ListSource;
-    uuid: string;
-    id: string;
-    data: any;
-    tags: {};
-    getTags(): {
-        [key: string]: any;
-    };
-    setTags(tags: {
-        [key: string]: any;
-    }): void;
-    getTag(name: string): any;
-    setTag(name: string, value: any): void;
-}
-declare class ListSource extends EventManager {
-    /**
-     * 通过数组创建 ListSource。ListSource的id自动生成。如果需要指定编号，可设置 idCreator
-     * @param arr
-     * @param idCreator
-     */
-    static createByArray(arr: any[], idCreator?: (item: any) => string): ListSource;
-    static createByListItem(arr: IListItem[], target?: ListSource): any;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:ListNode}
-     */
-    static EVENT_ADD: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:ListNode, index:number}
-     */
-    static EVENT_REMOVE: string;
-    /**
-     * 设置数据时触发
-     */
-    static EVENT_REMOVE_ALL: string;
-    /**
-     * 刷新数据节点
-     * dispatchParams = {node:ListNode}
-     */
-    static EVENT_REFRESH: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = nodes: [ListNode], indexs: [number]
-     */
-    static EVENT_SWAP: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:ListNode, data:any}
-     */
-    static EVENT_DATA_SET: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:ListNode, tag:string, value:any}
-     */
-    static EVENT_TAGS_SET: string;
-    protected _identFunc: (node: ListNode) => boolean;
-    at(index: number): ListNode;
-    first(): ListNode;
-    last(): ListNode;
-    length(): number;
-    /**
-     * 添加项，无法添加相同的项
-     * @param node
-     * @param enableDispatch 默认为true
-     */
-    add(node: ListNode, enableDispatch?: boolean): void;
-    getById(id: string): ListNode;
-    remove(node: ListNode): void;
-    removeAll(): void;
-    swap(a: ListNode, b: ListNode): void;
-    contains(node: ListNode): boolean;
-    containsById(id: string): boolean;
-    indexOf(node: ListNode): number;
-    indexOfById(id: string): number;
-    setData(node: ListNode, data: any): void;
-    setNodeTags(node: ListNode, tag: string, value: any): void;
-    /**
-     * 派发 refresh 消息
-     * @param node
-     */
-    refresh(node: ListNode): void;
-    walk(f: (node: ListNode) => boolean): boolean;
-    walkPrev(node: ListNode, f: (node: ListNode) => boolean): boolean;
-    get data(): any[];
-    private _data;
-}
-
-declare class DictNode {
-    static create(id: string, data?: any): DictNode;
-    constructor();
-    uuid: string;
-    id: string;
-    data: any;
-    tags: {};
-    getTags(): {
-        [key: string]: any;
-    };
-    getTag(name: string): any;
-    setTag(name: string, value: any): void;
-    /**
-     * 清理【data】和【tags】
-     */
-    clean(): void;
-}
-declare class DictSource extends Dictionary<string, DictNode> {
-    /**
-     * 刷新数据节点
-     * dispatchParams = {node:ListNode}
-     */
-    static EVENT_REFRESH: string;
-    /**
-     * 设置数据时触发
-     * dispatchParams = {node:ListNode, tag:string, value:any}
-     */
-    static EVENT_TAGS_SET: string;
-    setNodeTags(node: DictNode, tag: string, value: any): void;
-    refreshNode(node: DictNode): void;
-    get dispatcher(): EventManager;
-    protected _dispatcher: EventManager;
-}
-
-interface IDecl {
-    Name: string;
-    Namespace: string;
-    Tags: any;
-    Alias: string;
-}
-declare class EnumDecl implements IDecl {
-    Name: string;
-    Kind: Kind;
-    Value: string;
-    Fields: Field[];
-    constructor(Name?: string, Kind?: Kind, Value?: string, Fields?: Field[]);
-    firstValue(): number;
-    NameToValue(name: string): any;
-    ValueToName(value: any): string;
-    GetAllField(): Field[];
-    Alias: string;
-    Namespace: string;
-    Tags: any;
-    Comments: string[];
-}
-declare class ClassDecl implements IDecl {
-    Name: string;
-    Parent: string;
-    Fields: Field[];
-    constructor(Name?: string, Parent?: string, Fields?: Field[], tags?: any);
-    getIdent(): string;
-    get Alias(): string;
-    getParent(): ClassDecl;
-    getField(name: string): Field;
-    walkField(handler: (field: Field) => void): void;
-    protected _lastObject: any;
-    /**
-     * @param f
-     * @param sourceObject
-     */
-    walkFieldType(f: (field: Field, type: IType, obj?: {} | undefined, value?: any) => void, sourceObject?: any): void;
-    protected _walkFieldType(f: (field: Field, type: IType, obj?: {} | undefined, value?: any) => void, sourceObject: any): void;
-    Namespace: string;
-    Tags: any;
-    Comments: string[];
-}
-
-declare class Field {
-    Name: string;
-    Type: IType;
-    Value: string;
-    Tags: any;
-    /**
-     * 如果Type=ClassType, 可通过设置{}建立新对象, 否则默认为nil
-     * 如果Type=MapType, 可通过设置{}建立新对象, 否则默认为nil
-     * 如果Type=BasicType/EnumType, Value为初始值
-     * Value: string = "";
-     * @param Name
-     * @param Type
-     * @param Value
-     * @param Tags
-     */
-    constructor(Name?: string, Type?: IType, Value?: string, Tags?: any);
-    getTag(name: string): string;
-    convertToJsonValue(dataValue: any): any;
-    /**
-     * 默认值
-     * 获取转化后的Field.Value
-     */
-    getValue(): any;
-    /**
-     *
-     */
-    getValueBasicKind(): Kind;
-    Comments: string[];
-    decl: IDecl;
-}
-
-interface IType {
-    name: TypeName;
-}
-declare enum TypeName {
-    /**
-     * {_type:TypeName.Class, Decl:"类型声明的编号"}
-     */
-    Class = "class",
-    Func = "func",
-    /**
-     * {_type: TypeName.Map, Key: {_type:TypeName.Basic,Kind: Kind.String}, Value:{_type:TypeName.Basic,Kind: Kind.String}}
-     */
-    Map = "map",
-    /**
-     * {_type:TypeName.Enum, Decl:"枚举声明的编号"}
-     */
-    Enum = "enum",
-    /**
-     * {_type: TypeName.Array, Elem: {_type:TypeName.Basic,Kind: Kind.String}}
-     */
-    Array = "array",
-    /**
-     * {_type:TypeName.Basic,Kind: Kind.String}
-     */
-    Basic = "basic",
-    Any = "any"
-}
-declare class MapType {
-    Key: IType;
-    Value: IType;
-    name: TypeName;
-    constructor(Key?: IType, Value?: IType);
-}
-declare class ClassType {
-    Decl: string;
-    name: TypeName;
-    constructor(Decl?: string);
-}
-declare class EnumType {
-    Decl: string;
-    name: TypeName;
-    constructor(Decl?: string);
-}
-declare class ArrayType {
-    Elem: IType;
-    name: TypeName;
-    constructor(Elem?: IType);
-}
-declare class BasicType {
-    Kind: Kind;
-    name: TypeName;
-    constructor(Kind?: Kind);
-}
-declare class AnyType {
-    name: TypeName;
-    constructor();
-}
-declare enum Kind {
-    Invalid = 0,
-    Bool = 1,
-    Int8 = 2,
-    Int16 = 3,
-    Int32 = 4,
-    Int64 = 5,
-    Uint8 = 6,
-    Uint16 = 7,
-    Uint32 = 8,
-    Uint64 = 9,
-    Float32 = 10,
-    Float64 = 11,
-    String = 12,
-    Bytes = 13
-}
-
-declare function setClassCreator(key: string, creator: (data: any) => ICacheObject): void;
-declare function getClassCreator(key: string): (data: any) => ICacheObject;
-declare function newCacheObject(data: any): ICacheObject;
-declare function newObjectByType(obj: CacheObject, objectType: IType, data: any): ICacheObject;
-declare enum CacheModifyMode {
-    修正结构 = 0,
-    修正字典 = 1
-}
-declare class ModifyField {
-    modify: IModify;
-    modifyFieldOrItemType: number;
-    modifyFieldOrItemSchema: IType;
-}
-declare class CacheObject extends EventManager implements ICacheObject {
-    static EVENT_CHANGED: string;
-    private data;
-    schema: IType;
-    schemaDecl: ClassDecl;
-    schemaField: Field;
-    classId: string;
-    protected className: string;
-    private versions;
-    protected modifyUsed: boolean;
-    protected modifyMode: CacheModifyMode;
-    protected modifyFieldDict: {
-        [key: string]: ModifyField;
-    };
-    protected modifyMapOrArray: IModify;
-    protected modifyFieldOrItemType: number;
-    protected modifyFieldOrItemschema: IType;
-    protected modifyContext: any;
-    protected modifyItem0: any;
-    refSetClassId(val: string): void;
-    refSetClassName(val: string): void;
-    refClassId(): string;
-    refClassType(): string;
-    refClassName(): string;
-    /**
-     * 打开修正功能后，需要设置上下文，提供给修正函数
-     * @param modifyContext
-     */
-    refSetContext(modifyContext: any): void;
-    /**
-     * 如果元素为对象，会自动创建一个空的ICacheObject
-     * @param modify
-     */
-    refModifyMap(modify: IModify): void;
-    /**
-     * 如果字段为对象，会自动创建一个空的ICacheObject
-     * @param modify
-     * @param field
-     */
-    refModifyClass(modify: IModify, field: string): void;
-    refAnyType(): string;
-    _refGet(field: string): any;
-    refIsChanged(field: string, time: number): boolean;
-    refGetChangedFields(time: number): string[];
-    refGet(field: string): any;
-    refHas(field: string): boolean;
-    refGetUint(field: string): number;
-    refGetInt(field: string): number;
-    refGetBool(field: string): boolean;
-    refGetFloat64(field: string): number;
-    refFloat64(field: string): number;
-    refGetString(field: string): string;
-    refIsObject(field: string): boolean;
-    refGetObject(field: string): ICacheObject;
-    refNew(): this;
-    refNewIfNil(): this;
-    refIsNil(): boolean;
-    refGetArray(field: string): ICacheObject;
-    refReplace(data: {
-        [key: string]: any;
-    }): void;
-    refUpdate(data: {
-        [key: string]: any;
-    }): void;
-    refSet(field: string, val: any): void;
-    _refSet(sdata: {
-        [key: string]: any;
-    }, field: string, fieldVal: any): error;
-    protected createSchemaClass(classTyp: ClassType, fieldVal: any): ICacheObject;
-    protected createClassObject(typ: any, data: any): any;
-    protected createSchemaAny(fieldVal: any): any;
-    refRemove(field: string): void;
-    refSetNil(): this;
-    refLength(): number;
-    refFields(): string[];
-    refNewByMap(data: {
-        [key: string]: any;
-    }): void;
-    refLinkData(target: ICacheObject): void;
-    refGetData(): {
-        [key: string]: any;
-    };
-    toMap(): {
-        [key: string]: any;
-    };
-    toList(): any[];
-    toMapByField(fieldMap: {
-        [key: string]: any;
-    }): {
-        [key: string]: any;
-    };
-    _toMapByField(fieldMap: {
-        [key: string]: any;
-    }, toMap: {
-        [key: string]: any;
-    }): void;
-    refSetObject(field: string, val: ICacheObject): void;
-}
-
-declare namespace cachex {
-    function getObjectByPath(object: ICacheObject, path: string): ICacheObject;
-    function getObjectFieldByPath(object: ICacheObject, path: string): [ICacheObject, string];
-    function getFieldByPath(object: ICacheObject, path: string): any;
-    function contains(obj: ICacheObject, value: any): boolean;
-}
-
-interface IModify {
-    /**
-     * 修正是否生效
-     * @param ctx
-     * @param field
-     */
-    valid(ctx: any, field: string): boolean;
-    /**
-     * 返回修正后的值
-     * @param ctx
-     * @param field
-     * @param origin
-     * @param item0 用于数组，配置文件中，数组的第一个元素，通常作为修正的基础模版
-     */
-    value(ctx: any, field: string, origin: any, item0?: any): any;
-    /**
-     * 返回修正后的长度
-     * 用于数组类型
-     * @param ctx
-     * @param origin
-     */
-    length(ctx: any, origin: number): number;
-}
-interface ICacheObject {
-    refSetClassId(classId: string): any;
-    refSetClassName(className: string): any;
-    refClassId(): string;
-    refClassType(): string;
-    refClassName(): string;
-    refSetContext(modifyContext: any): any;
-    refModifyMap(modify: IModify): any;
-    refModifyClass(modify: IModify, field: string): any;
-    /**
-     * 当类型为any时，获取【_type】的值
-     */
-    refAnyType(): any;
-    refGet(field: string): any;
-    refGetUint(field: string): number;
-    refGetInt(field: string): number;
-    refGetFloat64(field: string): number;
-    refGetString(field: string): string;
-    refGetBool(field: string): boolean;
-    refGetObject(field: string): ICacheObject;
-    refGetArray(field: string): ICacheObject;
-    refSet(field: string, val: any): any;
-    refSetObject(field: string, val: ICacheObject): void;
-    refIsObject(field: string): boolean;
-    refHas(field: string): boolean;
-    refIsNil(): boolean;
-    refSetNil(): this;
-    refNewIfNil(): this;
-    refNew(): this;
-    /**
-     * 获取所有字段的名字列表
-     */
-    refFields(): string[];
-    refGetData(): any;
-    refLinkData(target: ICacheObject): void;
-    toMap(): any;
-    /**
-     * 如果当前对象是数组, 把数据转化成数组
-     */
-    toList(): any[];
-    toMapByField(fieldMap: any): any;
-    _toMapByField(fieldMap: {
-        [key: string]: any;
-    }, toMap: {
-        [key: string]: any;
-    }): any;
-    refLength(): number;
-    refNewByMap(data: {
-        [key: string]: any;
-    }): void;
-    refUpdate(data: {
-        [key: string]: any;
-    }): void;
-    refReplace(data: {
-        [key: string]: any;
-    }): void;
-    refRemove(field: string): void;
-}
-
-interface IDatabase {
-}
-interface IDBObject {
-    /**
-     * 返回模型的数据库对象
-     * @constructor
-     */
-    DBObject(): ICacheObject;
-    DBPath(): string;
-}
-interface IDBOnCreate {
-    /**
-     * 当创建完成后
-     */
-    DBOnCreate(): any;
-}
-interface IDBOnUpdate {
-    /**
-     * 当创建完成后
-     */
-    DBOnUpdate(): any;
-}
-interface IDBOnRemove {
-    /**
-     * 当创建完成后
-     */
-    DBOnRemove(): any;
-}
-interface IDBTable {
-    DBCreate(ident: any, data: any): IDBObject;
-    DBGet(key: string): IDBObject;
-    DBSet(key: string, val: IDBObject): any;
-    DBDelete(key: string): any;
-}
-/**
- * event.OnParams的类型
- */
-interface IDBEventDispatchParams {
-    action: DBAction;
-    object: IDBObject;
-    table: IDBTable;
-    /**
-     * 输入的数据
-     */
-    data: any;
-}
-declare enum DBAction {
-    Create = 0,
-    Update = 1,
-    Remove = 2,
-    /**
-     * 主动触发刷新的时间
-     */
-    Refresh = 3
-}
-
-/**
- * 触发器-缓存中的数据集合
- */
-declare class DBEvent extends TriggerEvent {
-    static create(objectId: string): DBEvent;
-    constructor(objectId: string);
-    enable(): void;
-    disable(): void;
-    dispose(): void;
-    protected onHandler(event: XEvent): void;
-    event: string;
-    eventParams: IDBEventDispatchParams;
-}
-
-declare class ControllerSet {
-    constructor(mod: IModule);
-    has(name: string): boolean;
-    add(controller: IController): void;
-    createAndEnable(name: string, ...args: any[]): void;
-    create(name: string, ...args: any[]): void;
-    remove(name: string): void;
-    disable(name: string): void;
-    enable(name: string): void;
-    enableAll(): void;
-    disableAll(): void;
-    dispose(): void;
-    registerCreator(name: string, creator: (...args: any[]) => IController): void;
-    protected _creator: {};
-    protected _mod: IModule;
-    private data;
-}
-
-/**
- * 一个简单的功能/库模块
- */
-interface IModuleSample {
-}
-interface IModule {
-    controllers: ControllerSet;
-}
-declare class Module extends EventManager implements IModule {
-    constructor();
-    get controllers(): ControllerSet;
-    private _controllers;
-}
-
-interface IController {
-    get name(): string;
-    get module(): IModule;
-    init(core: IModule): any;
-    enable(): any;
-    disable(): any;
-    dispose(): any;
-}
-declare class Controller {
-    constructor(name: string);
-    init(core: IModule): void;
-    enable(): void;
-    disable(): void;
-    dispose(): void;
-    get name(): string;
-    get module(): IModule;
-    get isEnable(): boolean;
-    protected _module: IModule;
-    protected _name: string;
-    protected _enabled: boolean;
-}
-
-interface IModel {
-    get module(): IModule;
-}
-declare class SimpleModel {
-    constructor(mod: IModule);
-    get core(): IModule;
-    protected _mod: any;
-}
-declare class Model extends EventManager {
-    constructor(core?: IModule);
-    get module(): IModule;
-    protected _module: any;
-}
-
-interface IExtend {
-    get module(): IModule;
-}
-
-declare class Factory {
-    _controllers: {
-        [key: string]: (mod: IModule) => IController;
-    };
-    _extends: {
-        [key: string]: (mod: IModule, ...args: any) => IExtend;
-    };
-    registerController(name: string, creator: (mod: IModule, ...args: any) => IController): void;
-    registerExtend(name: string, creator: (mod: IModule, ...args: any) => IExtend): void;
-    createController(name: string, mod: IModule): IController;
-    createExtend(name: string, mod: IModule, ...args: any[]): IExtend;
-}
-
-/**
- * 视图的路由值, 保存视图的信息
- * 规则: path/search
- * path = /a/b/c
- * search = ?key=val&key=val
- */
-declare class Route {
-    constructor(route: string);
-    recycle(): void;
-    /**
-     * 获取调用链
-     * 例如 a/b/c，返回 a/b/c -> a/b -> a
-     */
-    getLink(): Route[];
-    protected static data: any;
-    static getData(route: string): Route;
-    toLoaction(): Location;
-    /**
-     * @constructor
-     */
-    NewRoute(): Route;
-    /**
-     * @constructor
-     */
-    NewRoutePath(): Route;
-    /**
-     * 新建一个带参数的路由
-     * @param params
-     */
-    NewRouteParam(params: any): Route;
-    toString(): string;
-    get path(): string;
-    get parentPath(): string;
-    get params(): any;
-    get search(): string;
-    set search(value: string);
-    get name(): string;
-    /**
-     * path/search
-     */
-    get key(): string;
-    private _path;
-    private _parentPath;
-    private _search;
-    private _name;
-    private _params;
-    protected _route: string;
-}
-
-declare class UIObjectDict extends Dictionary<string, any | List> {
-    /**
-     * 获取唯一的
-     * @param prefab
-     */
-    uniqueObject(prefab: Prefab): Node;
-    removeObject(prefab: Prefab): void;
-    popObject(prefab: Prefab): any;
-    backObject(object: Node): void;
-    protected getList(key: any): List;
-}
-declare var uidict: UIObjectDict;
-
-declare class ViewController extends Component {
-    constructor(name: string);
-    open(...args: any[]): void;
-    close(): void;
-    get objectDict(): UIObjectDict;
-    protected _objectDict: UIObjectDict;
-}
-declare class ControllerDict extends Dictionary<string, ViewController> {
-    getByName(name: string): ViewController;
-    register(controller: ViewController): void;
-}
-declare var ctrlrepo: ControllerDict;
-
-declare class PageController extends ViewController {
-    constructor(routeName: string, config?: {
-        layer?: string;
-        tags?: string[];
-        enableHistory?: boolean;
-    });
-    protected onOpening(page: Page): void;
-    protected onOpened(page: Page): void;
-    protected onClosing(page: Page): void;
-    protected onClosed(page: Page): void;
-    protected onRefresh(page: Page): void;
-    openByRoute(route: Route): Page;
-    private openPage;
-    openComplete(page: Page): void;
-    closeByRoute(route?: Route): Page;
-    private closePage;
-    closeComplete(page: Page): void;
-    refresh(): void;
-    get layer(): string;
-    hasTags(tags: string[]): boolean;
-    setLayer(name: string): this;
-    setTags(tags: string[]): this;
-    get lastPage(): Page;
-    get route(): Route;
-    get enableHistory(): boolean;
-    protected _enableHistory: boolean;
-    protected _route: Route;
-    protected _lastPage: Page;
-    protected _tags: {};
-    protected _layer: string;
-}
-
-declare enum PageState {
-    /**
-     * 关闭
-     */
-    Closed = 0,
-    /**
-     * 正在打开
-     */
-    Opening = 1,
-    /**
-     * 已打开
-     */
-    Opened = 2,
-    /**
-     * 正在关闭
-     */
-    Closeing = 3
-}
-declare enum PageEvent {
-    Opening = "opening",
-    Opened = "opened",
-    Closeing = "closeing",
-    Closed = "closed",
-    Stop = "stop"
-}
-declare class Page extends EventManager {
-    constructor(controller: PageController, route: Route);
-    /**
-     * 等待打开完成指令
-     */
-    waitOpenComplete(): void;
-    waitCloseComplete(): void;
-    openComplete(): void;
-    closeComplete(): void;
-    stop(reason: LinkError): void;
-    /**
-     * 等待发送的结果
-     * 如果返回 null，表示主动取消 [cancel]
-     */
-    wait(): Promise<this>;
-    toString(): string;
-    get objectDict(): UIObjectDict;
-    protected _objectDict: UIObjectDict;
-    protected _waitOpenComplete: boolean;
-    protected _waitCloseComplete: boolean;
-    get controller(): PageController;
-    get route(): Route;
-    cache: {};
-    tags: {};
-    layer: string;
-    state: PageState;
-    protected _controller: PageController;
-    protected _route: Route;
-}
-
-/**
- * 视图管理器
- * 打开一个视图的时候，可能会听过加载资源，读取数据，调整布局，切换特效等处理，所以使用视图模式封装视图打开关闭的逻辑
- */
-declare class PageLayer {
-    name: string;
-    constructor(name: string);
-    close(): void;
-    /**
-     * 当前的页面
-     */
-    currentPage: Page;
-}
-
-declare class PageList extends List<Page> {
-}
-declare class PageRepo extends PageList {
-    constructor();
-    openByString(route: string): Page;
-    /**
-     * 打开页面
-     * 一个路由代表一个页面
-     * @param route
-     */
-    open(route: Route): Page;
-    close(route: Route): void;
-    /**
-     * 如果页面存在，则刷新
-     * @param route
-     */
-    refresh(route: Route): void;
-    /**
-     * 历史记录
-     */
-    getHistory(): Route[];
-    back(): void;
-    getByRoute(route: Route): Page;
-    listByTags(tags: string[]): PageList;
-    getLayerMain(): PageLayer;
-    /**
-     * @param name
-     */
-    getLayer(name: string): PageLayer;
-    protected getOrNewLayer(name: string): PageLayer;
-    getController(route: Route): PageController;
-    get objectDict(): UIObjectDict;
-    protected _objectDict: UIObjectDict;
-    protected _indexLayer: {};
-    protected _indexRoute: {};
-    protected _history: Route[];
-}
-declare const pagerepo: PageRepo;
-
-interface ISchemaTreeNode extends TreeNode {
-    tags: {
-        /**
-         * Field.Name
-         */
-        title: string;
-        /**
-         * 可获取节点对应的 Field
-         */
-        field: Field;
-        /**
-         * 可获取节点对应的 IType
-         */
-        schema: IType;
-        /**
-         * 当类型为ClassType时，标识是否为null
-         */
-        isNull: boolean;
-        /**
-         * 标识是否为默认值
-         */
-        isDefault: boolean;
-    };
-    /**
-     * 当 Field 的类型为 BasicType 时，设置成传入对象对应的值
-     * 否则为 null
-     */
-    data: any;
-}
-declare class SchemaTreeRootCreator {
-    static default: SchemaTreeRootCreator;
-    constructor();
-    createByType(root: TreeRoot, type: IType, id: string, object: any, title?: string, defaultValue?: any): TreeNode;
-    updateByType(node: TreeNode, value: any): void;
-    /**
-     * 通过类的约束和类的map值，生成用于对象编辑器的树对象
-     * @param decl
-     * @param object
-     *
-     * @see ISchemaTreeNode
-     */
-    createByClassDecl(decl: ClassDecl, object: any): TreeRoot;
-    /**
-     * 通过类的约束和类的map值，生成用于对象编辑器的树对象
-     * @param decl
-     *
-     * @see ISchemaTreeNode
-     */
-    createByEnumDecl(decl: EnumDecl): TreeRoot;
-    createNode(type: IType | ClassDecl | EnumDecl, id: string): TreeNode;
-    createOriginByClassDecl(root: TreeRoot, decl: ClassDecl, object: any): TreeNode;
-    createOriginByEnumDecl(root: TreeRoot, decl: EnumDecl, object: any): TreeNode;
-    protected createChildrenByEnumDecl(node: TreeNode, decl: EnumDecl, object: any): void;
-    protected createChildrenByClassDecl(node: TreeNode, decl: ClassDecl, object: any): void;
-    protected createChildByField(node: TreeNode, field: Field, object: any): void;
-    protected createChildByMapType(root: TreeRoot, type: MapType, id: string, object: {
-        [key: string]: any;
-    }, title: string): TreeNode;
-    protected createChildByMapType_Child(node: TreeNode, root: TreeRoot, type: IType, id: string, object: any, title: string): TreeNode;
-    protected createChildByArrayType(root: TreeRoot, type: ArrayType, id: string, object: any[], title: string): TreeNode;
-    protected createChildByClassType(root: TreeRoot, type: ClassType, id: string, value: any, title: string): TreeNode;
-    protected createChildByAnyType(root: TreeRoot, type: AnyType, id: string, value: any, title: string): TreeNode;
-    protected updateAnyType(node: TreeNode, value: any): void;
-    protected createByEnumType(root: TreeRoot, type: EnumType, id: string, value: any, title: string, defaultValue: any): TreeNode;
-    /**
-     * @param root
-     * @param type
-     * @param id
-     * @param value
-     * @param title
-     * @param defaultValue
-     * @param ident
-     * @param keepOrigin 保持 value 的值
-     * @protected
-     */
-    protected createByBasicType(root: TreeRoot, type: BasicType, id: string, value: any, title: string, defaultValue: any, ident?: string, keepOrigin?: boolean): TreeNode;
-    /**
-     * 表示是否检查约束声明中的 [hide] 标签
-     */
-    disableHide(): this;
-    disableAutoValue(): this;
-    replaceField(classDecl: string, fieldName: string, handler: (decl: ClassDecl, object: any, field: Field) => Field): this;
-    protected _checkHide: boolean;
-    protected _autoValue: boolean;
-    protected _replaceField: {};
-}
-
-declare class SchemaValueToJson {
-    field: Field;
-    constructor(field: Field);
-    toJson(treeValue: any): any;
-    _toJson(type: IType, value: any, field?: Field): any;
-    private toObject_ClassType;
-    private toObject_MapType;
-    private toObject_ArrayType;
-    private toObject_BasicType;
-    private toObject_ClassDecl;
-}
-
-declare class SchemaNodeToValue {
-    node: TreeNode;
-    constructor(node: TreeNode);
-    toValue(): any;
-    _toValue(node: TreeNode): any;
-    private toObject_ClassType;
-    private toObject_MapType;
-    private toObject_ArrayType;
-    private toObject_AnyType;
-    private toObject_BasicType;
-    private toObject_ClassDecl;
-    /**
-     * 动态关联的对象转化成字符串
-     */
-    setDlinkObjectToString(): this;
-    /**
-     * 设置移除默认的字段
-     */
-    setRemoveFieldDefault(): this;
-    protected _dlinkObjectToString: boolean;
-    protected _removeFieldDefault: boolean;
-}
-
-interface ISchemaType {
-    name: string;
-    matchType?: IType;
-    /**
-     * 值转换成字符串用于显示
-     * @param configSet
-     * @param data
-     * @param typeValue
-     */
-    valueToText: (dataNode: TreeNode, field: Field, typeValue: string) => string;
-    /**
-     * 转换成识别号
-     */
-    valueToIdent: Function;
-    /**
-     * 编辑器中使用的预设体
-     */
-    valueToPrefab?: (dataNode: TreeNode, field: Field, typeValue: string) => Prefab;
-}
-declare class SchemaManager extends EventManager {
-    registerExtendType(typ: ISchemaType): void;
-    getExtendTypeByField(field: Field): ISchemaType;
-    /**
-     * 通过约束树的节点获取该节点定义的扩展类型
-     * 如果是 map/array 的子节点，则返回 map和array 中定义的扩展类型
-     * @param node tags = {field:Field, schema:IType}
-     */
-    getExtendTypeByNode(node: TreeNode): ISchemaType;
-    getExtendType(typ: string): ISchemaType;
-    protected _typeExtendMap: {
-        [key: string]: ISchemaType;
-    };
-    /**
-     * 通过约束树的节点获取该节点定义的字段信息
-     * 如果是 map/array 的子节点，则返回 map和array 的字段信息
-     * @param node
-     */
-    getFieldByNode(node: TreeNode): Field;
-    createByType(root: TreeRoot, type: IType, id: string, object: any, title?: string, defaultValue?: any): TreeNode;
-    getDataNodeFieldTags(dataTyp: IType | Field, parentTyp: IType): any;
-    /**
-     * 获取节点schema中，所在Field的Tags。
-     * @param dataNode
-     */
-    getFieldTags(dataNode: TreeNode): {
-        [key: string]: string;
-    };
-}
-declare var schemamgr: SchemaManager;
-
-/**
- * 解码反射值的接口
- */
-interface IRefValue {
-    refType(): string;
-}
-declare class MapDecoder {
-    constructor();
-    decodeSet(m: {
-        [key: string]: any;
-    }): any;
-    decodeMap(m: {
-        [key: string]: any;
-    }): any;
-    decodeObj(obj: IRefValue, m: any): void;
-    protected parseObj(obj: any, m: any, desc: ClassDecl): void;
-    protected parseMap(omap: any, mmap: any, typ: MapType): any;
-    protected parseSlice(oarr: any, marr: any, typ: ArrayType): any;
-    protected parseAny(oval: any, mval: any, typ: AnyType): any;
-    protected parseClass(oval: any, mval: any, typ: ClassType): any;
-    protected parseEnum(oval: any, mval: any, typ: EnumType): any;
-    protected parseBasic(oval: any, mval: any, typ: BasicType): any;
-}
-
-declare class ByteDecoder {
-    decodeObj(obj: any, reader: ByteArray, desc: ClassDecl): void;
-    protected parseMap(omap: any, reader: ByteArray, typ: MapType, value: string): any;
-    protected parseSlice(oarr: any, reader: ByteArray, typ: ArrayType): any;
-    protected parseAny(oval: any, reader: ByteArray, typ: AnyType, value: string): any;
-    protected parseClass(oval: any, reader: ByteArray, typ: ClassType, value: string): any;
-    protected parseEnum(reader: ByteArray, typ: EnumType): any;
-    protected parseBasic(reader: ByteArray, typ: BasicType): any;
-    protected parseKind(reader: ByteArray, kind: Kind): any;
-}
-
-declare class SimpleModify {
-    ctx: any;
-    constructor(ctx: any);
-    setValue(key: string, valueOrCreator: any | Function): void;
-    protected _data: any[];
-    getValue(key: string): any;
-}
-
-type CreatorFunction = (...args: any[]) => {};
-/**
- * 回收的方法
- * 使用回收方法的原因是，某些对象没有recycle函数，由不方便实现recycle函数
- */
-type RecycleFunction = (item: any, ...args: any[]) => void;
-/**
- * 释放的方法
- */
-type DisposeFunction = (item: any, ...args: any[]) => void;
-/**
- * 对象池
- */
-declare class Pool {
-    creatorFunction: CreatorFunction;
-    recycleFunction: RecycleFunction;
-    disposeFunction: DisposeFunction;
-    name: string;
-    list: any[];
-    constructor();
-    /**
-     * 获取一个对象
-     */
-    getObject(...args: any[]): any;
-    /**
-     * 回收一个对象
-     * @param obj
-     */
-    recycleObject(obj: any): void;
-    /**
-     * 释放一个对象
-     * @param obj
-     */
-    disposeObject(obj: any): void;
-    /**
-     * 释放对象池
-     */
-    dispose(): void;
-}
-declare class PoolSet {
-    pools: {
-        [key: string]: Pool;
-    };
-    constructor();
-    register(poolName: string, creator: CreatorFunction, recycle?: RecycleFunction, dispose?: DisposeFunction): Pool;
-    getOrCreatePool(poolName: any): Pool;
-    getPool(poolName: any): Pool;
-    disposePool(poolName: string): void;
-    dispose(): void;
-}
-/**
- * 对象池
- */
-declare class SamplePool {
-    list: any[];
-    constructor();
-    /**
-     * 获取一个对象
-     */
-    get(): any;
-    /**
-     * 回收一个对象
-     * @param obj
-     */
-    put(obj: any): void;
-}
-/**
- * 对象池
- */
-declare class SamplePoolSet {
-    get(name: string): any;
-    put(name: string, item: any): void;
-    protected pools: {};
-}
-
-declare class CallbackItem {
-    listener: Function;
-    caller: any;
-    once: boolean;
-}
-declare class SampleCallbackList {
-    constructor();
-    dispose(): void;
-    has(caller: any, listener: Function): boolean;
-    protected getItem(caller: any, listener: Function): CallbackItem;
-    /**
-     * 监听事件，如果监听已经存在则返回
-     * @param caller
-     * @param listener 为了性能考虑， event使用了对象池处理。因此处理函数不应该保存event的引用。如有需要，可通过新建对象或Event.Clone()实现
-     */
-    on(caller: any, listener: (ctx: this, params?: any) => void): CallbackItem;
-    once(caller: any, listener: (ctx: this, params?: any) => void): CallbackItem;
-    protected offItem(item: CallbackItem): void;
-    off(caller: any, listener: Function): void;
-    offAll(type?: string): void;
-    offAllCaller(caller: any): void;
-    /**
-     * 派发事件
-     * @param params 事件参数
-     */
-    dispatch(params?: any): void;
-    protected _callbackItems: CallbackItem[];
-}
-
-declare enum DataValueType {
-    Class = 0,
-    Array = 1,
-    String = 2,
-    Number = 3,
-    Boolean = 4
-}
-declare class DataValue extends SampleCallbackList {
-    constructor(path: string, type: DataValueType);
-    enableLocalStorage(): this;
-    get(): any;
-    set(value: any): void;
-    load(): void;
-    save(value: any): void;
-    refresh(): void;
-    get path(): string;
-    get type(): DataValueType;
-    protected _enableLocalStorage: boolean;
-    protected _path: string;
-    protected _type: DataValueType;
-    protected _data: any;
-}
-
-declare class DataDispatchParams {
-    action: DBAction;
-    object: {};
-    table: IDBTable;
-    /**
-     *  DBAction.Update时为变化的数据
-     *  DBAction.Create时为创建的数据
-     */
-    data: any;
-}
-/**
- * tablePath 对象id@表id, 如果未设置表id，则默认为 "@alone"
- * propPath /prop1/prop2...
- */
-declare class DataManager extends EventManager implements IDatabase {
-    /**
-     * 输入 [表id][对象id] 返回 [表id, 对象id]
-     * @param tablePath
-     * @private
-     */
-    static $parseKey(tablePath: string): [string, string];
-    constructor();
-    init(): void;
-    registerTable(name: string, table: IDBTable): IDBTable;
-    /**
-     * 可通过 Laya.ClassUtils.regClass("database.table.tableId") 替换默认的 DataBucket
-     * @param name
-     */
-    getTable(name: string): IDBTable;
-    /**
-     * 创建表对象
-     * 需要设置表
-     * @param tablePath
-     * @param data
-     */
-    createObject<T = IDBObject>(tablePath: string, data: any): T;
-    updateObject(obj: IDBObject, data: {
-        [key: string]: any;
-    }): void;
-    /**
-     * 更新对象
-     * @param tablePath
-     * @param data 发生变化的数据
-     */
-    updateByPath(tablePath: string, data: any): void;
-    /**
-     * 移除对象
-     * @param tablePath
-     */
-    removeObject(tablePath: string): void;
-    /**
-     * 获取对象
-     * 如果设置了tableId，会保存包对应的表中
-     * @param tablePath =“tableId/objectId” or objectId
-     */
-    getObject(tablePath: string): IDBObject;
-    getOrCreateObject(tablePath: string): IDBObject;
-    /**
-     * 获取属性的值
-     * @param tablePath
-     * @param propPath
-     */
-    getObjectProp(tablePath: string, propPath?: string): any;
-    setObjectProp(tablePath: string, propPath?: string, data?: any, enableDispatch?: boolean): void;
-    LSKeys(): LSKeys;
-    LSLoadOrSaveObject(tablePath: string, data: any): void;
-    /**
-     * 从localStorage中加载数据并初始化，如果是table，则添加到table中
-     * @param objectPath
-     * @return 路径指向的对象，如果不存在则创建。如果未注册，抛出异常
-     * @return localStorage是否存在数目
-     */
-    LSLoadObject<T = IDBObject>(objectPath: string): T;
-    LSRemoveObject(tablePath: string): void;
-    LSSaveObject(tablePath: string): void;
-    LSLoadProp(tablePath: string, propPath: string, handler?: (data: any) => any): void;
-    LSSaveProp(tablePath: string, propPath: string): void;
-    getDataValue(path: string): DataValue;
-    existDataValue(path: string, creator: (path: string) => DataValue): DataValue;
-    setDataValue(dataObject: DataValue): void;
-    saveObject(path: string, object: any): void;
-    loadObject(path: string, target: any): any;
-    saveAny(key: string, val: any): void;
-    loadAny(key: string): any;
-    protected object: {};
-    private tables;
-}
-declare class LSKeys extends List<string> {
-    add(key: string): void;
-    dictByTable(tableName: string): List<string>;
-    protected indexTable: {
-        [key: string]: List<string>;
-    };
-}
-
-declare var datamgr: DataManager;
-
-declare class IDataTableConfig {
-    /**
-     * 名字
-     */
-    name: string;
-}
-declare class DataTableConfig {
-    /**
-     * 名字
-     */
-    name: string;
-    /**
-     * 数据对象的方法
-     */
-    objectCreator?: (ident: any, data: any) => IDBObject;
-    /**
-     * 数据集的类
-     */
-    mapCreator?: () => IDBTable;
-    constructor({ name, objectCreator, mapCreator }: DataTableConfig);
-}
-/**
- * 独立类型的配置表
- */
-declare class DataTableAloneConfig {
-    /**
-     * 名字
-     */
-    name: string;
-    /**
-     * 指定项的配置，用于独立模式，通常名字为alone
-     */
-    items: {
-        [key: string]: DataTableItemConfig;
-    };
-    constructor({ name, items }: DataTableAloneConfig);
-}
-interface DataTableItemConfig {
-    /**
-     * 数据对象的方法
-     */
-    objectCreator: (ident: any, data: any) => IDBObject;
-}
-
-declare class Config {
-    static createByJSONMap(编号: string, conf: IConfigInfo): Config;
-    static create(编号: string, 类型: string, 分类: string): Config;
-    /**
-     * 命名空间/类型
-     */
-    get类型标识(): string;
-    calculate最终数据(): {};
-    /**
-     * 配置保存的数据
-     */
-    get 数据(): any;
-    get 编辑器名称(): string;
-    get 父对象(): Config;
-    克隆(): Config;
-    /**
-     * 设置数据
-     * @param path /p1/p2/key
-     * @param value
-     */
-    setData(path: string, value: any): void;
-    removeData(path: string): void;
-    getSchema(): ClassDecl;
-    get类型(): string;
-    /**
-     * 转化成存储到文件的map对象的值
-     */
-    toSaveObj(r: any): any;
-    /**
-     * 转化成存储到文件的map对象的值
-     */
-    toSaveFileValue(): any;
-    /**
-     * 转化成存储到文件的map对象 {编号:toSaveFileValue()}
-     */
-    toSaveFileObject(): any;
-    已变化的属性路径: {
-        [key: string]: boolean;
-    };
-    发生错误的属性路径: {
-        [key: string]: boolean;
-    };
-    编辑器字体颜色(属性路径: string): Color;
-    更新发生错误(path: string): void;
-    protected 更新已更新(path: string): void;
-    刷新已变化的属性路径(): void;
-    刷新发生错误的属性路径(): void;
-    protected 刷新发生错误的属性路径_class_decl(decl: ClassDecl, obj: any, path: string): void;
-    井号to分类编号(val: string): string;
-    分类编号to井号(val: string): string;
-    /**
-     * 由类型和类型编号组成
-     * 格式为：分类编号@分类
-     */
-    编号: string;
-    /**
-     * 父配置的编号
-     */
-    父编号: string;
-    原始数据: any;
-    最终数据: any;
-    /**
-     * 私有的文件，只在文件内部可以发现
-     * 0-文件内可见， 1-目录内可见， 2-全局可见
-     */
-    导出的: number;
-    /**
-     * 配置所在的文件路径
-     */
-    文件: string;
-    /**
-     * 配置的分类
-     * 例如单位，技能，掉落
-     */
-    分类: string;
-    /**
-     * 分类编号
-     */
-    分类编号: string;
-    /**
-     * 配置的对象类型
-     * 例如技能-攻击，技能-移动，技能-效果
-     */
-    类型: string;
-    命名空间: string;
-    /**
-     * 编辑器使用的名称
-     */
-    名称: string;
-    /**
-     * 编辑器的数据
-     */
-    编辑器数据: any;
-    编辑器前缀: string;
-    编辑器后缀: string;
-    /**
-     * 用于记录当前配置是由哪个模版创建而成
-     */
-    编辑器模版: string;
-    /**
-     * 用于生成树结构
-     */
-    编辑器路径: string;
-    classDecl: ClassDecl;
-    /**
-     * 默认的配置
-     */
-    默认的: boolean;
-    /**
-     * 在自己的分类的名称是唯一的
-     */
-    唯一的: boolean;
-    /**
-     * 用于避免误操作
-     */
-    禁止删除: boolean;
-    /**
-     * 用于避免误操作
-     */
-    禁止编辑: boolean;
-}
-
-declare enum ConfigSetEventSub {
-    Add = "add",
-    DELETE = "delete",
-    UPDATE = "item_update1"
-}
-interface IConfigInfo {
-    _type: string;
-    _catalog: string;
-    _parent: string;
-    _export: string;
-    _default: string;
-    _prefix: string;
-    _suffix: string;
-    _name: string;
-    _file: string;
-}
-declare class ConfigSetEvent {
-    sub: ConfigSetEventSub;
-    config: Config;
-    constructor(sub: ConfigSetEventSub, config: Config);
-}
-declare class ConfigSet extends EventManager {
-    /**
-     * dispatchParams = {config:Config}
-     */
-    static EVENT_ADD: string;
-    /**
-     * dispatchParams = {config:Config}
-     */
-    static EVENT_DELETE: string;
-    /**
-     * dispatchParams = {config:Config}
-     */
-    static EVENT_UPDATE: string;
-    protected _data: Config[];
-    protected _indexTree: TreeRoot;
-    get data(): Config[];
-    constructor();
-    /**
-     * 加载发布后的文件
-     * @param contentObject
-     */
-    loadPublish(configMap: {
-        [key: string]: any;
-    }): void;
-    get indexTree(): TreeRoot;
-    loadByFile(file: string, contentObject: any): void;
-    loadByFileMap(files: any): void;
-    removeAll(): void;
-    /**
-     * 把源对象的数据复制到目标对象
-     * @param source
-     * @param target
-     * @param decl
-     */
-    copyObj(source: any, target: any, decl: ClassDecl): void;
-    查找_通过编号(编号: string): Config;
-    查找_通过文件(文件: string): ConfigSet;
-    查找_通过类型(类型: string): ConfigSet;
-    查找_通过分类(分类: string): ConfigSet;
-    获取所有分类(指定文件?: string): string[];
-    获取所有类型(指定文件?: string): string[];
-    获取所有文件(): string[];
-    生成类树(): TreeRoot;
-    protected getItemParentLink(item: Config): string;
-    /**
-     *
-     * @param 当前文件 优先显示当前文件的内容
-     */
-    生成类型树(当前文件?: string, 默认优先?: boolean): TreeRoot;
-    /**
-     * 由于树结构使用 "/" 来分隔，为避免冲突，把文件的 "/" 全替换成 $
-     */
-    生成分类树(使用分类?: boolean, 使用文件?: boolean): TreeRoot;
-    /**
-     * 按指定属性进行分类
-     * @param 指定属性
-     */
-    生成属性树(指定属性: string): TreeRoot;
-    /**
-     *
-     * @param value
-     * @param existed
-     */
-    合并(value: ConfigSet, existed?: ConfigSet): ConfigSet;
-    创建配置_通过父配置(父配置编号: string, 编号: string, 选项: {
-        数据?: any;
-        信息?: IConfigInfo;
-        继承复制的对象?: boolean;
-    }): Config;
+    get objectDict(): UIObjectDict;
+    protected _objectDict: UIObjectDict;
+    protected _waitOpenComplete: boolean;
+    protected _waitCloseComplete: boolean;
+    get controller(): PageController;
+    get route(): Route;
+    cache: {};
+    tags: {};
+    layer: string;
+    state: PageState;
+    protected _controller: PageController;
+    protected _route: Route;
+}
+
+/**
+ * 视图管理器
+ * 打开一个视图的时候，可能会听过加载资源，读取数据，调整布局，切换特效等处理，所以使用视图模式封装视图打开关闭的逻辑
+ */
+declare class PageLayer {
+    name: string;
+    constructor(name: string);
+    close(): void;
     /**
-     * @param 配置
-     * @param enableDispatch
-     * @see ConfigSet.EVENT_ADD
+     * 当前的页面
      */
-    添加配置(配置: Config, enableDispatch?: boolean): error;
-    删除配置集(set: ConfigSet, enableDispatch?: boolean): error;
+    currentPage: Page;
+}
+
+declare class PageList extends List<Page> {
+}
+declare class PageRepo extends PageList {
+    constructor();
+    openByString(route: string): Page;
     /**
-     *
-     * @param 编号
-     * @param enableDispatch
-     * @see ConfigSet.EVENT_DELETE
+     * 打开页面
+     * 一个路由代表一个页面
+     * @param route
      */
-    删除配置(编号: string, enableDispatch?: boolean): error;
+    open(route: Route): Page;
+    close(route: Route): void;
     /**
-     * 用于复制文件时使用，不触发事件，不修改缓存
-     * @param 配置
-     * @param 新编号
+     * 如果页面存在，则刷新
+     * @param route
      */
-    重置编号(配置: Config, 新编号: string): error;
-    删除_通过文件路径(路径: string): void;
-    重置文件路径(fromPath: any, toPath: any): void;
+    refresh(route: Route): void;
     /**
-     *
-     * 与setData一样, 但会派发 ConfigSet.EVENT_UPDATE
-     * @param 配置
-     * @param path
-     * @param value
+     * 历史记录
      */
-    设置配置值(配置: Config, path: string, value: any): void;
-    addItem(配置: Config): void;
-    removeItem(编号: string): any;
-    dispatchUpdateByIdent(ident: string): void;
-    dispatchUpdate(config: Config): void;
+    getHistory(): Route[];
+    back(): void;
+    getByRoute(route: Route): Page;
+    listByTags(tags: string[]): PageList;
+    getLayerMain(): PageLayer;
     /**
-     * 转换成保存到文件的对象
+     * @param name
      */
-    toSaveFileObject(): {
-        [key: string]: any;
-    };
-    toKeys(): string[];
+    getLayer(name: string): PageLayer;
+    protected getOrNewLayer(name: string): PageLayer;
+    getController(route: Route): PageController;
+    get objectDict(): UIObjectDict;
+    protected _objectDict: UIObjectDict;
+    protected _indexLayer: {};
+    protected _indexRoute: {};
+    protected _history: Route[];
 }
+declare const pagerepo: PageRepo;
 
-declare class ConfigManager {
-    _default: ConfigSet;
-    get default(): ConfigSet;
-    registerCascader(key: string, root: TreeRoot): void;
-    getCascader(path: string): TreeRoot;
-    _cascader: {
-        [key: string]: TreeRoot;
-    };
-}
-declare const configmgr: ConfigManager;
+/**
+ * 事件字符串分隔符
+ */
 
-declare class ConfigDict extends Dictionary<string, Config> {
-    getBy编号(编号: string): Config;
-    findByCondition(cond: (key: string, val: Config, iterator: DictIterator) => boolean): this;
-    getBy模版(编号: string): Config;
-    listBy文件(指定文件?: string): ConfigDict;
-    listBy目录(指定目录?: string): ConfigDict;
-    listBy分类(指定分类?: string): ConfigDict;
-    listBy类型(指定类型?: string): ConfigDict;
-    list所有分类(): string[];
-    list所有类型(): string[];
-    list所有文件(): string[];
+/**
+ * 回调列表
+ */
+declare class CallbackList<PARAMS = any> {
+    constructor();
+    addListener(listener: Listener): void;
+    removeListener(listener: Listener): void;
     /**
-     * @param 当前文件 优先显示当前文件的内容
-     * @param 默认优先
-     * @param 路径名和标题处理器 默认使用[item.编号, item.名称]
      */
-    create目录树(当前文件?: string, 默认优先?: boolean, 路径名和标题处理器?: (item: Config) => [string, string] | null): TreeRoot;
+    create(): Listener<PARAMS>;
     /**
-     * @param 当前文件 优先显示当前文件的内容
-     * @param 默认优先
-     * @param 路径名和标题处理器 默认使用[item.编号, item.名称]
+     * 如果监听器已经不存在，则创建
+     * @param ident
      */
-    create类型树(当前文件?: string, 默认优先?: boolean, 路径名和标题处理器?: (item: Config) => [string, string] | null): TreeRoot;
+    createByIdent(ident: any): Listener<PARAMS>;
+    removeByIdent(ident: any): void;
+    removeByCaller(caller: any): void;
+    getByIdent(ident: any): Listener;
     /**
-     * 由于树结构使用 "/" 来分隔，为避免冲突，把文件的 "/" 全替换成 $
+     * 派发事件
+     * @param params 事件参数
+     * @param subIdent
      */
-    create分类树(使用分类?: boolean, 使用文件?: boolean, 使用名称路径?: boolean): TreeRoot;
+    dispatch(params?: PARAMS, subIdent?: string): void;
+    protected _data: List<Listener<any>>;
+    protected _indexIdent: {};
+}
+
+declare class Listener<PARAMS = any> {
+    static create(ident?: string): Listener<any>;
+    constructor(ident?: string);
+    getCaller(): any;
+    setCaller(caller: any): this;
+    setSubIdent(val: string): this;
+    setCondition(condition: (listener: Listener<PARAMS>) => boolean): this;
+    setHandler(handler: (listener: Listener<PARAMS>) => void): this;
+    setOnParams(val: any): this;
+    getIdent(): string;
+    on(): this;
+    off(): this;
+    isOn(): boolean;
+    remove(): void;
     /**
-     * 按指定属性进行分类
-     * @param 指定属性
+     * 内部使用
+     * @param params
+     * @param subIdent 子编号
      */
-    create属性树(指定属性: string): TreeRoot;
+    _dispatch(params: PARAMS, subIdent?: string): void;
+    getOnParams(): any;
+    getParams(): PARAMS;
+    protected onParams: any;
+    protected params: PARAMS;
+    protected ident: string;
+    protected _subIdent: string;
+    protected source: CallbackList;
+    protected _handler: (any: any) => void;
+    protected _condition: (any: any) => boolean;
+    protected caller: any;
+    protected _isOn: boolean;
+}
+
+/**
+ * 事件字符串分隔符
+ */
+
+/**
+ * 事件派发器
+ */
+declare class Dispatcher implements ISchedulable {
+    constructor(name?: string);
+    dispose(): void;
+    create(type: string, listener: Listener): void;
+    remove(type: string, listener: Listener): void;
+    getByIdent(type: string, ident: string): Listener;
     /**
-     * 用于复制文件时使用，不触发事件，不修改缓存
-     * @param 配置
-     * @param 新编号
+     * @param type
+     * @param ident
      */
-    reset编号(配置: Config, 新编号: string): error;
+    createByIdent(type: string, ident: string): Listener;
     /**
-     * 转换成保存到文件的对象
+     * 派发事件
+     * @param eventType 事件类型
+     * @param params 事件参数
      */
-    to保存对象(): {
-        [key: string]: any;
-    };
+    dispatch(eventType: string, params?: any): void;
+    protected getList(type: string): CallbackList;
+    id?: string;
+    uuid?: string;
+    name: string;
+    protected isDispose: boolean;
+    protected typeToList: Dictionary<string, CallbackList<any>>;
+}
+
+declare class LoaderItem {
+    onComplete?: (err: any, asset: any) => void;
+    callHandler(err: any, asset: any): void;
+    getBundle(): AssetManager.Bundle;
+    type: string;
+    bundle: AssetManager.Bundle;
+    uri: AssetURI$1;
+    preload: boolean;
+    error: any;
+}
+/**
+ * uri格式:path, uuid://uuid, https://url
+ */
+declare class AssetLoader extends Dispatcher$1 {
     /**
-     * 重置索引树
      *
-     */
-    resetIndexTree(): TreeRoot;
-    getParentLink(item: Config): string;
+     * @param bundleName
+     * @param otherConfig preload:是预加载-否-加载, 包中的资源
+     */
+    loadBundle(bundleName: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        preload?: boolean;
+    }): this;
+    /**
+     * @param uri
+     * @param otherConfig
+     */
+    loadAtlas(uri: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        preload?: boolean;
+    }): this;
+    loadPrefab(uri: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        preload?: boolean;
+    }): this;
+    loadConfig(uri: string): this;
+    loadSpriteFrame(uri: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        uuid?: string;
+    }): this;
+    loadImageAsset(uri: string, otherConfig?: {
+        onHandler?: (err: any, asset: any) => void;
+    }): this;
+    protected _loadSpriteFrameByBundle(uri: string, bundle: AssetManager.Bundle): void;
     /**
-     * 重置索引树
-     *
+     * 等待发送的结果
+     * 如果返回 null，表示主动取消 [cancel]
      */
-    static createIndexTree(dict: ConfigDict): TreeRoot;
+    wait(): Promise<this>;
+    start(): this;
+    onComplete(val: (loader: AssetLoader) => void): this;
+    onProgress(val: (loader: AssetLoader) => void): this;
+    isComplete(): boolean;
+    protected validComplete(): void;
+    protected parseBundleToAssetsLoader(bundle: AssetManager.Bundle, loaderItem: LoaderItem): AssetLoader;
+    protected handleAtlas(item: LoaderItem, atlasAsset: Asset): void;
+    protected _loadByItem(item: LoaderItem, type: any, onComplate: (err: any, asset: any) => void): void;
+    getLoaded(): number;
+    getTotle(): number;
+    getSucceed(): number;
+    getFail(): number;
+    getFailList(): List$1<LoaderItem>;
+    protected _handleFailList(err: any, item: any): void;
+    stop(): void;
+    protected _stop: boolean;
+    protected _onCompleteHandler: Function;
+    protected _onProgressHandler: Function;
+    protected _loaded: number;
+    protected _loaderList: any;
+    protected _failList: any;
 }
-declare class ClassConfigDict extends ConfigDict {
-    constructor();
-    getBy字符串(val: string): Config;
-    getBy标识(val: string): Config;
-    protected index标识: {};
+
+declare class AssetURI {
+    name: string;
+    constructor(name: string);
+    loadType: number;
+    uuid: string;
+    path: string;
+    bundle: string;
 }
+declare class XAssetManager {
+    getAsset(uri: string): any;
+    getAssetByUUID(uuid: string): any;
+    getRoot(): AssetManager;
+}
+declare let assetx: XAssetManager;
 
-declare class ConfigRepo extends ConfigDict {
-    constructor();
-    dictBy文件(文件: string): ConfigDict;
-    dictBy分类(分类: string): ClassConfigDict;
-    dictBy类型(类型: string): ConfigDict;
-    dictBy功能(功能: string): ConfigDict;
-    get编号By字符串(val: string): string;
-    /**
-     * 格式: @分类#标识
-     * @param val
-     */
-    getBy字符串(val: string): Config;
-    /**
-     * 加载发布后的文件
-     */
-    loadPublish(configMap: {
-        [key: string]: any;
-    }): void;
-    loadByFile(file: string, contentObject: any): void;
-    protected _loadByFile(file: string, contentObject: any): void;
-    loadByFileMap(files: any): void;
-    createBy父配置(父配置编号: string, 编号: string, 选项: {
-        数据?: any;
-        信息?: IConfigInfo;
-        继承复制的对象?: boolean;
-    }): Config;
-    /**
-     * @param 配置
-     * @param enableDispatch
-     * @see ConfigSet.EVENT_ADD
-     */
-    add(配置: Config, enableDispatch?: boolean): error;
-    removeDict(dict: ConfigDict, enableDispatch?: boolean): error;
+declare function parseAtlas(name: any, plist: any, texture: any): SpriteAtlas;
+
+type CreatorFunction = (...args: any[]) => {};
+/**
+ * 回收的方法
+ * 使用回收方法的原因是，某些对象没有recycle函数，由不方便实现recycle函数
+ */
+type RecycleFunction = (item: any, ...args: any[]) => void;
+/**
+ * 释放的方法
+ */
+type DisposeFunction = (item: any, ...args: any[]) => void;
+/**
+ * 对象池
+ */
+declare class Pool {
+    creatorFunction: CreatorFunction;
+    recycleFunction: RecycleFunction;
+    disposeFunction: DisposeFunction;
+    name: string;
+    list: any[];
+    constructor(config: {
+        creatorFunction: CreatorFunction;
+        recycleFunction?: RecycleFunction;
+        disposeFunction?: DisposeFunction;
+        name?: string;
+    });
     /**
-     *
-     * @param 编号
-     * @param enableDispatch
-     * @see ConfigSet.EVENT_DELETE
+     * 获取一个对象
      */
-    remove(编号: string, enableDispatch?: boolean): error;
-    removeBy文件(路径: string): void;
-    reset文件(fromPath: any, toPath: string): void;
+    getObject(...args: any[]): any;
     /**
-     *
-     * 与setData一样, 但会派发 ConfigSet.EVENT_UPDATE
-     * @param 配置
-     * @param path
-     * @param value
+     * 回收一个对象
+     * @param obj
      */
-    set配置值(配置: Config, path: string, value: any): void;
+    recycleObject(obj: any): void;
     /**
-     * 派发更新的消息
-     * @param config
+     * 释放一个对象
+     * @param obj
      */
-    dispatchUpdateByIdent(ident: string): void;
+    disposeObject(obj: any): void;
     /**
-     * 派发更新的消息
-     * @param config
+     * 释放对象池
      */
-    dispatchUpdate(config: Config): void;
-    registerCascader(key: string, root: TreeRoot): void;
-    getCascader(path: string): TreeRoot;
-    get dispatcher(): EventManager;
-    _cascader: {
-        [key: string]: TreeRoot;
-    };
-    _dispatcher: EventManager;
-    index_文件: Dictionary<string, ConfigDict>;
-    index_分类: Dictionary<string, ClassConfigDict>;
-    index_类型: Dictionary<string, ConfigDict>;
-    index_功能: Dictionary<string, ConfigDict>;
-    index_tree: TreeRoot;
+    dispose(): void;
 }
-declare const configRepo: ConfigRepo;
-
-declare class ConfigEvent {
-    /**
-     * dispatchParams = {config:Config}
-     */
-    static EVENT_ADD: string;
+/**
+ * 对象池
+ */
+declare class SamplePool {
+    list: any[];
+    constructor();
     /**
-     * dispatchParams = {config:Config}
+     * 获取一个对象
      */
-    static EVENT_DELETE: string;
+    get(): any;
     /**
-     * dispatchParams = {config:Config}
+     * 回收一个对象
+     * @param obj
      */
-    static EVENT_UPDATE: string;
+    put(obj: any): void;
 }
 
 declare class ConvertUtil {
@@ -4242,114 +1852,5 @@ declare const pathutil: PathUtil;
 declare function parsePlist(plist: any, texture: any): SpriteAtlas;
 declare function loadAtlas(url: any, callback: any): void;
 
-declare class DebugManager {
-    constructor();
-}
-declare const debugmgr: DebugManager;
-
-declare enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    WARNING = 2,
-    ERROR = 3
-}
-declare class Logger {
-    name: string;
-    level: LogLevel;
-    ignoreRegexp: any[];
-    ignoreString: any[];
-    protected _enable: boolean;
-    disable(): void;
-    canLogByLevel(level: LogLevel): boolean;
-    canLog(msg: string, level: LogLevel): boolean;
-    debug(msg: string, ...data: any[]): void;
-    info(msg: string, ...data: any[]): void;
-    infof(msgCreator: () => string): void;
-    warning(msg: string, ...data: any[]): void;
-    error(msg: string, ...data: any[]): void;
-}
-
-declare const LOGGER_EVENT = "Event";
-declare class LogManager {
-    /**
-     * 获取事件的日志管理
-     * 日志的group为事件类型
-     */
-    getEventLogger(): Logger;
-    /**
-     * 获取日志管理
-     */
-    getLogger(name: string): Logger;
-    protected _loggers: {};
-    /**
-     * 是否开启日志
-     */
-    enable: boolean;
-    protected ignores: any[];
-    /**
-     * 忽视包含指定字符串的日志
-     * @param val
-     */
-    ignoreString(val: string): void;
-    /**
-     * 取消指定的日志
-     * @param val
-     */
-    ignoreStringCancel(val: string): void;
-    /**
-     * 是否可以输出日志
-     * @param type
-     * @private
-     */
-    canLog(type: string): boolean;
-    disableSystemConsole(): void;
-}
-declare const logmgr: LogManager;
-
-interface CommandInfo {
-    /**
-     * 默认的
-     */
-    caller?: any;
-    name: string;
-    handler: Function;
-    group?: string;
-    global: boolean;
-}
-declare class CommandManager extends EventManager {
-    protected _infos: any[];
-    register(info: CommandInfo): void;
-    execute(name: string, ...args: any): any;
-    removeGroup(group: string): void;
-}
-declare const cmdmgr: CommandManager;
-
-declare class XDate extends Date {
-    static parseString(val: string): XDate;
-    add(year?: number, month?: number, date?: number, hour?: number, minute?: number, second?: number): XDate;
-    /**
-     * 获取当月总共天数函数
-     */
-    getMonthDay(): number;
-    getQuarter(): number;
-    startOfYear(): XDate;
-    endOfYear(): XDate;
-    startOfQuarter(): XDate;
-    endOfQuarter(): XDate;
-    startOfMonth(): XDate;
-    endOfMonth(): XDate;
-    startOfWeek(): XDate;
-    endOfWeek(): XDate;
-    startOfDay(): XDate;
-    endOfDay(): XDate;
-    startOfHour(): XDate;
-    endOfHour(): XDate;
-    startOfMinute(): XDate;
-    endOfMinute(): XDate;
-    startOfSecond(): XDate;
-    endOfSecond(): XDate;
-    clone(): XDate;
-}
-
-export { ArrayUtil, BitUtil, ByteArray, ByteDecoder, CacheModifyMode, CacheObject, CacheObjectEvent, CallbackList, Caller, ClassConfigDict, ClickEvent, CommandManager, CommandProtocol, Config, ConfigDict, ConfigEvent, ConfigManager, ConfigRepo, ConfigSet, ConfigSetEvent, ConfigSetEventSub, ConnectState, Controller, ControllerDict, ControllerSet, ConvertUtil, CreateProtocol, DBAction, DBEvent, DataDispatchParams, DataManager, DataTableAloneConfig, DataTableConfig, DebugManager, DeleteProtocol, DictIterator, DictNode, DictSource, Dictionary, Dispatcher, Endian, EndianConst, ErrorUtil, EventItem, EventManager, EventProtocol, EventUtil, Factory, FloatUtil, FrameEvent, FrameWebSocket, GeometryUtil, HttpMethod, HttpRequest, HttpResponseType, IDataTableConfig, IdentUtil, LOGGER_EVENT, LSKeys, LinkError, List, ListIterator, ListNode, ListSource, Listener, LogLevel, LogManager, Logger, MapDecoder, MapUtil, MathUtil, Model, Module, NetHttp, NetIdent, NetManager, NetSocket, NetSub, NetUtil, NodeEvent, Page, PageController, PageEvent, PageLayer, PageList, PageRepo, PageState, PathUtil, Pool, PoolSet, PushProtocol, PushTag, RandUtil, RequestProtocol, ResponseEvent, ResponseProtocol, ResponseSub, Route, SamplePool, SamplePoolSet, ScaleUtil, SchemaManager, SchemaNodeToValue, SchemaTreeRootCreator, SchemaValueToJson, SerializeMode, SimpleModel, SimpleModify, StringUtil, SyncHandler, TimeUtil, TimerEvent, TreeIterator, TreeNode, TreeNodePlugin, TreeRoot, TreeRootPlugin, Trigger, TriggerEvent, TriggerManager, UIManager, UIObjectDict, UIPoolConfig, UISingleConfig, UIUtil, UpdateProtocol, ValidState, ViewController, WaitEvent, WebSocketType, XDate, XEvent, arrayutil, bitutil, cachex, cmdmgr, configRepo, configmgr, convertutil, ctrlrepo, datamgr, debugmgr, errorutil, eventmgr, eventutil, floatutil, formatutil, geoutil, getClassCreator, identutil, loadAtlas, logmgr, maputil, mathutil, netmgr, netutil, newCacheObject, newObjectByType, pagerepo, parseData, parsePlist, pathutil, randutil, receiveData, resutil, scaleutil, schemamgr, setClassCreator, stringutil, timer, timeutil, triggermgr, uidict, uimgr, uiutil };
-export type { CommandInfo, CreatorFunction, DataTableItemConfig, DisposeFunction, ICacheObject, IConfigInfo, IController, IDBEventDispatchParams, IDBObject, IDBOnCreate, IDBOnRemove, IDBOnUpdate, IDBTable, IDatabase, IEventManager, IExtend, IListItem, IModel, IModify, IModule, IModuleSample, IRefValue, ISchemaTreeNode, ISchemaType, ITreeListItem, ITriggerEvent, RecycleFunction, error };
+export { ArrayUtil, AssetLoader, AssetURI, BitUtil, CallbackList, Controller, ControllerDict, ControllerSet, ConvertUtil, DictIterator, DictNode, DictSource, Dictionary, Dispatcher, ErrorUtil, EventItem, EventManager, EventUtil, Factory, FloatUtil, GeometryUtil, IdentUtil, LinkError, List, ListIterator, ListNode, ListSource, Listener, MapUtil, MathUtil, Model, Module, NetUtil, Page, PageController, PageEvent, PageLayer, PageList, PageRepo, PageState, PathUtil, Pool, RandUtil, Route, SamplePool, ScaleUtil, SimpleModel, StringUtil, TimeUtil, Timer, TreeIterator, TreeNode, TreeNodePlugin, TreeRoot, TreeRootPlugin, UIManager, UIObjectDict, UIPoolConfig, UISingleConfig, UIUtil, ViewController, XAssetManager, XEvent, arrayutil, assetx, bitutil, convertutil, ctrlrepo, errorutil, eventmgr, eventutil, floatutil, formatutil, geoutil, identutil, loadAtlas, maputil, mathutil, netutil, pagerepo, parseAtlas, parsePlist, pathutil, randutil, resutil, scaleutil, stringutil, timeutil, uidict, uimgr, uiutil };
+export type { CreatorFunction, DisposeFunction, IController, IEventManager, IExtend, IListItem, IModel, IModule, IModuleSample, ITreeListItem, RecycleFunction, error };