@zhongguo168a/yxeditor-common 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4355 @@
+import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, ISchedulable, Node, Vec2, EventTouch, EventMouse, Prefab, Component, Color, Vec3, Vec4, AssetManager, SpriteAtlas } from 'cc';
+
+interface error {
+    isCancel(): boolean;
+    is(ident: string): boolean;
+    toString(): string;
+    has(ident: string): boolean;
+}
+/**
+ * 链式错误
+ * err1 <argA=val&argB=val>
+ */
+declare class LinkError {
+    next: LinkError;
+    ident: string;
+    args: {
+        [key: string]: any;
+    };
+    /**
+     * 判断当前错误是否 cancel 错误
+     */
+    isCancel(): boolean;
+    /**
+     * 当前的错误编号是否与指定的错误编号一致
+     * @param ident
+     */
+    is(ident: string): boolean;
+    /**
+     * 错误链中是否包含有 指定的错误编号
+     * @param ident
+     */
+    has(ident: string): boolean;
+    toString(): string;
+}
+declare class ErrorUtil {
+    parse(errString: string): LinkError;
+    create(ident: string, args?: {
+        [key: string]: any;
+    }): LinkError;
+    warp(err: LinkError, ident: any, args?: {
+        [key: string]: any;
+    }): LinkError;
+    to(err: error): LinkError;
+}
+declare const errorutil: ErrorUtil;
+
+/**
+ * 单例的UI对象
+ */
+
+interface IUIObject {
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+}
+declare class UISingleConfig {
+    /**
+     * 创建函数
+     */
+    creator: () => any;
+    /**
+     * 指定键值
+     * 可通过键值获得 ui对象
+     */
+    name: string;
+    constructor({ name, creator, }: {
+        name: string;
+        creator: () => any;
+    });
+}
+/**
+ * 单例的UI对象
+ */
+declare class UIPoolConfig {
+    /**
+     * 创建函数
+     * 对象需要实现recycle方法
+     */
+    creator: () => any;
+    /**
+     * 指定键值
+     * 可通过键值获得 ui对象
+     */
+    name: string;
+    /**
+     * 过期帧数，默认为永不过期(0)
+     */
+    expired: number;
+    constructor({ name, creator, expired, }: {
+        name: string;
+        expired?: number;
+        creator: () => any;
+    });
+}
+/**
+ * UI对象的缓存管理器，自动管理UI对象的创建和销毁
+ * 为了避免页面中的组件经常创建和销毁，可使用此对象管理
+ * 例如各种面板，背包栏等，不想每次关闭页面都重新创建对象，影响操作流畅性。在内存足够的情况下，交由 UIManager 管理。
+ * 另外可以使用UI管理器中的对象池
+ * 对于不需要管理的对象，直接在页面中创建，释放/等待垃圾回收
+ *
+ * 需要注册
+ */
+declare class UIManager {
+    /**
+     *  ui单例对象缓存数量的最大值
+     */
+    singleObjectMax: number;
+    protected singleObjs: any;
+    protected singleList: any[];
+    protected singleCounts: any;
+    protected singleConfigs: any;
+    protected pools: any;
+    protected poolConfig: any;
+    constructor();
+    /**
+     * 注册一个ui对象配置
+     * @param config
+     */
+    registerPool(config: UIPoolConfig): void;
+    /**
+     * 获取UI对象池中的一个对象
+     * @param key
+     */
+    getPoolObject(key: string): [any, error];
+    /**
+     * 返回UI到对象池中
+     * @param key
+     * @param obj
+     */
+    backPoolObject(key: string, obj: any): void;
+    /**
+     * 注册一个ui对象配置
+     * @param config
+     */
+    registerSingle(config: UISingleConfig): void;
+    /**
+     * 获取单例的UI对象
+     * 引用计数+1
+     * @param key
+     */
+    getSingle(key: string): [any, error];
+    /**
+     * 返还UI对象
+     * 引用计数-1，当引用计数等于0时，放入待清理列表
+     * @param key
+     */
+    backSingle(key: string): void;
+    private mark;
+    private unmark;
+    private clean;
+    protected addCleanList(key: string): void;
+    protected cleanObjects(): void;
+    showTips(msg: string): void;
+    alignObject(alignment: HorizontalTextAlignment, a: IUIObject, b: IUIObject, offset?: number): void;
+    alignVertObject(alignment: VerticalTextAlignment, a: IUIObject, b: IUIObject, offset?: number): void;
+}
+declare var uimgr: UIManager;
+
+declare class Timer {
+    get scheduler(): Scheduler;
+    private _scheduler;
+    constructor();
+    /**
+     * 定时执行一次。
+     * @param delay 延迟时间(单位为毫秒)。
+     * @param caller 执行域(this)。
+     * @param method 定时器回调函数。
+     */
+    once(delay: number, caller: any, method: (dt?: number) => void): void;
+    /**
+     * 定时重复执行。
+     * @param delay 间隔时间(单位毫秒)。
+     * @param caller 执行域(this)。
+     * @param method 定时器回调函数。
+     */
+    loop(delay: number, caller: any, method: (dt?: number) => void): void;
+    /**
+     * 清理定时器。
+     * @param caller 执行域(this)。
+     * @param method 定时器回调函数。
+     */
+    clear(caller: any, method: Function): void;
+    /**
+     * 清理对象身上的所有定时器。
+     * @param caller 执行域(this)。
+     */
+    clearAll(caller: any): void;
+    /**
+     * 延迟执行。
+     * @param caller 执行域(this)。
+     * @param method 定时器回调函数。
+     */
+    callLater(caller: any, method: (dt?: number) => void): void;
+    /**
+     * 暂停时钟
+     */
+    pause(caller: any): void;
+    /**
+     * 恢复时钟
+     */
+    resume(caller: any): void;
+    recycle(): void;
+    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 XEvent {
+    /**
+     *
+     */
+    dispatcher: any;
+    /**
+     * 子事件
+     */
+    sub: string;
+    /**
+     * 子事件
+     */
+    sub2: string;
+    /**
+     * 事件
+     */
+    type: string;
+    /**
+     * 监听时传递的参数
+     */
+    onParams: any;
+    /**
+     * 触发时传递的参数
+     */
+    dispatchParams: any;
+    toString(): string;
+    clone(): XEvent;
+    recycle(): void;
+    dispose(): void;
+}
+
+declare class EventItem {
+    recycle(): void;
+    dispose(): void;
+    dispatch(event: XEvent): void;
+    listener: (event: XEvent) => void;
+    caller: any;
+    /**
+     * 事件类型
+     */
+    type: string;
+    /**
+     * 子事件
+     * 如果sub == "" 或者 sub == "*", 则不需要检查sub值
+     */
+    sub: string;
+    /**
+     * 子事件2
+     * 如果sub == "" 或者 sub == "*", 则不需要检查sub值
+     */
+    sub2: string;
+    args: any;
+    once: boolean;
+}
+
+interface IEventManager {
+    has(type: string, caller: any, listener: Function): boolean;
+    /**
+     * 监听事件
+     * @param type
+     * @param caller
+     * @param listener 为了性能考虑， event使用了对象池处理。因此处理函数不应该保存event的引用。如有需要，可通过新建对象或Event.Clone()实现
+     * @param args
+     */
+    on(type: string, caller: any, listener: (event: XEvent) => void, ...args: any[]): EventItem;
+    once(type: string, caller: any, listener: Function, ...args: any[]): EventItem;
+    offItem(item: EventItem): any;
+    off(type: string, caller: any, listener: Function): void;
+    offAll(type?: string): void;
+    offAllCaller(caller: any): any;
+    /**
+     * 派发事件
+     * @param type
+     * @param params
+     */
+    dispatch(type: string, ...params: any[]): void;
+    dispose(): any;
+    pause(): any;
+    resume(): any;
+}
+
+/**
+ * 事件字符串分隔符
+ */
+
+/**
+ * 事件派发器
+ */
+declare class EventManager implements IEventManager {
+    constructor();
+    dispose(): void;
+    /**
+     * 暂停监听
+     */
+    pause(): void;
+    resume(): void;
+    protected _isPause: boolean;
+    has(type: string, caller: any, listener: Function): boolean;
+    getItem(type: string, caller: any, listener: Function): EventItem;
+    /**
+     * 监听事件，如果监听已经存在则返回
+     * @param type
+     * @param caller
+     * @param listener 为了性能考虑， event使用了对象池处理。因此处理函数不应该保存event的引用。如有需要，可通过新建对象或Event.Clone()实现
+     * @param args
+     */
+    on(type: string, caller: any, listener: (event: XEvent, dispatchParams: any) => void, args?: any): EventItem;
+    once(type: string, caller: any, listener: (event: XEvent) => void, args?: any): EventItem;
+    offItem(item: EventItem): void;
+    off(type: string, caller: any, listener: Function): void;
+    offAll(type?: string): void;
+    offAllCaller(caller: any): void;
+    /**
+     * 派发事件
+     * @param type 事件类型
+     * @param params 事件参数
+     * @param disableLog
+     */
+    dispatch(type: string, params?: any, disableLog?: boolean): void;
+    /**
+     * 派发事件
+     * @param type 事件类型.子事件.子事件2
+     * @param params 事件参数
+     * @param disableLog
+     */
+    dispatchSub(type: string, params?: any, disableLog?: boolean): void;
+    toString(): string;
+    protected getOnEventItems(type: string): EventItem[];
+    id?: string;
+    uuid?: string;
+    name: string;
+    private _onEventItems;
+    protected isDispose: boolean;
+}
+/**
+ * 全局的事件派发器
+ */
+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;
+    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;
+}
+
+interface IConn {
+    key: string;
+    token: string;
+    send(caller: Caller): any;
+    connected: boolean;
+    isValid(): boolean;
+    update(): any;
+    lastSeqResp: number;
+    lastSeqSend: number;
+    seqToCaller: {
+        [key: string]: Caller;
+    };
+}
+
+declare class SyncHandler {
+    create: (key: string, obj: any) => void;
+    update: (key: string, obj: any) => void;
+    remove: (key: string, obj: any) => void;
+}
+declare class NetManager extends EventManager {
+    init(): void;
+    /**
+     * 创建一个socket链接
+     * 可通过SendMessageCtrl.SetConn指定
+     * @param key
+     * @param addr
+     */
+    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;
+    /**
+     * 获取默认的链接
+     */
+    getDefault(): IConn;
+    /**
+     * 注册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
+     */
+    register(group: string, id: string, creator: Function): void;
+    /**
+     * 如果有全局调用的需求，可以设置group为 "global"
+     * @param id
+     * @param creator
+     */
+    registerGlobal(id: string, creator: Function): void;
+    /**
+     * 获取调用者
+     * @param group
+     * @param id
+     */
+    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;
+}
+declare var netmgr: NetManager;
+
+declare class HttpRequest {
+    constructor();
+    /**
+     * @private
+     */
+    private _xhr;
+    /**
+     *
+     */
+    timeout: number;
+    /**
+     *
+     */
+    onError: (request: HttpRequest) => void;
+    /**
+     *
+     */
+    onComplete: (request: HttpRequest) => void;
+    /**
+     *
+     */
+    onProgress: (request: HttpRequest, event: any) => void;
+    /**
+     * 出现错误时的错误信息
+     */
+    error: error;
+    /**
+     * @private
+     * 本次请求返回的数据，数据类型根据responseType设置的值确定。
+     */
+    get response(): any;
+    /**
+     * @private
+     */
+    private _responseType;
+    /**
+     * @private
+     * 设置返回的数据格式，请使用 HttpResponseType 里定义的枚举值。设置非法的值或不设置，都将使用HttpResponseType.TEXT。
+     */
+    get responseType(): HttpResponseType;
+    set responseType(value: HttpResponseType);
+    /**
+     * @private
+     */
+    private _withCredentials;
+    /**
+     * @private
+     * 表明在进行跨站(cross-site)的访问控制(Access-Control)请求时，是否使用认证信息(例如cookie或授权的header)。 默认为 false。(这个标志不会影响同站的请求)
+     */
+    get withCredentials(): boolean;
+    set withCredentials(value: boolean);
+    /**
+     * @private
+     */
+    private _url;
+    private _method;
+    /**
+     * @private
+     *
+     * @returns
+     */
+    private getXHR;
+    /**
+     * @private
+     * 初始化一个请求.注意，若在已经发出请求的对象上调用此方法，相当于立即调用abort().
+     * @param url 该请求所要访问的URL该请求所要访问的URL
+     * @param method 请求所使用的HTTP方法， 请使用 HttpMethod 定义的枚举值.
+     */
+    open(url: string, method?: HttpMethod): void;
+    /**
+     * @private
+     * 发送请求.
+     * @param data 需要发送的数据
+     */
+    send(data?: any): void;
+    /**
+     * @private
+     * 如果请求已经被发送,则立刻中止请求.
+     */
+    abort(): void;
+    /**
+     * @private
+     * 返回所有响应头信息(响应头名和值), 如果响应头还没接受,则返回"".
+     */
+    getAllResponseHeaders(): string;
+    private headerObj;
+    /**
+     * @private
+     * 给指定的HTTP请求头赋值.在这之前,您必须确认已经调用 open() 方法打开了一个url.
+     * @param header 将要被赋值的请求头名称.
+     * @param value 给指定的请求头赋的值.
+     */
+    setRequestHeader(header: string, value: string): void;
+    /**
+     * @private
+     * 返回指定的响应头的值, 如果响应头还没被接受,或该响应头不存在,则返回"".
+     * @param header 要返回的响应头名称
+     */
+    getResponseHeader(header: string): string;
+    /**
+     * @private
+     */
+    private onTimeout;
+    private callOnError;
+    private callOnProgress;
+    private callOnComplete;
+    /**
+     * @private
+     */
+    private onReadyStateChange;
+    /**
+     * @private
+     */
+    private updateProgress;
+    /**
+     * @private
+     */
+    private onload;
+    /**
+     * @private
+     */
+    private onerror;
+}
+declare class NetHttp {
+    /**
+     * 地址
+     */
+    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;
+}
+
+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 {
+    /**
+     * 以字符串格式发送和接收数据
+     */
+    static TYPE_STRING: string;
+    /**
+     * 以二进制格式发送和接收数据
+     */
+    static TYPE_BINARY: string;
+    private _writeMessage;
+    private _readMessage;
+    private _connected;
+    private _connecting;
+    private _socket;
+    private _url;
+    /**
+     * 出现错误时的错误信息
+     */
+    error: error;
+    /**
+     * 根据提供的url连接
+     * @param url 全地址。如ws://echo.websocket.org:80
+     */
+    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;
+    /**
+     * 根据提供的url连接
+     * @param url 全地址。如ws://echo.websocket.org:80
+     */
+    connect(url: string): void;
+    /**
+     * 关闭套接字
+     */
+    close(): void;
+    /**
+     * 对套接字输出缓冲区中积累的所有数据进行刷新
+     */
+    flush(): void;
+    private _isReadySend;
+    /**
+     * 将字符串数据写入套接字
+     * @param message 要写入套接字的字符串
+     */
+    writeUTF(message: string): void;
+    /**
+     * 从套接字读取一个 UTF-8 字符串
+     * @returns {string}
+     */
+    readUTF(): string;
+    private _readByte;
+    private _writeByte;
+    private _bytesWrite;
+    /**
+     * 从指定的字节数组写入一系列字节。写入操作从 offset 指定的位置开始。
+     * 如果省略了 length 参数，则默认长度 0 将导致该方法从 offset 开始写入整个缓冲区。
+     * 如果还省略了 offset 参数，则写入整个缓冲区。
+     * @param bytes 要从中读取数据的 ByteArray 对象
+     * @param offset ByteArray 对象中从零开始的偏移量，应由此开始执行数据写入
+     * @param length 要写入的字节数。默认值 0 导致从 offset 参数指定的值开始写入整个缓冲区
+
+     */
+    writeBytes(bytes: ByteArray, offset?: number, length?: number): void;
+    /**
+     * 从套接字读取 length 参数指定的数据字节数。从 offset 所表示的位置开始，将这些字节读入指定的字节数组
+     * @param bytes 要将数据读入的 ByteArray 对象
+     * @param offset 数据读取的偏移量应从该字节数组中开始
+     * @param length 要读取的字节数。默认值 0 导致读取所有可用的数据
+     */
+    readBytes(bytes: ByteArray, offset?: number, length?: number): void;
+    /**
+     * 表示此 Socket 对象目前是否已连接
+     */
+    get connected(): boolean;
+    /**
+     * @private
+     */
+    private _type;
+    /**
+     * 发送和接收数据的格式，默认是字符串格式
+     */
+    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;
+    };
+    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 {
+    id: string;
+    seq: number;
+    serialMode: number;
+    token: string;
+    data: any;
+    pack(writer: ByteArray): 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;
+    /**
+     * 把【other】的项合并到自身
+     * @param other
+     */
+    removeList(other: List<T>): void;
+    sort(compareFn?: (a: T, b: T) => number): void;
+    reverse(): void;
+    clear(): void;
+    /**
+     * 克隆自身所有项到【target】对象，并返回【target】对象
+     * @param target
+     */
+    clone(target: this): this;
+    get length(): number;
+    insertAt(index: number, ...item: T[]): void;
+    /**
+     * @param beforeItem
+     * @param item
+     */
+    insertBefore(beforeItem: T, ...item: T[]): void;
+    /**
+     * @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;
+    /**
+     * 把【other】的项合并到自身
+     * @param other
+     */
+    pushList(other: List<T>): void;
+    getData(): T[];
+    resetData(val: T[]): void;
+    /**
+     * 随机获取【count】个项，并返回【target】对象
+     * @param count
+     * @param enableRepeat 允许重复
+     * @param target
+     */
+    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;
+    /**
+     */
+    create(): Listener<PARAMS>;
+    /**
+     * 如果监听器已经不存在，则创建
+     * @param ident
+     */
+    createByIdent(ident: any): Listener<PARAMS>;
+    removeByIdent(ident: any): void;
+    removeByCaller(caller: any): void;
+    getByIdent(ident: any): Listener;
+    /**
+     * 派发事件
+     * @param params 事件参数
+     * @param subIdent
+     */
+    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 params
+     * @param subIdent 子编号
+     */
+    _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 DictIterator {
+    break(): void;
+    isBreak(): boolean;
+    protected _isBreak: any;
+}
+declare class Dictionary<K = string, V = any> {
+    constructor(data?: any);
+    reset(data: any): void;
+    protected _reset(data: any, size?: number): void;
+    getData(): any;
+    /**
+     * 如果使用了 onSet or onDelete，需要注意清理
+     */
+    clear(): void;
+    /**
+     * 克隆自身所有项到【target】对象，并返回【target】对象
+     * @param target
+     */
+    clone(target: this): this;
+    resetByDict(dict: Dictionary): void;
+    onSet(caller: any, handler: (key: K, value: V) => void): void;
+    onDelete(caller: any, handler: (key: K, value: V) => void): void;
+    /**
+     * 设置键值对，如果没有发生变化，不会触发onSet函数
+     * @param key
+     * @param value
+     */
+    set(key: K, value: V): void;
+    private setData;
+    setByMap(m: any): void;
+    addDictionary(other: Dictionary<K, V>): void;
+    deleteDictionary(other: Dictionary<K, V>): void;
+    /**
+     * 如果不存在，返回 undefined
+     * @param key
+     */
+    get(key: K): V;
+    exist(key: K): boolean;
+    delete(key: K): void;
+    private deleteData;
+    exists(key: K): boolean;
+    length(): number;
+    pop(key: K): [V, boolean];
+    isEmpty(): boolean;
+    items(): V[];
+    keys(): K[];
+    /**
+     *
+     * @param handler 可以使用【iterator】中断遍历
+     * @return iterator 获取是否中断了
+     */
+    forEach(handler: (key: K, val: V, iterator: DictIterator) => void): DictIterator;
+    /**
+     */
+    first(): V | undefined;
+    /**
+     * @param handler 返回true结束迭代
+     */
+    firstByCondition(handler: (key: K, val: V) => boolean): V | undefined;
+    /**
+     * 移除符合条件的项
+     * @param cond 可以使用【iterator】中断遍历
+     */
+    removeByCondition(cond: (key: K, val: V, iterator: DictIterator) => boolean): void;
+    /**
+     * 查找符合条件的项保存到【target】对象中，并返回【target】对象
+     * @param cond 可以使用【iterator】中断遍历
+     * @param target 存到目标对象中
+     */
+    findByCondition(cond: (key: K, val: V, iterator: DictIterator) => boolean, target: Dictionary): this;
+    groupByCondition(createKey: (key: K, val: V) => string, ITEM_CLASS?: any): {
+        [key: string]: any;
+    };
+    protected size: number;
+    private _data;
+    private _onSet;
+    private _onDelete;
+    private _onSetCaller;
+    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;
+    /**
+     * 派发事件
+     * @param eventType 事件类型
+     * @param params 事件参数
+     */
+    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>>;
+}
+
+interface ITriggerEvent extends ISchedulable {
+    /**
+     *
+     * @param val
+     */
+    callback(val: (event: this) => void): this;
+    /**
+     * 执行触发器
+     */
+    execute(): any;
+    /**
+     * 允许触发器
+     */
+    enable(): any;
+    /**
+     * 禁止触发器
+     */
+    disable(): any;
+    /**
+     * 重置触发器
+     */
+    reset(): any;
+    /**
+     * 释放触发器
+     */
+    dispose(): any;
+    /**
+     * 设置触发后，下一帧再执行
+     * @param val
+     */
+    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>;
+}
+
+/**
+ * 事件触发器
+ * 注意: 列表项中监听全局的事件容易导致所有项都进行了监听.
+ */
+
+/**
+ * 触发器-监听框架的事件
+ */
+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 Trigger {
+    /**
+     *
+     * @param group 设置所在组，通常为当前界面的uuid
+     * @param ident 默认为不用设置，如果需要对触发器进行操作，可指定ident
+     */
+    constructor(group: string, ident?: any);
+    enable(): void;
+    disable(): void;
+    destroy(): void;
+    /**
+     * 把当前的行为转化为异步，等待当前行为结束
+     */
+    waitAction(): void;
+    /**
+     * 当前行为结束，执行下一个行为
+     */
+    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;
+    /**
+     * 完成时, 执行的方法
+     * @param f
+     */
+    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;
+    /**
+     * 当节点[node]销毁时，移除触发器组[destroyGroup]
+     * @param node
+     * @param destroyGroup
+     */
+    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;
+    /**
+     *
+     * @param _internal 默认为帧频
+     */
+    constructor(_internal?: number);
+    dispose(): void;
+    /**
+     * 设置次数
+     * @param val
+     */
+    setCount(val: number): TimerEvent;
+    /**
+     * 开始的时候是否执行一次update
+     * @param updateAtStart
+     */
+    setUpdateAtStart(updateAtStart?: boolean): TimerEvent;
+    enable(): this;
+    disable(): void;
+    protected onTimerLoop(): void;
+}
+
+/**
+ * 点击目标区域后触发事件
+ */
+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;
+    /**
+     *
+     * @param target
+     * @param rangeOut 点击除去目标的区域时触发
+     */
+    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;
+}
+
+/**
+ * 触发器-缓存中的数据属性
+ */
+declare class CacheObjectEvent extends TriggerEvent {
+}
+
+/**
+ * 触发器-缓存中的数据痛
+ */
+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 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 TreeIterator {
+    break(): void;
+    isBreak(): boolean;
+    protected _isBreak: any;
+}
+interface ITreeListItem {
+    /**
+     * 路径
+     */
+    path: string;
+    /**
+     * 自定义数据
+     */
+    data?: any;
+    /**
+     * 功能性标签，用于开发组件时，记录组件的状态。例如title, icon, 显示树的组件，需要 expanded，selected标签
+     */
+    tags?: {
+        [key: string]: any;
+    };
+    /**
+     * 是否树叶
+     */
+    isLeaf: boolean;
+}
+declare class TreeNode<T = any> {
+    get root(): TreeRoot;
+    /**
+     * 根节点
+     */
+    protected _root: TreeRoot;
+    /**
+     * 编号
+     */
+    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
+     */
+    clone(): TreeRoot;
+    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;
+    /**
+     * @param 配置
+     * @param enableDispatch
+     * @see ConfigSet.EVENT_ADD
+     */
+    添加配置(配置: Config, enableDispatch?: boolean): error;
+    删除配置集(set: ConfigSet, enableDispatch?: boolean): error;
+    /**
+     *
+     * @param 编号
+     * @param enableDispatch
+     * @see ConfigSet.EVENT_DELETE
+     */
+    删除配置(编号: string, enableDispatch?: boolean): error;
+    /**
+     * 用于复制文件时使用，不触发事件，不修改缓存
+     * @param 配置
+     * @param 新编号
+     */
+    重置编号(配置: Config, 新编号: string): error;
+    删除_通过文件路径(路径: string): void;
+    重置文件路径(fromPath: any, toPath: any): 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;
+    /**
+     * 转换成保存到文件的对象
+     */
+    toSaveFileObject(): {
+        [key: string]: any;
+    };
+    toKeys(): string[];
+}
+
+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[];
+    /**
+     * @param 当前文件 优先显示当前文件的内容
+     * @param 默认优先
+     * @param 路径名和标题处理器 默认使用[item.编号, item.名称]
+     */
+    create目录树(当前文件?: string, 默认优先?: boolean, 路径名和标题处理器?: (item: Config) => [string, string] | null): TreeRoot;
+    /**
+     * @param 当前文件 优先显示当前文件的内容
+     * @param 默认优先
+     * @param 路径名和标题处理器 默认使用[item.编号, item.名称]
+     */
+    create类型树(当前文件?: string, 默认优先?: boolean, 路径名和标题处理器?: (item: Config) => [string, string] | null): TreeRoot;
+    /**
+     * 由于树结构使用 "/" 来分隔，为避免冲突，把文件的 "/" 全替换成 $
+     */
+    create分类树(使用分类?: boolean, 使用文件?: boolean, 使用名称路径?: boolean): TreeRoot;
+    /**
+     * 按指定属性进行分类
+     * @param 指定属性
+     */
+    create属性树(指定属性: string): TreeRoot;
+    /**
+     * 用于复制文件时使用，不触发事件，不修改缓存
+     * @param 配置
+     * @param 新编号
+     */
+    reset编号(配置: Config, 新编号: string): error;
+    /**
+     * 转换成保存到文件的对象
+     */
+    to保存对象(): {
+        [key: string]: any;
+    };
+    /**
+     * 重置索引树
+     *
+     */
+    resetIndexTree(): TreeRoot;
+    getParentLink(item: Config): string;
+    /**
+     * 重置索引树
+     *
+     */
+    static createIndexTree(dict: ConfigDict): TreeRoot;
+}
+declare class ClassConfigDict extends ConfigDict {
+    constructor();
+    getBy字符串(val: string): Config;
+    getBy标识(val: string): Config;
+    protected index标识: {};
+}
+
+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;
+    /**
+     *
+     * @param 编号
+     * @param enableDispatch
+     * @see ConfigSet.EVENT_DELETE
+     */
+    remove(编号: string, enableDispatch?: boolean): error;
+    removeBy文件(路径: string): void;
+    reset文件(fromPath: any, toPath: string): void;
+    /**
+     *
+     * 与setData一样, 但会派发 ConfigSet.EVENT_UPDATE
+     * @param 配置
+     * @param path
+     * @param value
+     */
+    set配置值(配置: Config, path: string, value: any): void;
+    /**
+     * 派发更新的消息
+     * @param config
+     */
+    dispatchUpdateByIdent(ident: string): 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;
+}
+declare const configRepo: ConfigRepo;
+
+declare class ConfigEvent {
+    /**
+     * dispatchParams = {config:Config}
+     */
+    static EVENT_ADD: string;
+    /**
+     * dispatchParams = {config:Config}
+     */
+    static EVENT_DELETE: string;
+    /**
+     * dispatchParams = {config:Config}
+     */
+    static EVENT_UPDATE: string;
+}
+
+declare class ConvertUtil {
+    anyToBoolean(val: any, defaultValue?: boolean): boolean;
+    anyToInt(val: any, defaultValue?: number): number;
+    anyToFloat(val: any, defaultValue?: number): number;
+    anyToString(val: any, defaultValue?: string): string;
+    /**
+     * 未定义的值转化成零值，否则返回原值
+     * @param val
+     * @param type
+     */
+    undefinedToZero(val: any, type: string): any;
+}
+declare const convertutil: ConvertUtil;
+
+declare class MapUtil {
+    /**
+     * 获取所欲的值
+     */
+    values<T = any>(m: {
+        [key: string]: T;
+    }): T[];
+    /**
+     * 获取所有的键
+     */
+    keys(m: {
+        [key: string]: any;
+    }): string[];
+    /**
+     * 以字符串数字作为键值的map，转化成数组
+     */
+    toList<T = any>(m: {
+        [key: string]: T;
+    }): T[];
+    /**
+     * 以字符串数字作为键值的map，转化成数组
+     */
+    listToMap(list: any[]): any;
+    /**
+     * 转换成数字, 如果原值无效, 返回0
+     * @constructor
+     */
+    has(m: any, key: string): boolean;
+    /**
+     * 转换成数字, 如果原值无效, 返回0
+     * @constructor
+     */
+    number(m: any, key: string, dflt?: number): number;
+    /**
+     * 转换成字符串, 如果原值无效, 返回""
+     * @constructor
+     */
+    string(m: any, key: string, dflt?: string): string;
+    /**
+     * 转换成布尔值, 如果原值无效, 返回false
+     * @constructor
+     */
+    boolean(m: any, key: string, dflt?: boolean): boolean;
+    /**
+     * 转换成{}, 如果原值无效, 返回{}
+     * @constructor
+     */
+    map(m: any, key: string, dflt?: boolean | Object): any;
+    /**
+     * 转换成[], 如果原值无效, 返回[]
+     * @constructor
+     */
+    array(m: any, key: string, dflt?: boolean | Array<any>): any[];
+    /**
+     * 返回第一个符合条件的key
+     * @param m
+     * @param conf
+     */
+    keyOfConf(m: any, conf: (key: string, item: any) => boolean): string;
+    /**
+     * 比较对象，并返回包含差异的对象
+     * 如果返回 undefined 表示没有差异
+     * @param obj
+     * @param parent
+     * @param removeDefault
+     */
+    diff(obj: any, parent: any, removeDefault?: boolean): any;
+    /**
+     * 克隆对象
+     * @param obj
+     */
+    clone(obj: any): any;
+    /**
+     * 通过path设置属性，创建不存在的路径对象
+     * @param obj
+     * @param path "/key1/key2"
+     * @param data
+     */
+    setByPath(obj: any, path: string, data: any): void;
+    /**
+     * 通过path删除
+     * @param obj
+     * @param path "/key1/key2"
+     */
+    removeByPath(obj: any, path: string): void;
+    /**
+     * 通过path获取属性
+     * @param obj
+     * @param path
+     */
+    getByPath(obj: any, path: string): any;
+    flat(obj: any, split?: string): any;
+    _flat(obj: any, result: any, path: string, split?: string): any;
+    /**
+     * 比较两个对象，包括基础类型
+     * @param a
+     * @param b
+     */
+    compare(a: any, b: any): boolean;
+    /**
+     * 从[from]对象复制到 [to]对象
+     * 如果from字段为object并且等于null,则设置to字段为null
+     * 如果from字段为undefined, 则不覆盖
+     * @param from
+     * @param to
+     * @param tokey 如果[to]存在key才进行拷贝
+     */
+    copy(from: any, to: any, tokey?: boolean): void;
+    /**
+     * 去掉兼职
+     */
+    flatString(target: any): string;
+}
+declare const maputil: MapUtil;
+
+declare class UIUtil {
+    /**
+     * 格式化节点的uuid，用于树结构
+     * 树结构的路径的反斜杠与uuid有冲突
+     * @param uuid
+     */
+    formatUUIDForTree(uuid: string): string;
+    /**
+     * x, y 使用 鼠标点击事件产生的 event.getLocation()坐标
+     * @param target
+     * @param x
+     * @param y
+     */
+    hitTest(target: Node, x: number, y: number): boolean;
+    findNode(node: Node, name: string): Node;
+    walk(node: Node, f: (target: Node) => boolean): void;
+    _walk(node: Node, f: (target: Node) => boolean): boolean;
+}
+declare const uiutil: UIUtil;
+
+declare class EventUtil {
+}
+/**
+ * 框架的事件
+ */
+declare const eventutil: EventUtil;
+
+declare class NetUtil {
+    decodeLocationSearch(search: string): any;
+    encodeLocationSearch(params: any, firstChat?: "" | "?" | "&"): string;
+    getLocation(): Location;
+    /**
+     * 获取Loation的参数
+     */
+    getLocationParams(): any;
+}
+declare const netutil: NetUtil;
+
+declare class ArrayUtil {
+    lastItem(array: any[]): any;
+    unique(array: any[]): any[];
+    removeSelf(arr: any[], item: any): void;
+    /**
+     *
+     * @param arr
+     * @param desc 降序
+     */
+    sortNumber(arr: any[], desc?: boolean): any[];
+    sortString(arr: any[], desc?: boolean): any[];
+    getByPath(target: any, key: string): any;
+    sortObject(arr: any[], desc: boolean, ...paths: string[]): any[];
+    sortBySeq(arr: any[], desc: boolean, seq: {
+        [key: string]: number;
+    }, key?: string): any[];
+    indexOfConf(arr: any[], caller: any, f: (item: any) => boolean): number;
+}
+declare const arrayutil: ArrayUtil;
+
+declare class ScaleUtil {
+    tenToAny: string[];
+    allstr: string;
+    randString(size: number, n: number): string;
+    decimalTo(num: number, n: number): string;
+    findkey(instr: string): number;
+    toDecimal(num: string, n: number): number;
+}
+declare const scaleutil: ScaleUtil;
+
+declare class BitUtil {
+    getState(state: number, key: number): boolean;
+    setState(state: number, key: number, value: boolean): number;
+    /**
+     * @param state
+     * @param key
+     */
+    getStateBig(state: bigint, key: bigint): boolean;
+    setStateBig(state: bigint, key: bigint, value: boolean): bigint;
+    /**
+     * key从0开始
+     * @param val
+     */
+    convertToState(val: {
+        [key: string]: boolean;
+    }): number;
+    /**
+     * 判断是否匹配
+     * @param target
+     * @param match 0-返回true
+     */
+    match(target: number, match: number): boolean;
+}
+declare const bitutil: BitUtil;
+
+declare class StringUtil {
+    lowerFirst(key: string): string;
+    upperFirst(key: string): string;
+    cjkEncode(text: any): string;
+    replaceFormat(format: string, source: any): string;
+    /**
+     *
+     * @param format
+     * @param source
+     */
+    evalFormat(format: string, source: any): string;
+    splitLast(val: string, separator: string): string;
+    /**
+     * 从最后一个分隔符截断字符串，返回截断的左右字符串
+     * @param val
+     * @param separator
+     */
+    splitLastArray(val: string, separator: string): [string, string];
+    /**
+     * 截断字符串
+     * @param val
+     * @param separator
+     * @return [最终的字符串, 被截断的字符串]
+     */
+    truncateLast(val: string, separator: string): [string, string];
+    fill(str: string, char: string, length: number): string;
+}
+declare const stringutil: StringUtil;
+
+declare class IdentUtil {
+    /**
+     * 设置时间的基线，通过减去已经过去的时间，可缩短id长度
+     * 注：同一个项目必须拥有同样的基线，否则有几率出现相同的id！
+     * 注2：基线必须与精度符合
+     * @param time
+     */
+    setTimeBaseline(time: number): void;
+    protected _baseline: number;
+    /**
+     * 设置时间的精度
+     * @param precision
+     */
+    setTimePrecision(precision: "ms" | "s"): void;
+    protected _precision: string;
+    /**
+     * 设置随机数的长度
+     * @param value
+     */
+    setRandLength(value?: number): void;
+    protected _randLength: number;
+    genOne(): string;
+    protected _count: number;
+    protected _lastTime: number;
+}
+declare const identutil: IdentUtil;
+
+declare class RandUtil {
+    /**
+     * 根据权重随机并返回其中的一个键值
+     * // key = 键, val=权重
+     * @param source
+     * @return source的其中一个key
+     */
+    weight(source: {
+        [key: string]: number;
+    }): string;
+    /**
+     * [0, val]
+     * @param val
+     */
+    intn(val: number): number;
+    /**
+     * [min, max)
+     * @param min
+     * @param max
+     */
+    range(min: number, max: number): number;
+    /**
+     * 在arr中随机返回【count】个元素
+     * @param arr
+     * @param count
+     */
+    countOfArray(arr: any[], count: number): any[];
+}
+declare const randutil: RandUtil;
+
+declare class MathUtil {
+    version: number;
+    TempVec2: Vec2;
+    TempVec3: Vec3;
+    TempVec4: Vec4;
+    convertVec2to3(vec2: Vec2, useTemp?: boolean): Vec3;
+    convertVec3to2(vec3: Vec3, useTemp?: boolean): Vec2;
+    isOdd(value: number): boolean;
+}
+declare const mathutil: MathUtil;
+
+declare class ResUtil {
+    loadResource(path: string): Promise<[any, error]>;
+    preloadResource(path: string): Promise<[any, error]>;
+    loadBubble(bundle: string): Promise<[AssetManager.Bundle, error]>;
+    loadBubbleItem(bubble: AssetManager.Bundle, path: string, type: any): Promise<[any, error]>;
+    loadAtlas(path: string): Promise<[SpriteAtlas, error]>;
+    getByPath(path: string, type: any): any;
+    loadByPath(path: string, type: any): Promise<[any, error]>;
+    loadByPathCallback(path: string, type: any, callback: (any: any, error: any) => void): void;
+}
+declare var resutil: ResUtil;
+
+declare class TimeUtil {
+    sleep(time: number): Promise<void>;
+    /**
+     * @param {Number} timeStamp eg:1551323702241
+     * @param {String} formatter eg:yyyy-MM-dd  yyyy/MM/dd yyyy-M-d yyyy/M/d yyyy-MM-dd hh:mm:ss
+     * */
+    format(timeStamp: number, formatter: string): string;
+    /**
+     * @param {Number,String} para
+     * @return {String,Number}
+     * */
+    protected handleDouble(para: any): string;
+    formatLeave(time: number, formatter: string): string;
+}
+declare const timeutil: TimeUtil;
+
+declare enum GeometryDirection {
+    East = 0,
+    SouthEast = 1,
+    South = 2,
+    SouthWest = 3,
+    West = 4,
+    NorthWest = 5,
+    North = 6,
+    NorthEast = 7
+}
+declare class GeometryUtil {
+    /**
+     *  mode，8表示八方向，2表示二方向(左右），4表示4方向
+     * @param dot
+     * @param mode
+     */
+    angleToDirection(dot: number, mode?: number): GeometryDirection;
+}
+declare let geoutil: GeometryUtil;
+
+declare namespace formatutil {
+    /**
+     * 格式化数字
+     * @param format 第nn天
+     * @param val
+     */
+    function toChinese(formatter: string, val: number): string;
+    /**
+     * 转换为 x亿x万
+     * @param val
+     */
+    function format数字使用万亿(val: number | string): string;
+    /**
+     * 格式化货币，每N位增加一个逗号识别
+     * @param val
+     * @param N
+     */
+    function format数字使用逗号(val: number | string, N?: number): string;
+}
+
+declare class FloatUtil {
+    epsilon: number;
+    neq(a: number, b: number, threshold?: number): boolean;
+    eq(a: number, b: number, threshold?: number): boolean;
+    gt(a: number, b: number, threshold?: number): boolean;
+    lt(a: number, b: number, threshold?: number): boolean;
+    geq(a: number, b: number, threshold?: number): boolean;
+    leq(a: number, b: number, threshold?: number): boolean;
+}
+declare let floatutil: FloatUtil;
+
+declare class PathUtil {
+    getDir(path: string): string;
+    getRelativePath(fromPath: string, toPath: string): string;
+    getSamePath(fromPath: string, toPath: string): string;
+    protected validatePath(path: string): void;
+    protected splitPath(path: string): string[];
+}
+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 };