define("winControllerApi", ["componentmodelComponentApi", "slotModelApi", "displayEngineApi", "reelsApi", "gameLayoutApi", "clientkernelEventbusApi"],
    function(componentmodelComponentApi, slotModelApi, displayEngineApi, reelsApi, gameLayoutApi, clientkernelEventbusApi) {
        "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 haxe == 'undefined') {
            var haxe = {};
        };

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

        };
        if (typeof winControllerApi == 'undefined') {
            var winControllerApi = {};
        };

        winControllerApi.IWinControllerImplementationPort = function() {}
        winControllerApi.IWinControllerImplementationPort.prototype = {

            showWin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            requestConfiguration: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            reconfigure: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            onCurrentWinLine: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            onReady: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            onWinCycleFinished: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        winControllerApi.IWinControllerPort = function() {}
        winControllerApi.IWinControllerPort.prototype = {

            showWin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            requestConfiguration: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            reconfigure: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            onCurrentWinLine: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            onReady: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            onWinCycleFinished: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        winControllerApi.WinControllerDeclaration = function() {};
        winControllerApi.WinControllerDeclaration = ck_implements(winControllerApi.WinControllerDeclaration, componentmodelComponentApi.IComponentDeclaration);
        winControllerApi.WinControllerDeclaration.__interfaces__ = [componentmodelComponentApi.IComponentDeclaration];
        winControllerApi.WinControllerDeclaration.__name__ = ["winControllerApi", "WinControllerDeclaration"];
        winControllerApi.WinControllerDeclaration.prototype.getChildComponents = function() {
            return null;
        };
        winControllerApi.WinControllerDeclaration.prototype.getReferredComponents = function() {
            return null;
        };
        winControllerApi.WinControllerDeclaration.prototype.getImplementedPorts = function() {
            return [winControllerApi.IWinControllerImplementationPort];
        };
        winControllerApi.WinControllerDeclaration.prototype.getUsedPorts = function() {
            return [winControllerApi.IWinControllerPort, gameLayoutApi.IGameLayoutPort, reelsApi.IReelsPort];
        };
        winControllerApi.WinControllerDeclaration.prototype.__class__ = winControllerApi.WinControllerDeclaration;
        winControllerApi.WinControllerPort = function(bus) {
            this._reconfigure = new clientkernelEventbusApi.Topic("wincontroller:reconfigure");
            this._onWinCycleFinished = new clientkernelEventbusApi.Topic("wincontroller:onWinCycleFinished");
            this._onCurrentWinLine = new clientkernelEventbusApi.Topic("wincontroller:onCurrentWinLine");
            this._onReady = new clientkernelEventbusApi.Topic("wincontroller:onReady");
            this._dispose = new clientkernelEventbusApi.Topic("wincontroller:dispose");
            this._requestConfiguration = new clientkernelEventbusApi.Request("wincontroller:requestConfiguration");
            this._showWin = new clientkernelEventbusApi.Request("wincontroller:showWin");
            this._showWin.connect(bus);
            this._dispose.connect(bus);
            this._onReady.connect(bus);
            this._onCurrentWinLine.connect(bus);
            this._onWinCycleFinished.connect(bus);
            this._requestConfiguration.connect(bus);
            this._reconfigure.connect(bus);
        };
        winControllerApi.WinControllerPort = ck_implements(winControllerApi.WinControllerPort, winControllerApi.IWinControllerPort);
        winControllerApi.WinControllerPort = ck_implements(winControllerApi.WinControllerPort, winControllerApi.IWinControllerImplementationPort);
        winControllerApi.WinControllerPort.__interfaces__ = [winControllerApi.IWinControllerPort, winControllerApi.IWinControllerImplementationPort];
        winControllerApi.WinControllerPort.__name__ = ["winControllerApi", "WinControllerPort"];
        winControllerApi.WinControllerPort.prototype._showWin = null;
        winControllerApi.WinControllerPort.prototype._requestConfiguration = null;
        winControllerApi.WinControllerPort.prototype._dispose = null;
        winControllerApi.WinControllerPort.prototype._onReady = null;
        winControllerApi.WinControllerPort.prototype._onCurrentWinLine = null;
        winControllerApi.WinControllerPort.prototype._onWinCycleFinished = null;
        winControllerApi.WinControllerPort.prototype._reconfigure = null;
        winControllerApi.WinControllerPort.prototype.showWin = function() {
            return this._showWin;
        };
        winControllerApi.WinControllerPort.prototype.dispose = function() {
            return this._dispose;
        };
        winControllerApi.WinControllerPort.prototype.onCurrentWinLine = function() {
            return this._onCurrentWinLine;
        };
        winControllerApi.WinControllerPort.prototype.onReady = function() {
            return this._onReady;
        };
        winControllerApi.WinControllerPort.prototype.onWinCycleFinished = function() {
            return this._onWinCycleFinished;
        };
        winControllerApi.WinControllerPort.prototype.requestConfiguration = function() {
            return this._requestConfiguration;
        };
        winControllerApi.WinControllerPort.prototype.reconfigure = function() {
            return this._reconfigure;
        };
        winControllerApi.WinControllerPort.prototype.__class__ = winControllerApi.WinControllerPort;
        winControllerApi.WinControllerPortFactory = function() {};
        winControllerApi.WinControllerPortFactory = ck_implements(winControllerApi.WinControllerPortFactory, componentmodelComponentApi.IPortFactory);
        winControllerApi.WinControllerPortFactory.__interfaces__ = [componentmodelComponentApi.IPortFactory];
        winControllerApi.WinControllerPortFactory.__name__ = ["winControllerApi", "WinControllerPortFactory"];
        winControllerApi.WinControllerPortFactory.prototype.provide = function(channel) {
            return new winControllerApi.WinControllerPort(channel);
        };
        winControllerApi.WinControllerPortFactory.prototype["use"] = function(channel) {
            return new winControllerApi.WinControllerPort(channel);
        };
        winControllerApi.WinControllerPortFactory.prototype.__class__ = winControllerApi.WinControllerPortFactory;
        winControllerApi.AnimateScatterLandingPayload = function(id, row, column) {
            this.id = id;
            this.row = row;
            this.column = column;
        };
        winControllerApi.AnimateScatterLandingPayload.__name__ = ["winControllerApi", "AnimateScatterLandingPayload"];
        winControllerApi.AnimateScatterLandingPayload.prototype.id = null;
        winControllerApi.AnimateScatterLandingPayload.prototype.row = null;
        winControllerApi.AnimateScatterLandingPayload.prototype.column = null;
        winControllerApi.AnimateScatterLandingPayload.prototype.__class__ = winControllerApi.AnimateScatterLandingPayload;
        winControllerApi.BonusWinLine = function(id, name, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount) {
            slotModelApi.BonusWin.call(this, winControllerApi.BonusWinLine.TYPE, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount);
        };
        winControllerApi.BonusWinLine.__name__ = ["winControllerApi", "BonusWinLine"];
        winControllerApi.BonusWinLine.__super__ = slotModelApi.BonusWin;
        for (var k in slotModelApi.BonusWin.prototype) winControllerApi.BonusWinLine.prototype[k] = slotModelApi.BonusWin.prototype[k];
        winControllerApi.BonusWinLine.prototype.__class__ = winControllerApi.BonusWinLine;
        winControllerApi.CurrentWinLinePayload = function(win) {
            this.win = win;
        };
        winControllerApi.CurrentWinLinePayload.__name__ = ["winControllerApi", "CurrentWinLinePayload"];
        winControllerApi.CurrentWinLinePayload.prototype.win = null;
        winControllerApi.CurrentWinLinePayload.prototype.__class__ = winControllerApi.CurrentWinLinePayload;
        winControllerApi.ShowWinPayload = function(outcome, loop, frozenSymbols, isHighWin, stopFrameName) {
            if (stopFrameName == null) stopFrameName = "";
            if (isHighWin == null) isHighWin = false;
            if (loop == null) loop = true;
            this.frozenSymbols = frozenSymbols;
            this.loop = loop;
            this.isHighWin = isHighWin;
            this.outcome = outcome;
            this.stopFrameName = stopFrameName;
        };
        winControllerApi.ShowWinPayload.__name__ = ["winControllerApi", "ShowWinPayload"];
        winControllerApi.ShowWinPayload.prototype.frozenSymbols = null;
        winControllerApi.ShowWinPayload.prototype.outcome = null;
        winControllerApi.ShowWinPayload.prototype.loop = null;
        winControllerApi.ShowWinPayload.prototype.isHighWin = null;
        winControllerApi.ShowWinPayload.prototype.stopFrameName = null;
        winControllerApi.ShowWinPayload.prototype.__class__ = winControllerApi.ShowWinPayload;

        winControllerApi.IWinControllerOverlapablePluginExtension = function() {}
        winControllerApi.IWinControllerOverlapablePluginExtension.prototype = {

            setOverlapMap: function(map) {
                return {
                    arguments: [Map],
                    returns: "void"
                };
            }
        };

        winControllerApi.IWinControllerPlugin = function() {}
        winControllerApi.IWinControllerPlugin.prototype = {

            setCurrentWin: function(type, win) {
                return {
                    arguments: ["string", "*"],
                    returns: "void"
                };
            },
            setContainer: function(container) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            setReelLayoutModel: function(reelLayoutModel) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            setWinSymbolsModel: function(winSymbolsModel) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            setWinAnimationRulesModel: function(winAnimationRulesModel) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            setOutcome: function(outcome) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            ready: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            showSummery: function(wins) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            setLoadedAssets: function(loadedAssets) {
                return {
                    arguments: [Map],
                    returns: "void"
                };
            }
        };

        winControllerApi.IWinControllerPluginService = function() {}
        winControllerApi.IWinControllerPluginService.prototype = {

            registerPlugin: function(name, instance) {
                return {
                    arguments: ["string", "*"],
                    returns: "void"
                };
            },
            showWin: function(type, win) {
                return {
                    arguments: ["string", "*"],
                    returns: "void"
                };
            },
            updateReelData: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            registerSubContainer: function(name, dispay) {
                return {
                    arguments: ["string", "*"],
                    returns: "void"
                };
            },
            getAllContainers: function() {
                return {
                    arguments: [],
                    returns: Map
                };
            },
            getAllPlugins: function() {
                return {
                    arguments: [],
                    returns: Map
                };
            }
        };

        winControllerApi.IWinControllerScatterPluginExtension = function() {}
        winControllerApi.IWinControllerScatterPluginExtension.prototype = {

            showScatterLanding: function(scatters) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            hideScatterLanding: function(remove) {
                return {
                    arguments: [{
                        type: "boolean",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            setScatterLandingModel: function(scatterSumbolsModel) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            }
        };
        winControllerApi.WinControllerAbstractPlugin = function() {};
        winControllerApi.WinControllerAbstractPlugin = ck_implements(winControllerApi.WinControllerAbstractPlugin, winControllerApi.IWinControllerPlugin);
        winControllerApi.WinControllerAbstractPlugin.__interfaces__ = [winControllerApi.IWinControllerPlugin];
        winControllerApi.WinControllerAbstractPlugin.__name__ = ["winControllerApi", "WinControllerAbstractPlugin"];
        winControllerApi.WinControllerAbstractPlugin.prototype.setCurrentWin = function(type, win) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.setContainer = function(container) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.setReelLayoutModel = function(reelLayoutModel) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.setWinSymbolsModel = function(winSymbolsModel) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.setWinAnimationRulesModel = function(winAnimationRulesModel) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.dispose = function() {};
        winControllerApi.WinControllerAbstractPlugin.prototype.setOutcome = function(outcome) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.ready = function() {};
        winControllerApi.WinControllerAbstractPlugin.prototype.showSummery = function(wins) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.setLoadedAssets = function(loadedAssets) {};
        winControllerApi.WinControllerAbstractPlugin.prototype.__class__ = winControllerApi.WinControllerAbstractPlugin;
        winControllerApi.ReelLayoutModel = function(reelPicture, reelPositions, reelsPort, reelRegistryService, reelRowOffset) {
            if (reelRowOffset == null) reelRowOffset = 0;
            this.registryService = reelRegistryService;
            this.reelPort = reelsPort;
            this.reelRowOffset = reelRowOffset;
            this.reelPositions = reelPositions;
            this.reelPicture = reelPicture;
        };
        winControllerApi.ReelLayoutModel.__name__ = ["winControllerApi", "ReelLayoutModel"];
        winControllerApi.ReelLayoutModel.prototype.reelPositions = null;
        winControllerApi.ReelLayoutModel.prototype.reelPicture = null;
        winControllerApi.ReelLayoutModel.prototype.reelRowOffset = null;
        winControllerApi.ReelLayoutModel.prototype.reelPort = null;
        winControllerApi.ReelLayoutModel.prototype.registryService = null;
        winControllerApi.ReelLayoutModel.prototype.getCellPosition = function(row, column) {
            return this.reelPositions[column][row + this.reelRowOffset];
        };
        winControllerApi.ReelLayoutModel.prototype.getCellSymbolID = function(row, column) {
            return this.reelPicture[column][row + this.reelRowOffset];
        };
        winControllerApi.ReelLayoutModel.prototype.setCellVisibility = function(visibilityArray) {
            this.reelPort.setReelCellsVisibility().publish(visibilityArray);
        };
        winControllerApi.ReelLayoutModel.prototype.resetReelVisibility = function() {
            this.reelPort.setReelPicture().publish(this.registryService.getReelPicture());
        };
        winControllerApi.ReelLayoutModel.prototype.getNumberOfColumns = function() {
            return this.reelPositions.length;
        };
        winControllerApi.ReelLayoutModel.prototype.getNumberOfRows = function() {
            return this.reelPositions[0].length;
        };
        winControllerApi.ReelLayoutModel.prototype.__class__ = winControllerApi.ReelLayoutModel;
        winControllerApi.ScatterSymbolsModel = function(scatterSymbolsAssetsMap, scatterSymbolsActiveFrameMap) {
            this.scatterSymbolsActiveFrameMap = scatterSymbolsActiveFrameMap;
            this.scatterSymbolsAssetsMap = scatterSymbolsAssetsMap;
        };
        winControllerApi.ScatterSymbolsModel.__name__ = ["winControllerApi", "ScatterSymbolsModel"];
        winControllerApi.ScatterSymbolsModel.prototype.scatterSymbolsAssetsMap = null;
        winControllerApi.ScatterSymbolsModel.prototype.scatterSymbolsActiveFrameMap = null;
        winControllerApi.ScatterSymbolsModel.prototype.getScatterLandingAnimationForId = function(id) {
            return this.scatterSymbolsAssetsMap.get(id);
        };
        winControllerApi.ScatterSymbolsModel.prototype.getScatterLandingActiveFrameAnimationId = function(id) {
            return this.scatterSymbolsActiveFrameMap.get(id);
        };
        winControllerApi.ScatterSymbolsModel.prototype.__class__ = winControllerApi.ScatterSymbolsModel;
        winControllerApi.WinAnimationsRulesModel = function(winProcesDescription) {
            this.winRules = winProcesDescription;
        };
        winControllerApi.WinAnimationsRulesModel.__name__ = ["winControllerApi", "WinAnimationsRulesModel"];
        winControllerApi.WinAnimationsRulesModel.prototype.winRules = null;
        winControllerApi.WinAnimationsRulesModel.prototype.get_animateCurrentLineOnly = function() {
            return this.winRules.animateCurrentLineOnly;
        };
        winControllerApi.WinAnimationsRulesModel.prototype.get_showActiveFrames = function() {
            return this.winRules.showActiveFrames;
        };
        winControllerApi.WinAnimationsRulesModel.prototype.get_showInactiveFrames = function() {
            return this.winRules.showInactiveFrames;
        };
        winControllerApi.WinAnimationsRulesModel.prototype.get_showSummary = function() {
            return this.winRules.showSummary;
        };
        winControllerApi.WinAnimationsRulesModel.prototype.get_winLineInterval = function() {
            return this.winRules.winLineInterval;
        };
        winControllerApi.WinAnimationsRulesModel.prototype.get_excludeScatterWinFromFreeze = function() {
            return this.winRules.excludeScatterWinFromFreeze;
        };
        winControllerApi.WinAnimationsRulesModel.prototype.__class__ = winControllerApi.WinAnimationsRulesModel;
        winControllerApi.WinSymbolModel = function(winSymbolsAssetMap, activeWinFramesAssetMap, inactiveWinFramesAssetMap) {
            this.inactiveWinFramesAssetMap = inactiveWinFramesAssetMap;
            this.activeWinFramesAssetMap = activeWinFramesAssetMap;
            this.winSymbolsAssetMap = winSymbolsAssetMap;
            this.lineColors = new _hcmn_.haxe_ds_IntMap();
        };
        winControllerApi.WinSymbolModel.__name__ = ["winControllerApi", "WinSymbolModel"];
        winControllerApi.WinSymbolModel.prototype.winSymbolsAssetMap = null;
        winControllerApi.WinSymbolModel.prototype.activeWinFramesAssetMap = null;
        winControllerApi.WinSymbolModel.prototype.inactiveWinFramesAssetMap = null;
        winControllerApi.WinSymbolModel.prototype.lineColors = null;
        winControllerApi.WinSymbolModel.prototype.getActiveFrameAssetId = function(symbolID) {
            return this.activeWinFramesAssetMap.get(symbolID);
        };
        winControllerApi.WinSymbolModel.prototype.getInactiveFrameAssetId = function(symbolID) {
            return this.inactiveWinFramesAssetMap.get(symbolID);
        };
        winControllerApi.WinSymbolModel.prototype.getWinSymbolAssetId = function(symbolID) {
            return this.winSymbolsAssetMap.get(symbolID);
        };
        winControllerApi.WinSymbolModel.prototype.setLineColor = function(id, color) {
            this.lineColors.h[id] = color;
        };
        winControllerApi.WinSymbolModel.prototype.getLineColor = function(id) {
            return this.lineColors.h[id];
        };
        winControllerApi.WinSymbolModel.prototype.__class__ = winControllerApi.WinSymbolModel;
        winControllerApi.FramePerSymbolsRelation = function(symbolId, activeFrameID, inactiveFrameID) {
            this.inactiveFrameID = inactiveFrameID;
            this.activeFrameID = activeFrameID;
            this.symbolId = symbolId;
        };
        winControllerApi.FramePerSymbolsRelation.__name__ = ["winControllerApi", "FramePerSymbolsRelation"];
        winControllerApi.FramePerSymbolsRelation.prototype.inactiveFrameID = null;
        winControllerApi.FramePerSymbolsRelation.prototype.activeFrameID = null;
        winControllerApi.FramePerSymbolsRelation.prototype.symbolId = null;
        winControllerApi.FramePerSymbolsRelation.prototype.__class__ = winControllerApi.FramePerSymbolsRelation;
        winControllerApi.SummaryRules = function(show, type) {
            this.show = false;
            this.type = type;
            this.show = show;
        };
        winControllerApi.SummaryRules.__name__ = ["winControllerApi", "SummaryRules"];
        winControllerApi.SummaryRules.prototype.show = null;
        winControllerApi.SummaryRules.prototype.type = null;
        winControllerApi.SummaryRules.prototype.__class__ = winControllerApi.SummaryRules;
        winControllerApi.Vector2D = function(x, y) {
            this.x = x;
            this.y = y;
        };
        winControllerApi.Vector2D.__name__ = ["winControllerApi", "Vector2D"];
        winControllerApi.Vector2D.prototype.x = null;
        winControllerApi.Vector2D.prototype.y = null;
        winControllerApi.Vector2D.prototype.get_y = function() {
            return this.y;
        };
        winControllerApi.Vector2D.prototype.get_x = function() {
            return this.x;
        };
        winControllerApi.Vector2D.prototype.__class__ = winControllerApi.Vector2D;
        winControllerApi.WinAnimationRules = function() {
            this.excludeScatterWinFromFreeze = false;
            this.restartEachWinAnimation = false;
            this.winLineInterval = 1000;
            this.showInactiveFrames = true;
            this.showActiveFrames = true;
            this.showSummary = new winControllerApi.SummaryRules(false, winControllerApi.SummaryRules.SUMMARY_TYPE_END);
            this.animateCurrentLineOnly = false;
        };
        winControllerApi.WinAnimationRules.__name__ = ["winControllerApi", "WinAnimationRules"];
        winControllerApi.WinAnimationRules.prototype.animateCurrentLineOnly = null;
        winControllerApi.WinAnimationRules.prototype.showSummary = null;
        winControllerApi.WinAnimationRules.prototype.showActiveFrames = null;
        winControllerApi.WinAnimationRules.prototype.showInactiveFrames = null;
        winControllerApi.WinAnimationRules.prototype.winLineInterval = null;
        winControllerApi.WinAnimationRules.prototype.restartEachWinAnimation = null;
        winControllerApi.WinAnimationRules.prototype.excludeScatterWinFromFreeze = null;
        winControllerApi.WinAnimationRules.prototype.__class__ = winControllerApi.WinAnimationRules;
        winControllerApi.WinControllerConfiguration = function() {
            this.framesAndSymbolsRelationMap = new _hcmn_.haxe_ds_StringMap();
            this.winAnimationRules = new winControllerApi.WinAnimationRules();
            this.winAnimationRules = new winControllerApi.WinAnimationRules();
            this.framesAndSymbolsRelationMap = new _hcmn_.haxe_ds_StringMap();
        };
        winControllerApi.WinControllerConfiguration.__name__ = ["winControllerApi", "WinControllerConfiguration"];
        winControllerApi.WinControllerConfiguration.prototype.winAnimationRules = null;
        winControllerApi.WinControllerConfiguration.prototype.framesAndSymbolsRelationMap = null;
        winControllerApi.WinControllerConfiguration.prototype.setFrameForSymbols = function(symbolIds, isActive, frameID) {
            var _g = 0;
            while (_g < symbolIds.length) {
                var symbol = symbolIds[_g];
                ++_g;
                if (isActive) {
                    if (!this.framesAndSymbolsRelationMap.exists(symbol)) {
                        var value = new winControllerApi.FramePerSymbolsRelation(symbol, "", "");
                        this.framesAndSymbolsRelationMap.set(symbol, value);
                    }
                    this.framesAndSymbolsRelationMap.get(symbol).activeFrameID = frameID;
                } else {
                    if (!this.framesAndSymbolsRelationMap.exists(symbol)) {
                        var value1 = new winControllerApi.FramePerSymbolsRelation(symbol, "", "");
                        this.framesAndSymbolsRelationMap.set(symbol, value1);
                    }
                    this.framesAndSymbolsRelationMap.get(symbol).inactiveFrameID = frameID;
                }
            }
        };
        winControllerApi.WinControllerConfiguration.prototype.setFrameForAll = function(isActive, frameID) {
            var $it0 = this.framesAndSymbolsRelationMap.keys();
            while ($it0.hasNext()) {
                var symbol = $it0.next();
                if (isActive) this.framesAndSymbolsRelationMap.get(symbol).activeFrameID = frameID;
                else this.framesAndSymbolsRelationMap.get(symbol).inactiveFrameID = frameID;
            }
        };
        winControllerApi.WinControllerConfiguration.prototype.__class__ = winControllerApi.WinControllerConfiguration;
        winControllerApi.BonusWinLine.TYPE = "BonusWinLine";;
        winControllerApi.SummaryRules.SUMMARY_TYPE_BEGINNING = "beginning";;
        winControllerApi.SummaryRules.SUMMARY_TYPE_END = "end";;
        winControllerApi.SummaryRules.SUMMARY_TYPE_ONLY = "only";;
        return {
            exports: winControllerApi
        };
    });
//# sourceURL=winControllerApi.js