define("displayEngineApi", [],
    function() {
        "use strict";

        function $iterator(o) {
            if (o instanceof Array) return function() {
                return {
                    cur: 0,
                    arr: o,
                    hasNext: function() {
                        return this.cur < this.arr.length;
                    },
                    next: function() {
                        return this.arr[this.cur++];
                    }
                };
            };
            return typeof(o.iterator) == 'function' ? $bind(o, o.iterator) : o.iterator;
        };;
        var $fid = 0;

        function $bind(o, m) {
            if (m == null) return null;
            if (m.__id__ == null) m.__id__ = $fid++;
            var f;
            if (o.hx__closures__ == null) o.hx__closures__ = {};
            else f = o.hx__closures__[m.__id__];
            if (f == null) {
                f = function() {
                    return f.method.apply(f.scope, arguments);
                };
                f.scope = o;
                f.method = m;
                o.hx__closures__[m.__id__] = f;
            }
            return f;
        };
        var $_;
        var $estr = function() {
            return _hcmn_.js_Boot.__string_rec(this, '');
        };
        if (typeof displayEngineApi == 'undefined') {
            var displayEngineApi = {};
        };

        displayEngineApi.IAnimation = function() {}
        displayEngineApi.IAnimation.prototype = {

            start: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IDisplayObject = function() {}
        displayEngineApi.IDisplayObject.prototype = {

            getId: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            setCacheAsBitmap: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            setName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            },
            getName: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            getParent: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPivot: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setPivot: function(point) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getWidth: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setWidth: function(width) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getHeight: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setHeight: function(heigh) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getAlpha: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setAlpha: function(alpha) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getRotation: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setRotation: function(rotation) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setX: function(x) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setY: function(y) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            setPos: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            setDim: function(width, height) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            getScaleX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleX: function(scalex) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getScaleY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleY: function(scaley) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            setScale: function(factor) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getZIndex: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setZIndex: function(zIndex) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getZOrder: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setZOrder: function(zIndex) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            sendToBottom: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            bringToTop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getCursor: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            setCursor: function(cursor) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            },
            getButtonMode: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setButtonMode: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getMask: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setMask: function(graphics) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getHitArea: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setHitArea: function(area) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            getMouseEnabled: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setMouseEnabled: function(mouseEnabled) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getVisible: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setVisible: function(visible) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            updateCache: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getBounds: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setBounds: function(x, y, width, height) {
                return {
                    arguments: ["number", "number", "number", "number"],
                    returns: "void"
                };
            },
            globalToLocal: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            },
            localToGlobal: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            },
            on: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            off: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            onAddedToStage: function(handler) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getStageName: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            isType: function(type) {
                return {
                    arguments: ["*"],
                    returns: "boolean"
                };
            },
            setDraggable: function(draggable) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            isDraggable: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setDragBounds: function(bounds) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getDragBounds: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getUserData: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IBitmap = function() {}
        displayEngineApi.IBitmap.prototype = {

            clone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            update: function(c, width, height) {
                return {
                    arguments: ["*", "number", "*"],
                    returns: "void"
                };
            },
            getInfo: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            renderNoise: function(r, g, b, a) {
                return {
                    arguments: ["*", "*", "*", "number"],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IDisplayObjectContainer = function() {}
        displayEngineApi.IDisplayObjectContainer.prototype = {

            getNumChildren: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getChildren: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            },
            addChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            addChildAt: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "*"
                };
            },
            addChildren: function(children) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            removeChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            removeChildAt: function(index) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            removeChildren: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getChildAt: function(index) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getChildIndex: function(child) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            setChildIndex: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "void"
                };
            },
            getChildByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IGraphics = function() {}
        displayEngineApi.IGraphics.prototype = {

            arc: function(cx, cy, radius, startAngle, endAngle, anticlockwise) {
                return {
                    arguments: ["number", "number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            clear: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            clone: function(fillColor, fillAlpha, strokeColor, strokeThickness, strokeAlpha) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            update: function(fillColor, fillAlpha, strokeColor, strokeThickness, strokeAlpha) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            beginFill: function(color, alpha) {
                return {
                    arguments: ["number", {
                        type: "number",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            lineStyle: function(thickness, color, alpha) {
                return {
                    arguments: ["number", "number", {
                        type: "number",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            moveTo: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            },
            lineTo: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            },
            drawRect: function(x, y, width, height) {
                return {
                    arguments: ["number", "number", "number", "number"],
                    returns: "*"
                };
            },
            drawRoundRect: function(x, y, width, height, borderRadius) {
                return {
                    arguments: ["number", "number", "number", "number", "number"],
                    returns: "*"
                };
            },
            drawCircle: function(x, y, radius) {
                return {
                    arguments: ["number", "number", "number"],
                    returns: "*"
                };
            },
            drawEllipse: function(x, y, width, height) {
                return {
                    arguments: ["number", "number", "number", "number"],
                    returns: "*"
                };
            },
            drawPoly: function(polyDef, close) {
                return {
                    arguments: ["*", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            bezierCurveTo: function(cpX, cpY, cpX2, cpY2, toX, toY) {
                return {
                    arguments: ["number", "number", "number", "number", "number", "number"],
                    returns: "*"
                };
            },
            quadraticCurveTo: function(cpX, cpY, toX, toY) {
                return {
                    arguments: ["number", "number", "number", "number"],
                    returns: "*"
                };
            },
            endFill: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            endStroke: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IMovieClip = function() {}
        displayEngineApi.IMovieClip.prototype = {

            getEnabled: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setEnabled: function(enabled) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getAnimationSpeed: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setAnimationSpeed: function(speed) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getPaused: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setPaused: function(paused) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getLoop: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setLoop: function(loop) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getCurrentFrame: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setCurrentFrame: function(frame) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getStateFrameCount: function(stateName) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "number"
                };
            },
            gotoAndPlay: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            applyPNGMask: function(mask) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            toBitmap: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            gotoAndStop: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            gotoAndPlayReversed: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            gotoAndStopReversed: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            nextFrame: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            prevFrame: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            nextScene: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            prevScene: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            play: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            clone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOffscreenBitmaps: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            }
        };

        displayEngineApi.IOffscreenStage = function() {}
        displayEngineApi.IOffscreenStage.prototype = {

            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            addBitmapChild: function(bmp) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getCanvas: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getMaskedCanvas: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            applyMask: function(mask) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            getRegisteredBitmaps: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            }
        };

        displayEngineApi.IParticleSystem = function() {}
        displayEngineApi.IParticleSystem.prototype = {

            start: function(stage, path, loop) {
                return {
                    arguments: ["*", {
                        type: "*",
                        opt: true
                    }, {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            moveTo: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.ISprite = function() {}
        displayEngineApi.ISprite.prototype = {

            getGraphics: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IStage = function() {}
        displayEngineApi.IStage.prototype = {

            getFpsInfo: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getId: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            getRenderer: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRendererType: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getTimingMode: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setTimingMode: function(mode) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            setFPS: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getCanvas: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHeight: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setHeight: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getWidth: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setWidth: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getScaleX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleX: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getScaleY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleY: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getAlpha: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setAlpha: function(alpha) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getVisible: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setVisible: function(val) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getMouse: function(event) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            render: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            addChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            addChildAt: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "void"
                };
            },
            addChildren: function(_children_) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            removeChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            removeChildAt: function(index) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getChildIndex: function(child) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            setChildIndex: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "void"
                };
            },
            getChildAt: function(index) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getChildByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            removeAllChildren: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getNumChildren: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getDeltaTime: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getChildren: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            },
            on: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            off: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            offAll: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            onWindowTouch: function(handler, fireOnlyOnce) {
                return {
                    arguments: ["*", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "void"
                };
            }
        };

        displayEngineApi.ITicker = function() {}
        displayEngineApi.ITicker.prototype = {

            setInterval: function(interval) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getInterval: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setFPS: function(value) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getFPS: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setup: function(timingMode, renderer, targetFPS, maxDelta) {
                return {
                    arguments: ["*", "*", {
                        type: "number",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            init: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            reset: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getMeasuredTickTime: function(ticks) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            getMeasuredFPS: function(ticks) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            setPaused: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getPaused: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            getTime: function(runTime) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            getEventTime: function(runTime) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            getTicks: function(paused) {
                return {
                    arguments: ["boolean"],
                    returns: "number"
                };
            }
        };
        displayEngineApi.LineStyle = function(lineWidth, color, alpha) {
            this.lineWidth = lineWidth;
            this.color = color;
            this.alpha = alpha;
        };
        displayEngineApi.LineStyle.__name__ = ["displayEngineApi", "LineStyle"];
        displayEngineApi.LineStyle.prototype.lineWidth = null;
        displayEngineApi.LineStyle.prototype.color = null;
        displayEngineApi.LineStyle.prototype.alpha = null;
        displayEngineApi.LineStyle.prototype.__class__ = displayEngineApi.LineStyle;
        displayEngineApi.RendererName = {
            __ename__: ["displayEngineApi", "RendererName"],
            __constructs__: ["PIXI", "EASEL"]
        };
        displayEngineApi.RendererName.PIXI = ["PIXI", 0];
        displayEngineApi.RendererName.PIXI.toString = $estr;
        displayEngineApi.RendererName.PIXI.__enum__ = displayEngineApi.RendererName;
        displayEngineApi.RendererName.EASEL = ["EASEL", 1];
        displayEngineApi.RendererName.EASEL.toString = $estr;
        displayEngineApi.RendererName.EASEL.__enum__ = displayEngineApi.RendererName;
        displayEngineApi.RendererType = {
            __ename__: ["displayEngineApi", "RendererType"],
            __constructs__: ["RENDERER_CANVAS", "RENDERER_WEBGL"]
        };
        displayEngineApi.RendererType.RENDERER_CANVAS = ["RENDERER_CANVAS", 0];
        displayEngineApi.RendererType.RENDERER_CANVAS.toString = $estr;
        displayEngineApi.RendererType.RENDERER_CANVAS.__enum__ = displayEngineApi.RendererType;
        displayEngineApi.RendererType.RENDERER_WEBGL = ["RENDERER_WEBGL", 1];
        displayEngineApi.RendererType.RENDERER_WEBGL.toString = $estr;
        displayEngineApi.RendererType.RENDERER_WEBGL.__enum__ = displayEngineApi.RendererType;
        displayEngineApi.TimingMode = {
            __ename__: ["displayEngineApi", "TimingMode"],
            __constructs__: ["RAF", "TIMEOUT", "RAF_SYNCHED", "ONCE"]
        };
        displayEngineApi.TimingMode.RAF_SYNCHED = ["RAF_SYNCHED", 2];
        displayEngineApi.TimingMode.RAF_SYNCHED.toString = $estr;
        displayEngineApi.TimingMode.RAF_SYNCHED.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.TimingMode.ONCE = ["ONCE", 3];
        displayEngineApi.TimingMode.ONCE.toString = $estr;
        displayEngineApi.TimingMode.ONCE.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.TimingMode.TIMEOUT = ["TIMEOUT", 1];
        displayEngineApi.TimingMode.TIMEOUT.toString = $estr;
        displayEngineApi.TimingMode.TIMEOUT.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.TimingMode.RAF = ["RAF", 0];
        displayEngineApi.TimingMode.RAF.toString = $estr;
        displayEngineApi.TimingMode.RAF.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.DisplayObjectEvents = function() {};
        displayEngineApi.DisplayObjectEvents.__name__ = ["displayEngineApi", "DisplayObjectEvents"];
        displayEngineApi.DisplayObjectEvents.prototype.__class__ = displayEngineApi.DisplayObjectEvents;
        displayEngineApi.MovieClipEvents = function() {};
        displayEngineApi.MovieClipEvents.__name__ = ["displayEngineApi", "MovieClipEvents"];
        displayEngineApi.MovieClipEvents.prototype.__class__ = displayEngineApi.MovieClipEvents;
        displayEngineApi.DisplayConstants = function() {};
        displayEngineApi.DisplayConstants.__name__ = ["displayEngineApi", "DisplayConstants"];
        displayEngineApi.DisplayConstants.prototype.__class__ = displayEngineApi.DisplayConstants;
        displayEngineApi.DisplayType = {
            __ename__: ["displayEngineApi", "DisplayType"],
            __constructs__: ["STAGE", "DISPLAY_OBJECT", "DISPLAY_OBJECT_CONTAINER", "MOVIE_CLIP", "GRAPHICS", "BITMAP", "SPRITE", "VIDEO"]
        };
        displayEngineApi.DisplayType.BITMAP = ["BITMAP", 5];
        displayEngineApi.DisplayType.BITMAP.toString = $estr;
        displayEngineApi.DisplayType.BITMAP.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.MOVIE_CLIP = ["MOVIE_CLIP", 3];
        displayEngineApi.DisplayType.MOVIE_CLIP.toString = $estr;
        displayEngineApi.DisplayType.MOVIE_CLIP.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.STAGE = ["STAGE", 0];
        displayEngineApi.DisplayType.STAGE.toString = $estr;
        displayEngineApi.DisplayType.STAGE.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.VIDEO = ["VIDEO", 7];
        displayEngineApi.DisplayType.VIDEO.toString = $estr;
        displayEngineApi.DisplayType.VIDEO.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.DISPLAY_OBJECT_CONTAINER = ["DISPLAY_OBJECT_CONTAINER", 2];
        displayEngineApi.DisplayType.DISPLAY_OBJECT_CONTAINER.toString = $estr;
        displayEngineApi.DisplayType.DISPLAY_OBJECT_CONTAINER.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.GRAPHICS = ["GRAPHICS", 4];
        displayEngineApi.DisplayType.GRAPHICS.toString = $estr;
        displayEngineApi.DisplayType.GRAPHICS.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.DISPLAY_OBJECT = ["DISPLAY_OBJECT", 1];
        displayEngineApi.DisplayType.DISPLAY_OBJECT.toString = $estr;
        displayEngineApi.DisplayType.DISPLAY_OBJECT.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.SPRITE = ["SPRITE", 6];
        displayEngineApi.DisplayType.SPRITE.toString = $estr;
        displayEngineApi.DisplayType.SPRITE.__enum__ = displayEngineApi.DisplayType;

        displayEngineApi.IDisplayProvider = function() {}
        displayEngineApi.IDisplayProvider.prototype = {

            getFactory: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStages: function() {
                return {
                    arguments: [],
                    returns: Map
                };
            },
            getDefaultStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IFactory = function() {}
        displayEngineApi.IFactory.prototype = {

            createStage: function(def) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            createDisplayObjectContainer: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            createMovieClip: function(def) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            createOffscreenStage: function(width, height, isWebGL, timingMode, targetFPS) {
                return {
                    arguments: ["number", "number", {
                        type: "boolean",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createGraphics: function(cacheCommands) {
                return {
                    arguments: [{
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createBitmap: function(image, offset) {
                return {
                    arguments: ["*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createSprite: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            createParticleSystem: function(img, type, config) {
                return {
                    arguments: ["*", "string", "*"],
                    returns: "*"
                };
            },
            createAnimation: function(name, object, animDef) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, "*", "*"],
                    returns: "*"
                };
            },
            cache: function(objects) {
                return {
                    arguments: ["array"],
                    returns: "string"
                };
            },
            uncache: function(objectID) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            }
        };
        displayEngineApi.MCDef = function(name, animeDef, animDefState, animationBitmap, offScreen, videoDef) {
            this.name = name;
            this.animeDef;
            this.animDefState = animDefState;
            this.animationBitmap = animationBitmap;
            this.videoDef = videoDef;
            this.offScreen = offScreen;
        };
        displayEngineApi.MCDef.__name__ = ["displayEngineApi", "MCDef"];
        displayEngineApi.MCDef.prototype.name = null;
        displayEngineApi.MCDef.prototype.animeDef = null;
        displayEngineApi.MCDef.prototype.animDefState = null;
        displayEngineApi.MCDef.prototype.animationBitmap = null;
        displayEngineApi.MCDef.prototype.offScreen = null;
        displayEngineApi.MCDef.prototype.videoDef = null;
        displayEngineApi.MCDef.prototype.__class__ = displayEngineApi.MCDef;
        displayEngineApi.Point = function(x, y) {
            this.x = x;
            this.y = y;
        };
        displayEngineApi.Point.__name__ = ["displayEngineApi", "Point"];
        displayEngineApi.Point.prototype.x = null;
        displayEngineApi.Point.prototype.y = null;
        displayEngineApi.Point.prototype.__class__ = displayEngineApi.Point;
        displayEngineApi.Rectangle = function(x, y, w, h) {
            this.x = x;
            this.y = y;
            this.w = w;
            this.h = h;
        };
        displayEngineApi.Rectangle.__name__ = ["displayEngineApi", "Rectangle"];
        displayEngineApi.Rectangle.prototype.x = null;
        displayEngineApi.Rectangle.prototype.y = null;
        displayEngineApi.Rectangle.prototype.w = null;
        displayEngineApi.Rectangle.prototype.h = null;
        displayEngineApi.Rectangle.prototype.__class__ = displayEngineApi.Rectangle;
        displayEngineApi.StageDef = function(id, dimension, canvas, isWebgl, timingMode, targetFPS) {
            if (targetFPS == null) targetFPS = 60;
            this.targetFPS = 60;
            this.id = id;
            this.dimension = dimension;
            this.canvas = canvas;
            this.isWebgl = isWebgl;
            if (timingMode != null) this.timingMode = timingMode;
            else this.timingMode = displayEngineApi.TimingMode.RAF;
            this.targetFPS = targetFPS;
        };
        displayEngineApi.StageDef.__name__ = ["displayEngineApi", "StageDef"];
        displayEngineApi.StageDef.prototype.id = null;
        displayEngineApi.StageDef.prototype.dimension = null;
        displayEngineApi.StageDef.prototype.canvas = null;
        displayEngineApi.StageDef.prototype.isWebgl = null;
        displayEngineApi.StageDef.prototype.timingMode = null;
        displayEngineApi.StageDef.prototype.targetFPS = null;
        displayEngineApi.StageDef.prototype.__class__ = displayEngineApi.StageDef;
        displayEngineApi.VideoDef = function(src, poster, width, height, framerate, autoPlay, loop) {};
        displayEngineApi.VideoDef.__name__ = ["displayEngineApi", "VideoDef"];
        displayEngineApi.VideoDef.prototype.src = null;
        displayEngineApi.VideoDef.prototype.poster = null;
        displayEngineApi.VideoDef.prototype.width = null;
        displayEngineApi.VideoDef.prototype.height = null;
        displayEngineApi.VideoDef.prototype.framerate = null;
        displayEngineApi.VideoDef.prototype.autoPlay = null;
        displayEngineApi.VideoDef.prototype.loop = null;
        displayEngineApi.VideoDef.prototype.__class__ = displayEngineApi.VideoDef;
        if (typeof haxe == 'undefined') {
            var haxe = {};
        };

        haxe.IMap = function() {}
        haxe.IMap.prototype = {

        };
        displayEngineApi.DisplayObjectEvents.ENTER_FRAME = "enterFrame";;
        displayEngineApi.DisplayObjectEvents.CLICK = "click";;
        displayEngineApi.DisplayObjectEvents.DOUBLE_CLICK = "doubleclick";;
        displayEngineApi.DisplayObjectEvents.MIDDLE_CLICK = "middleclick";;
        displayEngineApi.DisplayObjectEvents.MIDDLE_MOUSE_DOWN = "middlemousedown";;
        displayEngineApi.DisplayObjectEvents.MIDDLE_MOUSE_UP = "middlemouseup";;
        displayEngineApi.DisplayObjectEvents.MOUSE_DOWN = "mousedown";;
        displayEngineApi.DisplayObjectEvents.MOUSE_MOVE = "mousemove";;
        displayEngineApi.DisplayObjectEvents.MOUSE_OUT = "mouseout";;
        displayEngineApi.DisplayObjectEvents.MOUSE_OVER = "mouseover";;
        displayEngineApi.DisplayObjectEvents.MOUSE_UP = "mouseup";;
        displayEngineApi.DisplayObjectEvents.MOUSE_WHEEL = "DOMMouseScroll";;
        displayEngineApi.DisplayObjectEvents.RIGHT_CLICK = "rightclick";;
        displayEngineApi.DisplayObjectEvents.RIGHT_MOUSE_DOWN = "rightmousedown";;
        displayEngineApi.DisplayObjectEvents.RIGHT_MOUSE_UP = "rightmouseup";;
        displayEngineApi.DisplayObjectEvents.MOUSE_DRAG = "mousedrag";;
        displayEngineApi.DisplayObjectEvents.TOUCH_START = "touchstart";;
        displayEngineApi.DisplayObjectEvents.TOUCH_END = "touchend";;
        displayEngineApi.DisplayObjectEvents.TOUCH_MOVE = "touchmove";;
        displayEngineApi.DisplayObjectEvents.TOUCH_LEAVE = "touchleave";;
        displayEngineApi.DisplayObjectEvents.TOUCH_CANCEL = "touchcancel";;
        displayEngineApi.MovieClipEvents.ANIMATION_START = "mc_animationstart";;
        displayEngineApi.MovieClipEvents.ANIMATION_COMPLETE = "mc_animationcomplete";;
        displayEngineApi.MovieClipEvents.ANIMATION_TICK = "mc_animationtick";;
        displayEngineApi.DisplayConstants.DEFAULT_STAGE = "skgl_0";;
        displayEngineApi.DisplayConstants.DEFAULT_MC_STATE = "default";;
        return {
            exports: displayEngineApi
        };
    });
//# sourceURL=displayEngineApi.js