declare module els {
    class BaseObject extends egret.EventDispatcher {
        private static _uniqueID;
        private _id;
        /**编辑类型，0：可以添加到场景中，1：内置，不能添加到场景中 */
        editType: number;
        UID: number;
        name: string;
        constructor();
        readonly id: number;
        destroy(): void;
        clone(): BaseObject;
    }
}
declare module els {
    /**
     * 组件接口
     */
    interface IComponentData {
        name: string;
        propertys: any;
    }
    class Component extends BaseObject {
        private _enabled;
        gameobject: GameObject;
        constructor();
        enabled: boolean;
        readonly className: string;
        /**
         * 当属性改变时
         * @param oldProp 旧的属性
         * @param currentProp 新的属性
         *  */
        onPropertyChanged(oldProp: {
            name: string;
            value: any;
        }, currentProp: {
            name: string;
            value: any;
        }): void;
        /**在渲染对象之前被调用 */
        onWillRenderObject(): void;
        /**每帧渲染执行 */
        onRender(): void;
        /**
         * 只会被调用一次，在onStart方法之前被调用,主要用于字段的初始化工作，禁用脚本，创建游戏对象
         * 注意：是所有游戏对象初始化完毕之后才调用，而非本身初始化完毕后调用。
         */
        onAwake(): void;
        /**
         * 仅在render函数第一次调用前调用，它在整个脚本生命周期时只被调用一次。（它在onAwake之前执行？？？)
         * 主要用于程序UI的初始化操作，比如获取游戏对象或组件
         * 设置了enabled = false之后，start不会被调用
         */
        onStart(): void;
        /**每帧执行，设置了enabled = false之后，tick不会被调用 */
        tick(): void;
        /**如果enabled=true,那么每帧将被执行 */
        update(): void;
        fixedUpdate(): void;
        lateUpdate(): void;
        /**
         * 当组件被载入时被调用
         */
        onEnable(): void;
        /**
         * 当组件被销毁或者组件被卸载时调用
         */
        onDisable(): void;
        /**
         * 当组件被销毁时调用
         */
        onDestroy(): void;
        /**
         * 当组件所在游戏对象变成显示时，这里函数调用表示在视野中可见，并不一定只指visible属性为true
         */
        onBecomeVisible(): void;
        /**
         * 当组件所在游戏对象变成隐藏时,这里函数调用表示在视野中不可见，并不一定只指visible属性为false
         */
        onBecomeInVisible(): void;
        /** 当组件所在游戏对象与其它游戏对象碰撞时 */
        onCollision(): void;
        /** 在渲染与处理GUI事件时调用，通常我们可以通过此函数来画一个按纽等，每一帧执行 */
        onGUI(): void;
        /** 用户点击重置按纽或者首次添加该对象时被调用，只函数只在编辑模式下被调用 */
        onReset(): void;
        /** 编辑器模式下被调用 */
        onDrawGizmos(): void;
        destroy(): void;
        onTouchBegin(event: egret.TouchEvent): void;
        onTouchEnd(event: egret.TouchEvent): void;
        onTouchMove(event: egret.TouchEvent): void;
        onTouchTap(event: egret.TouchEvent): void;
        onTouchReleaseOutside(event: egret.TouchEvent): void;
        onTouchRollOver(event: egret.TouchEvent): void;
        onTouchRollOut(event: egret.TouchEvent): void;
        clone(): Component;
    }
}
declare module els {
    class Renderer extends Component {
        protected _renderer: egret.DisplayObjectContainer;
        constructor();
        renderer: egret.DisplayObjectContainer;
        private __onRendererRender();
        protected onTouchEvent(event: egret.TouchEvent): void;
    }
}
declare module els {
    /**
     * 游戏对象数据接口
     */
    interface IGameObjectData {
        name: string;
        UID: number;
        components: IComponentData[];
        transform: any;
        gameobjects: IGameObjectData[];
    }
    class GameObject extends BaseObject {
        private _components;
        private _componentHash;
        private _alpha;
        private _visible;
        private _snapPixelsEnabled;
        private _update;
        private _numChildren;
        private _parent;
        private _transfrom;
        private _isStatic;
        private _enabled;
        private _rendererComponentCount;
        protected _rendererComponent: Renderer;
        protected _children: GameObject[];
        onUpdate: Function;
        constructor(name?: string);
        readonly dt: number;
        readonly numChildren: number;
        readonly children: GameObject[];
        /** 获取游戏对象上的渲染组件 */
        readonly rendererComponent: Renderer;
        readonly renderer: egret.DisplayObjectContainer;
        readonly transform: Transform;
        enabled: boolean;
        readonly components: Component[];
        readonly componentHash: any;
        isStatic: boolean;
        readonly update: boolean;
        snapPixelsEnabled: boolean;
        x: number;
        y: number;
        width: number;
        height: number;
        scaleX: number;
        scaleY: number;
        skewX: number;
        skewY: number;
        anchorOffsetX: number;
        anchorOffsetY: number;
        rotation: number;
        alpha: number;
        visible: boolean;
        readonly parent: GameObject;
        readonly scene: Scene;
        getTransformedBounds(targetCoordinateSpace: egret.DisplayObject, resultRect?: egret.Rectangle): egret.Rectangle;
        getBounds(resultRect?: egret.Rectangle, calculateAnchor?: boolean): egret.Rectangle;
        getChildAt(index: number): GameObject;
        getChildIndex(child: GameObject): number;
        getChildByName(name: string): GameObject;
        addChild(child: GameObject): void;
        removeChild(child: GameObject): void;
        addChildAt(child: GameObject, index: number): GameObject;
        /** TODO */
        setChildIndex(child: GameObject, index: number): void;
        swapChildrenAt(index1: number, index2: number): void;
        swapChildren(child1: GameObject, child2: GameObject): void;
        removeChildren(): void;
        contains(child: GameObject): boolean;
        getComponentById(id: number): Component;
        getComponentsByName(name: string): Component[];
        addComponent(com: Component): void;
        removeComponent(com: Component): void;
        removeComponentByName(compName: string): void;
        removeAllComponents(): void;
        fixedUpdate(): void;
        /**
         *  渲染
         *  @private
         */
        private __render();
        destroy(): void;
        clone(): GameObject;
    }
}
declare module els {
    function file(format: string): (target: Component, propertyKey: string) => void;
    function select(providers: (number | string | boolean)[]): (target: Component, propertyKey: string) => void;
    function input(): (target: Component, propertyKey: string) => void;
}
declare module els {
    class ButtonRenderer extends Renderer {
        private _up;
        private _down;
        private _disable;
        private _currentState;
        touchEnabled: boolean;
        upUrl: string;
        downUrl: string;
        disableUrl: string;
        constructor();
        onAwake(): void;
        onPropertyChanged(oldProp: {
            name: string;
            value: any;
        }, currentProp: {
            name: string;
            value: any;
        }): void;
        protected onTouchEvent(event: egret.TouchEvent): void;
        clone(): ButtonRenderer;
    }
}
declare module els {
    class DragonBonesRenderer extends Renderer {
        url: string;
        textureConfigUrl: string;
        skeletonUrl: string;
        loopTimes: number;
        defaultAnimation: string;
        defaultArmature: string;
        private _dbContainer;
        private _texture;
        constructor();
        onAwake(): void;
        clone(): DragonBonesRenderer;
    }
}
declare module els {
    class Camera extends GameObject {
        constructor();
    }
}
declare module els {
    class ShapeRenderer extends Renderer {
        private _shape;
        color: number;
        constructor();
        update(): void;
        onAwake(): void;
        clone(): ShapeRenderer;
    }
}
declare module els {
    class SpriteRenderer extends Renderer {
        url: string;
        private _bitmap;
        constructor();
        onAwake(): void;
        clone(): SpriteRenderer;
    }
}
declare module els {
    class TextFieldRenderer extends Renderer {
        private _textField;
        text: string;
        type: string;
        italic: boolean;
        border: boolean;
        borderColor: number;
        background: boolean;
        backgroundColor: number;
        maxChars: number;
        displayAsPassword: boolean;
        multiline: boolean;
        textAlign: string;
        size: number;
        fontFamily: string;
        bold: boolean;
        inputType: string;
        constructor();
        onAwake(): void;
        clone(): TextFieldRenderer;
    }
}
declare module els {
    class TiledBackgroundRenderer extends Renderer {
        url: string;
        private _bitmap;
        constructor();
        onAwake(): void;
        clone(): TiledBackgroundRenderer;
    }
}
declare module els {
    class Transform {
        x: number;
        y: number;
        width: number;
        height: number;
        scaleX: number;
        scaleY: number;
        anchorOffsetX: number;
        anchorOffsetY: number;
        rotation: number;
        skewX: number;
        skewY: number;
    }
}
declare module els {
    let registerEventListener: boolean;
    let editorTargets: any[];
    function BindComponent($Class?: any): (target: Function) => void;
    class Editor {
        static editors: any;
        component: Component;
        gameobject: GameObject;
        private _id;
        private static _uniqueID;
        private _sceneuis;
        private _componentuis;
        private _renderContainer;
        constructor();
        readonly id: number;
        readonly sceneuis: HTMLElement[];
        readonly componentuis: HTMLElement[];
        readonly renderContainer: HTMLElement;
        /**
         * 每帧更新
         */
        tick(): void;
        onEnabled(): void;
        addSceneUI(ui: HTMLElement): void;
        addComponentUI(ui: HTMLElement): void;
    }
}
declare module els {
    class ComponentEvent extends Event {
        static COMPONENTS_INIT_COMPLETE: string;
        static COMPONENTS_INSTANCE_COMPLETE: string;
        constructor(type: string, eventInitDict?: EventInit);
    }
}
declare module els {
    class CommonComponent extends Component {
        mp: number;
        hp: number;
    }
}
declare module els {
    class AnimationRenderer extends Renderer {
        private _bitmap;
        constructor();
        clone(): ButtonRenderer;
    }
}
declare module els {
    class Sprite extends BaseObject {
    }
}
declare module els {
    interface PropertyRender {
        component: Component;
        propertyName: string;
        renderDOM: HTMLElement;
        baseHTML: string;
    }
    class ComponentPropertyMaps {
        static componentPropertys: any;
        /**
         * @param componentName 组件名
         * @param propertyName 属性名
         * @param newValue 更新属性的新值
         */
        static getPropertyRender(componentName: string, propertyName: string, newValue?: (string | number | boolean | (number | string | boolean)[])): PropertyRender;
        static addPropertyRender(component: Component, propertyName: string, renderDOM: HTMLElement): void;
        static removePropertyRender(component: Component, propertyName: string): void;
    }
}
declare module els {
    enum ElsModeType {
        PREVIEW = 0,
        EDIT = 1,
    }
    class ElsMode {
        /**0：预览模式  1：编辑模式 */
        static mode: number;
    }
}
declare module els {
    let editorRuns: any;
    interface IEditorRun {
        callName: string;
    }
    /**
     * 编辑
     * @param type 0: 预览  1：编辑
     */
    function mode(type?: number): (target: Component, propertyKey: string, descriptor: PropertyDescriptor) => void;
}
declare module els {
    class Scene extends GameObject {
        private static _instance;
        private editors;
        private _lastTick;
        private _uigameobjectHash;
        static TICK: number;
        constructor();
        static getInstance(): Scene;
        readonly renderContainer: egret.DisplayObjectContainer;
        getGameobjectByUID(uid: number): any;
        switchScene(url: string, onComplete?: Function, thisObject?: any, debug?: boolean): void;
        private parseGameObject(objectdata);
        private execAwake(gameobject);
        private execStart(gameobject);
        private execRenderer(gameobject);
        startRender(): void;
        stopRender(): void;
        private onRender();
        destroy(): void;
    }
}
declare module els {
    class MathUtils {
        static TO_RADIAN: number;
        static TO_DEGREE: number;
        static toRadian(a: number): number;
        static toDegree(radian: number): number;
    }
}
declare module els {
    class Vector2D {
        _x: number;
        _y: number;
        constructor(x?: number, y?: number);
        x: number;
        y: number;
        length: number;
        readonly lengthSQ: number;
        angle: number;
        rotation: number;
        normalize(): Vector2D;
        truncate(max: number): Vector2D;
        reverse(): Vector2D;
        isNormalized(): boolean;
        dotProd(v2: Vector2D): number;
        crossProd(v2: Vector2D): boolean;
        getCross(v2: Vector2D): number;
        static angleBetween(v1: Vector2D, v2: Vector2D): number;
        readonly perp: Vector2D;
        sign(v2: Vector2D): number;
        distance(v2: Vector2D): number;
        distanceSQ(v2: Vector2D): number;
        equals(v2: Vector2D): boolean;
        isZero(): boolean;
        scale(value: number): Vector2D;
        add(x: number, y: number): Vector2D;
        substruct(x: number, y: number): Vector2D;
        multiply(x: number, y: number): Vector2D;
        divide(x: number, y: number): Vector2D;
        clone(): Vector2D;
        toString(): string;
    }
}