define("slotModelApi", ["componentmodelComponentApi", "clientkernelEventbusApi", "moneyApi"],
    function(componentmodelComponentApi, clientkernelEventbusApi, moneyApi) {
        "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 slotModelApi == 'undefined') {
            var slotModelApi = {};
        };
        slotModelApi.SlotModelDeclaration = function() {};
        slotModelApi.SlotModelDeclaration = ck_implements(slotModelApi.SlotModelDeclaration, componentmodelComponentApi.IComponentDeclaration);
        slotModelApi.SlotModelDeclaration.__interfaces__ = [componentmodelComponentApi.IComponentDeclaration];
        slotModelApi.SlotModelDeclaration.__name__ = ["slotModelApi", "SlotModelDeclaration"];
        slotModelApi.SlotModelDeclaration.prototype.getChildComponents = function() {
            return null;
        };
        slotModelApi.SlotModelDeclaration.prototype.getReferredComponents = function() {
            return null;
        };
        slotModelApi.SlotModelDeclaration.prototype.getImplementedPorts = function() {
            return [slotModelApi.ISlotModelImplementationPort];
        };
        slotModelApi.SlotModelDeclaration.prototype.getUsedPorts = function() {
            return [slotModelApi.ISlotModelPort];
        };
        slotModelApi.SlotModelDeclaration.prototype.__class__ = slotModelApi.SlotModelDeclaration;

        slotModelApi.ISlotModelImplementationPort = function() {}
        slotModelApi.ISlotModelImplementationPort.prototype = {

            getStages: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameCommands: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameContext: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getError: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.ISlotModelPort = function() {}
        slotModelApi.ISlotModelPort.prototype = {

            getStages: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameCommands: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameContext: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getError: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.SlotModelPort = function(channel, $use) {
            if ($use) {
                this.stagesPort = slotModelApi.StagesPort["use"](channel);
                this.gameCommandsPort = slotModelApi.GameCommandsPort["use"](channel);
                this.gameContextPort = slotModelApi.GameContextPort["use"](channel);
                this.errorPort = slotModelApi.ErrorPort["use"](channel);
            } else {
                this.stagesPort = slotModelApi.StagesPort.provide(channel);
                this.gameCommandsPort = slotModelApi.GameCommandsPort.provide(channel);
                this.gameContextPort = slotModelApi.GameContextPort.provide(channel);
                this.errorPort = slotModelApi.ErrorPort.provide(channel);
            }
        };
        slotModelApi.SlotModelPort = ck_implements(slotModelApi.SlotModelPort, slotModelApi.ISlotModelPort);
        slotModelApi.SlotModelPort = ck_implements(slotModelApi.SlotModelPort, slotModelApi.ISlotModelImplementationPort);
        slotModelApi.SlotModelPort.__interfaces__ = [slotModelApi.ISlotModelPort, slotModelApi.ISlotModelImplementationPort];
        slotModelApi.SlotModelPort.__name__ = ["slotModelApi", "SlotModelPort"];
        slotModelApi.SlotModelPort.prototype.stagesPort = null;
        slotModelApi.SlotModelPort.prototype.gameCommandsPort = null;
        slotModelApi.SlotModelPort.prototype.gameContextPort = null;
        slotModelApi.SlotModelPort.prototype.errorPort = null;
        slotModelApi.SlotModelPort.prototype.getStages = function() {
            return this.stagesPort;
        };
        slotModelApi.SlotModelPort.prototype.getGameCommands = function() {
            return this.gameCommandsPort;
        };
        slotModelApi.SlotModelPort.prototype.getGameContext = function() {
            return this.gameContextPort;
        };
        slotModelApi.SlotModelPort.prototype.getError = function() {
            return this.errorPort;
        };
        slotModelApi.SlotModelPort.prototype.__class__ = slotModelApi.SlotModelPort;
        slotModelApi.SlotModelPortFactory = function() {};
        slotModelApi.SlotModelPortFactory = ck_implements(slotModelApi.SlotModelPortFactory, componentmodelComponentApi.IPortFactory);
        slotModelApi.SlotModelPortFactory.__interfaces__ = [componentmodelComponentApi.IPortFactory];
        slotModelApi.SlotModelPortFactory.__name__ = ["slotModelApi", "SlotModelPortFactory"];
        slotModelApi.SlotModelPortFactory.prototype.provide = function(channel) {
            return new slotModelApi.SlotModelPort(channel, false);
        };
        slotModelApi.SlotModelPortFactory.prototype["use"] = function(channel) {
            return new slotModelApi.SlotModelPort(channel, true);
        };
        slotModelApi.SlotModelPortFactory.prototype.__class__ = slotModelApi.SlotModelPortFactory;

        slotModelApi.IFeaturesPort = function() {}
        slotModelApi.IFeaturesPort.prototype = {

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

        slotModelApi.IFeaturesImplementationPort = function() {}
        slotModelApi.IFeaturesImplementationPort.prototype = {

            getExpandingWildsPort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlayerDecisionPort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.FeaturesPort = function(channel, $use) {
            if ($use) {
                this.expandingWildsPort = slotModelApi.ExpandingWildsPort["use"](channel);
                this.playerDecisionPort = slotModelApi.PlayerDecisionPort["use"](channel);
            } else {
                this.expandingWildsPort = slotModelApi.ExpandingWildsPort.provide(channel);
                this.playerDecisionPort = slotModelApi.PlayerDecisionPort.provide(channel);
            }
        };
        slotModelApi.FeaturesPort = ck_implements(slotModelApi.FeaturesPort, slotModelApi.IFeaturesPort);
        slotModelApi.FeaturesPort = ck_implements(slotModelApi.FeaturesPort, slotModelApi.IFeaturesImplementationPort);
        slotModelApi.FeaturesPort.__interfaces__ = [slotModelApi.IFeaturesPort, slotModelApi.IFeaturesImplementationPort];
        slotModelApi.FeaturesPort.__name__ = ["slotModelApi", "FeaturesPort"];
        slotModelApi.FeaturesPort.prototype.expandingWildsPort = null;
        slotModelApi.FeaturesPort.prototype.playerDecisionPort = null;
        slotModelApi.FeaturesPort.prototype.getExpandingWildsPort = function() {
            return this.expandingWildsPort;
        };
        slotModelApi.FeaturesPort.prototype.getPlayerDecisionPort = function() {
            return this.playerDecisionPort;
        };
        slotModelApi.FeaturesPort.provide = function(channel) {
            return new slotModelApi.FeaturesPort(channel, false);
        };
        slotModelApi.FeaturesPort["use"] = function(channel) {
            return new slotModelApi.FeaturesPort(channel, true);
        };
        slotModelApi.FeaturesPort.prototype.__class__ = slotModelApi.FeaturesPort;

        slotModelApi.IExpandingWildsPort = function() {}
        slotModelApi.IExpandingWildsPort.prototype = {

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

        slotModelApi.IExpandingWildsImplementationPort = function() {}
        slotModelApi.IExpandingWildsImplementationPort.prototype = {

            getStartExpandingWild: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getExpandingWildsPresented: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.ExpandingWildsPort = function(channel) {
            this.expandingWildsPresented = new clientkernelEventbusApi.Topic("slotmodel:expandingWildsPresented");
            this.startExpandingWild = new clientkernelEventbusApi.Topic("slotmodel:startExpandingWild");
            this.startExpandingWild.connect(channel);
            this.expandingWildsPresented.connect(channel);
        };
        slotModelApi.ExpandingWildsPort = ck_implements(slotModelApi.ExpandingWildsPort, slotModelApi.IExpandingWildsPort);
        slotModelApi.ExpandingWildsPort = ck_implements(slotModelApi.ExpandingWildsPort, slotModelApi.IExpandingWildsImplementationPort);
        slotModelApi.ExpandingWildsPort.__interfaces__ = [slotModelApi.IExpandingWildsPort, slotModelApi.IExpandingWildsImplementationPort];
        slotModelApi.ExpandingWildsPort.__name__ = ["slotModelApi", "ExpandingWildsPort"];
        slotModelApi.ExpandingWildsPort.prototype.startExpandingWild = null;
        slotModelApi.ExpandingWildsPort.prototype.expandingWildsPresented = null;
        slotModelApi.ExpandingWildsPort.prototype.getStartExpandingWild = function() {
            return this.startExpandingWild;
        };
        slotModelApi.ExpandingWildsPort.prototype.getExpandingWildsPresented = function() {
            return this.expandingWildsPresented;
        };
        slotModelApi.ExpandingWildsPort.provide = function(channel) {
            return new slotModelApi.ExpandingWildsPort(channel);
        };
        slotModelApi.ExpandingWildsPort["use"] = function(channel) {
            return new slotModelApi.ExpandingWildsPort(channel);
        };
        slotModelApi.ExpandingWildsPort.prototype.__class__ = slotModelApi.ExpandingWildsPort;
        slotModelApi.ExpandingWildsPresentedTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "ExpandingWildsPresented");
        };
        slotModelApi.ExpandingWildsPresentedTopic.__name__ = ["slotModelApi", "ExpandingWildsPresentedTopic"];
        slotModelApi.ExpandingWildsPresentedTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.ExpandingWildsPresentedTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.ExpandingWildsPresentedTopic.prototype.__class__ = slotModelApi.ExpandingWildsPresentedTopic;
        slotModelApi.StartExpandingWildTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "StartExpandingWild");
        };
        slotModelApi.StartExpandingWildTopic.__name__ = ["slotModelApi", "StartExpandingWildTopic"];
        slotModelApi.StartExpandingWildTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.StartExpandingWildTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.StartExpandingWildTopic.prototype.__class__ = slotModelApi.StartExpandingWildTopic;

        slotModelApi.IPlayerDecisionImplementationPort = function() {}
        slotModelApi.IPlayerDecisionImplementationPort.prototype = {

            getConfirmPlayerDecision: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getExitPlayerDecision: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEnterPlayerDecision: function(choices) {
                return {
                    arguments: ["array"],
                    returns: "*"
                };
            },
            getUpdatePlayerDecisionsPending: function(playerDecisionsPending) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getPlayerDecisionEntered: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlayerDecisionExited: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlayerDecisionSelected: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IPlayerDecisionPort = function() {}
        slotModelApi.IPlayerDecisionPort.prototype = {

            getConfirmPlayerDecision: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getExitPlayerDecision: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEnterPlayerDecision: function(choices) {
                return {
                    arguments: ["array"],
                    returns: "*"
                };
            },
            getUpdatePlayerDecisionsPending: function(playerDecisionsPending) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getPlayerDecisionEntered: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlayerDecisionExited: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlayerDecisionSelected: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.PlayerDecisionPort = function(channel) {
            this.playerDecisionSelected = new clientkernelEventbusApi.Topic("slotmodel:playerDecisionSelected");
            this.playerDecisionExited = new clientkernelEventbusApi.Topic("slotmodel:playerDecisionExited");
            this.playerDecisionEntered = new clientkernelEventbusApi.Topic("slotmodel:playerDecisionEntered");
            this.updatePlayerDecisionsPending = new clientkernelEventbusApi.Topic("slotmodel:updatePlayerDecisionsPending");
            this.exitPlayerDecision = new clientkernelEventbusApi.Topic("slotmodel:exitPlayerDecision");
            this.enterPlayerDecision = new clientkernelEventbusApi.Topic("slotmodel:enterPlayerDecision");
            this.confirmPlayerDecision = new clientkernelEventbusApi.Topic("slotmodel:confirmPlayerDecision");
            this.confirmPlayerDecision.connect(channel);
            this.enterPlayerDecision.connect(channel);
            this.exitPlayerDecision.connect(channel);
            this.updatePlayerDecisionsPending.connect(channel);
            this.playerDecisionEntered.connect(channel);
            this.playerDecisionExited.connect(channel);
            this.playerDecisionSelected.connect(channel);
        };
        slotModelApi.PlayerDecisionPort = ck_implements(slotModelApi.PlayerDecisionPort, slotModelApi.IPlayerDecisionPort);
        slotModelApi.PlayerDecisionPort = ck_implements(slotModelApi.PlayerDecisionPort, slotModelApi.IPlayerDecisionImplementationPort);
        slotModelApi.PlayerDecisionPort.__interfaces__ = [slotModelApi.IPlayerDecisionPort, slotModelApi.IPlayerDecisionImplementationPort];
        slotModelApi.PlayerDecisionPort.__name__ = ["slotModelApi", "PlayerDecisionPort"];
        slotModelApi.PlayerDecisionPort.prototype.confirmPlayerDecision = null;
        slotModelApi.PlayerDecisionPort.prototype.enterPlayerDecision = null;
        slotModelApi.PlayerDecisionPort.prototype.exitPlayerDecision = null;
        slotModelApi.PlayerDecisionPort.prototype.updatePlayerDecisionsPending = null;
        slotModelApi.PlayerDecisionPort.prototype.playerDecisionEntered = null;
        slotModelApi.PlayerDecisionPort.prototype.playerDecisionExited = null;
        slotModelApi.PlayerDecisionPort.prototype.playerDecisionSelected = null;
        slotModelApi.PlayerDecisionPort.prototype.getConfirmPlayerDecision = function() {
            return this.confirmPlayerDecision;
        };
        slotModelApi.PlayerDecisionPort.prototype.getExitPlayerDecision = function() {
            return this.exitPlayerDecision;
        };
        slotModelApi.PlayerDecisionPort.prototype.getEnterPlayerDecision = function(choices) {
            return this.enterPlayerDecision;
        };
        slotModelApi.PlayerDecisionPort.prototype.getUpdatePlayerDecisionsPending = function(playerDecisionsPending) {
            return this.updatePlayerDecisionsPending;
        };
        slotModelApi.PlayerDecisionPort.prototype.getPlayerDecisionEntered = function() {
            return this.playerDecisionEntered;
        };
        slotModelApi.PlayerDecisionPort.prototype.getPlayerDecisionExited = function() {
            return this.playerDecisionExited;
        };
        slotModelApi.PlayerDecisionPort.prototype.getPlayerDecisionSelected = function() {
            return this.playerDecisionSelected;
        };
        slotModelApi.PlayerDecisionPort.provide = function(channel) {
            return new slotModelApi.PlayerDecisionPort(channel);
        };
        slotModelApi.PlayerDecisionPort["use"] = function(channel) {
            return new slotModelApi.PlayerDecisionPort(channel);
        };
        slotModelApi.PlayerDecisionPort.prototype.__class__ = slotModelApi.PlayerDecisionPort;
        slotModelApi.ConfirmPlayerDecisionTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "ConfirmPlayerDecision");
        };
        slotModelApi.ConfirmPlayerDecisionTopic.__name__ = ["slotModelApi", "ConfirmPlayerDecisionTopic"];
        slotModelApi.ConfirmPlayerDecisionTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.ConfirmPlayerDecisionTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.ConfirmPlayerDecisionTopic.prototype.__class__ = slotModelApi.ConfirmPlayerDecisionTopic;
        slotModelApi.EnterPlayerDecisionTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "RequestPlayerDecision");
        };
        slotModelApi.EnterPlayerDecisionTopic.__name__ = ["slotModelApi", "EnterPlayerDecisionTopic"];
        slotModelApi.EnterPlayerDecisionTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.EnterPlayerDecisionTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.EnterPlayerDecisionTopic.prototype.__class__ = slotModelApi.EnterPlayerDecisionTopic;
        slotModelApi.ExitPlayerDecisionTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "ExitPlayerDecision");
        };
        slotModelApi.ExitPlayerDecisionTopic.__name__ = ["slotModelApi", "ExitPlayerDecisionTopic"];
        slotModelApi.ExitPlayerDecisionTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.ExitPlayerDecisionTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.ExitPlayerDecisionTopic.prototype.__class__ = slotModelApi.ExitPlayerDecisionTopic;
        slotModelApi.PlayerDecisionEnteredTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "PlayerDecisionEntered");
        };
        slotModelApi.PlayerDecisionEnteredTopic.__name__ = ["slotModelApi", "PlayerDecisionEnteredTopic"];
        slotModelApi.PlayerDecisionEnteredTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.PlayerDecisionEnteredTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.PlayerDecisionEnteredTopic.prototype.__class__ = slotModelApi.PlayerDecisionEnteredTopic;
        slotModelApi.PlayerDecisionExitedTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "PlayerDecisionExited");
        };
        slotModelApi.PlayerDecisionExitedTopic.__name__ = ["slotModelApi", "PlayerDecisionExitedTopic"];
        slotModelApi.PlayerDecisionExitedTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.PlayerDecisionExitedTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.PlayerDecisionExitedTopic.prototype.__class__ = slotModelApi.PlayerDecisionExitedTopic;
        slotModelApi.PlayerDecisionSelectedTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "PlayerDecisionSelected");
        };
        slotModelApi.PlayerDecisionSelectedTopic.__name__ = ["slotModelApi", "PlayerDecisionSelectedTopic"];
        slotModelApi.PlayerDecisionSelectedTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.PlayerDecisionSelectedTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.PlayerDecisionSelectedTopic.prototype.__class__ = slotModelApi.PlayerDecisionSelectedTopic;
        slotModelApi.UpdatePlayerDecisionsPendingTopic = function() {
            clientkernelEventbusApi.Topic.call(this, "UpdatePlayerDecisionsPending");
        };
        slotModelApi.UpdatePlayerDecisionsPendingTopic.__name__ = ["slotModelApi", "UpdatePlayerDecisionsPendingTopic"];
        slotModelApi.UpdatePlayerDecisionsPendingTopic.__super__ = clientkernelEventbusApi.Topic;
        for (var k in clientkernelEventbusApi.Topic.prototype) slotModelApi.UpdatePlayerDecisionsPendingTopic.prototype[k] = clientkernelEventbusApi.Topic.prototype[k];
        slotModelApi.UpdatePlayerDecisionsPendingTopic.prototype.__class__ = slotModelApi.UpdatePlayerDecisionsPendingTopic;

        slotModelApi.IDraftGameCommandsPort = function() {}
        slotModelApi.IDraftGameCommandsPort.prototype = {

            getSkipCommandLabelState: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStakeCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStakeCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getstopCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getTestContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IDraftGameCommandsImplementationPort = function() {}
        slotModelApi.IDraftGameCommandsImplementationPort.prototype = {

            getSkipCommandLabelState: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStakeCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStakeCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getstopCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getTestContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.DraftGameCommandsPort = function(channel) {
            this.stopCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:stopCommandExecuted");
            this.testContinueCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:testContinueCommandExecuted");
            this.continueCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:continueCommandExecuted");
            this.spinCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:spinCommandExecuted");
            this.stakeCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:stakeCommandExecuted");
            this.paytableCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:paytableCommandExecuted");
            this.helpCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:helpCommandExecuted");
            this.stopCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:stopCommandAvailable");
            this.continueCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:continueCommandAvailable");
            this.spinCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:spinCommandAvailable");
            this.stakeCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:stakeCommandAvailable");
            this.skipCommandLabelState = new clientkernelEventbusApi.Topic("slotmodel:skipCommandLabelState");
            this.paytableCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:paytableCommandAvailable");
            this.helpCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:helpCommandAvailable");
            this.helpCommandAvailable.connect(channel);
            this.paytableCommandAvailable.connect(channel);
            this.skipCommandLabelState.connect(channel);
            this.stakeCommandAvailable.connect(channel);
            this.spinCommandAvailable.connect(channel);
            this.continueCommandAvailable.connect(channel);
            this.stopCommandAvailable.connect(channel);
            this.helpCommandExecuted.connect(channel);
            this.paytableCommandExecuted.connect(channel);
            this.stakeCommandExecuted.connect(channel);
            this.spinCommandExecuted.connect(channel);
            this.continueCommandExecuted.connect(channel);
            this.testContinueCommandExecuted.connect(channel);
            this.stopCommandExecuted.connect(channel);
        };
        slotModelApi.DraftGameCommandsPort = ck_implements(slotModelApi.DraftGameCommandsPort, slotModelApi.IDraftGameCommandsPort);
        slotModelApi.DraftGameCommandsPort = ck_implements(slotModelApi.DraftGameCommandsPort, slotModelApi.IDraftGameCommandsImplementationPort);
        slotModelApi.DraftGameCommandsPort.__interfaces__ = [slotModelApi.IDraftGameCommandsPort, slotModelApi.IDraftGameCommandsImplementationPort];
        slotModelApi.DraftGameCommandsPort.__name__ = ["slotModelApi", "DraftGameCommandsPort"];
        slotModelApi.DraftGameCommandsPort.prototype.helpCommandAvailable = null;
        slotModelApi.DraftGameCommandsPort.prototype.paytableCommandAvailable = null;
        slotModelApi.DraftGameCommandsPort.prototype.skipCommandLabelState = null;
        slotModelApi.DraftGameCommandsPort.prototype.stakeCommandAvailable = null;
        slotModelApi.DraftGameCommandsPort.prototype.spinCommandAvailable = null;
        slotModelApi.DraftGameCommandsPort.prototype.continueCommandAvailable = null;
        slotModelApi.DraftGameCommandsPort.prototype.stopCommandAvailable = null;
        slotModelApi.DraftGameCommandsPort.prototype.helpCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.paytableCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.stakeCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.spinCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.continueCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.testContinueCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.stopCommandExecuted = null;
        slotModelApi.DraftGameCommandsPort.prototype.getSkipCommandLabelState = function() {
            return this.skipCommandLabelState;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getStakeCommandAvailable = function() {
            return this.stakeCommandAvailable;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getHelpCommandAvailable = function() {
            return this.helpCommandAvailable;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getPaytableCommandAvailable = function() {
            return this.paytableCommandAvailable;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getSpinCommandAvailable = function() {
            return this.spinCommandAvailable;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getContinueCommandAvailable = function() {
            return this.continueCommandAvailable;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getStopCommandAvailable = function() {
            return this.stopCommandAvailable;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getStakeCommandExecuted = function() {
            return this.stakeCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getHelpCommandExecuted = function() {
            return this.helpCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getPaytableCommandExecuted = function() {
            return this.paytableCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getSpinCommandExecuted = function() {
            return this.spinCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getContinueCommandExecuted = function() {
            return this.continueCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getTestContinueCommandExecuted = function() {
            return this.testContinueCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.prototype.getstopCommandExecuted = function() {
            return this.stopCommandExecuted;
        };
        slotModelApi.DraftGameCommandsPort.provide = function(channel) {
            return new slotModelApi.DraftGameCommandsPort(channel);
        };
        slotModelApi.DraftGameCommandsPort["use"] = function(channel) {
            return new slotModelApi.DraftGameCommandsPort(channel);
        };
        slotModelApi.DraftGameCommandsPort.prototype.__class__ = slotModelApi.DraftGameCommandsPort;

        slotModelApi.IDraftGameContextPort = function() {}
        slotModelApi.IDraftGameContextPort.prototype = {

            getBalance: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameOptionChanged: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRegisterGameOption: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IDraftGameContextImplementationPort = function() {}
        slotModelApi.IDraftGameContextImplementationPort.prototype = {

            getBalance: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameOptionChanged: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRegisterGameOption: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        if (typeof slotmodel == 'undefined') {
            var slotmodel = {};
        };
        if (!slotmodel.api) {
            slotmodel.api = {};
        };
        if (!slotmodel.api.port) {
            slotmodel.api.port = {};
        };
        if (!slotmodel.api.port.draft) {
            slotmodel.api.port.draft = {};
        };
        if (!slotmodel.api.port.draft.gamecontext) {
            slotmodel.api.port.draft.gamecontext = {};
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort = function(channel) {
            this.registerGameOption = new clientkernelEventbusApi.Topic("slotmodel:registerGameOption");
            this.gameOptionChanged = new clientkernelEventbusApi.Topic("slotmodel:gameOptionChanged");
            this.balance = new clientkernelEventbusApi.Topic("slotmodel:balance");
            this.balance.connect(channel);
            this.gameOptionChanged.connect(channel);
            this.registerGameOption.connect(channel);
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort = ck_implements(slotmodel.api.port.draft.gamecontext.GameContextPort, slotModelApi.IDraftGameContextPort);
        slotmodel.api.port.draft.gamecontext.GameContextPort = ck_implements(slotmodel.api.port.draft.gamecontext.GameContextPort, slotModelApi.IDraftGameContextImplementationPort);
        slotmodel.api.port.draft.gamecontext.GameContextPort.__interfaces__ = [slotModelApi.IDraftGameContextPort, slotModelApi.IDraftGameContextImplementationPort];
        slotmodel.api.port.draft.gamecontext.GameContextPort.__name__ = ["slotmodel", "api", "port", "draft", "gamecontext", "GameContextPort"];
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.balance = null;
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.gameOptionChanged = null;
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.registerGameOption = null;
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.getBalance = function() {
            return this.balance;
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.getGameOptionChanged = function() {
            return this.gameOptionChanged;
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.getRegisterGameOption = function() {
            return this.registerGameOption;
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort.provide = function(channel) {
            return new slotmodel.api.port.draft.gamecontext.GameContextPort(channel);
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort["use"] = function(channel) {
            return new slotmodel.api.port.draft.gamecontext.GameContextPort(channel);
        };
        slotmodel.api.port.draft.gamecontext.GameContextPort.prototype.__class__ = slotmodel.api.port.draft.gamecontext.GameContextPort;
        slotModelApi.DashboardTextPayload = {
            __ename__: ["slotModelApi", "DashboardTextPayload"],
            __constructs__: ["TEXT_EMPTY", "TEXT_WIN_LINE", "TEXT_WIN_SCATTER", "TEXT_WIN_FREE_GAME_TOTAL", "TEXT_TRIGGER_FREE_GAME", "TEXT_RETRIGGER_FREE_GAME", "TEXT_FREE_GAME_PAYS", "TEXT_BASE_GAME_PAYS"]
        };
        slotModelApi.DashboardTextPayload.TEXT_RETRIGGER_FREE_GAME = ["TEXT_RETRIGGER_FREE_GAME", 5];
        slotModelApi.DashboardTextPayload.TEXT_RETRIGGER_FREE_GAME.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_RETRIGGER_FREE_GAME.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_BASE_GAME_PAYS = ["TEXT_BASE_GAME_PAYS", 7];
        slotModelApi.DashboardTextPayload.TEXT_BASE_GAME_PAYS.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_BASE_GAME_PAYS.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_FREE_GAME_PAYS = ["TEXT_FREE_GAME_PAYS", 6];
        slotModelApi.DashboardTextPayload.TEXT_FREE_GAME_PAYS.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_FREE_GAME_PAYS.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_WIN_FREE_GAME_TOTAL = ["TEXT_WIN_FREE_GAME_TOTAL", 3];
        slotModelApi.DashboardTextPayload.TEXT_WIN_FREE_GAME_TOTAL.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_WIN_FREE_GAME_TOTAL.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_TRIGGER_FREE_GAME = ["TEXT_TRIGGER_FREE_GAME", 4];
        slotModelApi.DashboardTextPayload.TEXT_TRIGGER_FREE_GAME.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_TRIGGER_FREE_GAME.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_WIN_LINE = ["TEXT_WIN_LINE", 1];
        slotModelApi.DashboardTextPayload.TEXT_WIN_LINE.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_WIN_LINE.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_WIN_SCATTER = ["TEXT_WIN_SCATTER", 2];
        slotModelApi.DashboardTextPayload.TEXT_WIN_SCATTER.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_WIN_SCATTER.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.DashboardTextPayload.TEXT_EMPTY = ["TEXT_EMPTY", 0];
        slotModelApi.DashboardTextPayload.TEXT_EMPTY.toString = $estr;
        slotModelApi.DashboardTextPayload.TEXT_EMPTY.__enum__ = slotModelApi.DashboardTextPayload;
        slotModelApi.FreeGameCounter = function(currentSpinCount, totalSpinCount, multiplier) {
            this.multiplier = multiplier;
            this.totalSpinCount = totalSpinCount;
            this.currentSpinCount = currentSpinCount;
        };
        slotModelApi.FreeGameCounter.__name__ = ["slotModelApi", "FreeGameCounter"];
        slotModelApi.FreeGameCounter.prototype.multiplier = null;
        slotModelApi.FreeGameCounter.prototype.totalSpinCount = null;
        slotModelApi.FreeGameCounter.prototype.currentSpinCount = null;
        slotModelApi.FreeGameCounter.prototype.toString = function() {
            return "[FreeGameCounter] currentSpinCount: $currentSpinCount, totalSpinCount: $totalSpinCount, multiplier: $multiplier";
        };
        slotModelApi.FreeGameCounter.prototype.__class__ = slotModelApi.FreeGameCounter;
        slotModelApi.FreeGameOutcome = function(totalFreeGameWin, showCongratulations) {
            this.totalFreeGameWin = totalFreeGameWin;
            this.showCongratulations = showCongratulations;
        };
        slotModelApi.FreeGameOutcome.__name__ = ["slotModelApi", "FreeGameOutcome"];
        slotModelApi.FreeGameOutcome.prototype.totalFreeGameWin = null;
        slotModelApi.FreeGameOutcome.prototype.showCongratulations = null;
        slotModelApi.FreeGameOutcome.prototype.__class__ = slotModelApi.FreeGameOutcome;
        slotModelApi.KeyValuePairPayload = function(key, value) {
            this.key = key;
            this.value = value;
        };
        slotModelApi.KeyValuePairPayload.__name__ = ["slotModelApi", "KeyValuePairPayload"];
        slotModelApi.KeyValuePairPayload.prototype.key = null;
        slotModelApi.KeyValuePairPayload.prototype.value = null;
        slotModelApi.KeyValuePairPayload.prototype.__class__ = slotModelApi.KeyValuePairPayload;
        slotModelApi.ReasonPayload = {
            __ename__: ["slotModelApi", "ReasonPayload"],
            __constructs__: ["BUTTON_SPIN_PRESSED", "BUTTON_STAKE_PRESSED", "BUTTON_PAYTABLE_PRESSED"]
        };
        slotModelApi.ReasonPayload.BUTTON_PAYTABLE_PRESSED = ["BUTTON_PAYTABLE_PRESSED", 2];
        slotModelApi.ReasonPayload.BUTTON_PAYTABLE_PRESSED.toString = $estr;
        slotModelApi.ReasonPayload.BUTTON_PAYTABLE_PRESSED.__enum__ = slotModelApi.ReasonPayload;
        slotModelApi.ReasonPayload.BUTTON_STAKE_PRESSED = ["BUTTON_STAKE_PRESSED", 1];
        slotModelApi.ReasonPayload.BUTTON_STAKE_PRESSED.toString = $estr;
        slotModelApi.ReasonPayload.BUTTON_STAKE_PRESSED.__enum__ = slotModelApi.ReasonPayload;
        slotModelApi.ReasonPayload.BUTTON_SPIN_PRESSED = ["BUTTON_SPIN_PRESSED", 0];
        slotModelApi.ReasonPayload.BUTTON_SPIN_PRESSED.toString = $estr;
        slotModelApi.ReasonPayload.BUTTON_SPIN_PRESSED.__enum__ = slotModelApi.ReasonPayload;

        slotModelApi.IFreeSpinStagePort = function() {}
        slotModelApi.IFreeSpinStagePort.prototype = {

            getBootstrapFreeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDecideFreeGameFlow: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDisplayRetriggerNotification: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEnterFreeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getInitiateFreeGameOutro: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getLeaveFreeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformOutro: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformPlayerDecision: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformRetrigger: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getUpdateFreeGameCounter: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFreeGameExited: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFreeGameOutroEntered: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFreeGameOutroExited: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRetriggerNotificationFinished: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IFreeSpinStageImplementationPort = function() {}
        slotModelApi.IFreeSpinStageImplementationPort.prototype = {

            getBootstrapFreeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDecideFreeGameFlow: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDisplayRetriggerNotification: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEnterFreeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getInitiateFreeGameOutro: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getLeaveFreeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformOutro: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformPlayerDecision: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformRetrigger: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPerformSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getUpdateFreeGameCounter: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFreeGameExited: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFreeGameOutroEntered: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFreeGameOutroExited: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRetriggerNotificationFinished: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.FreeSpinStagePort = function(channel) {
            this.retriggerNotificationFinished = new clientkernelEventbusApi.Topic("slotmodel:retriggerNotificationFinished");
            this.freeGameOutroExited = new clientkernelEventbusApi.Topic("slotmodel:freeGameOutroExited");
            this.freeGameOutroEntered = new clientkernelEventbusApi.Topic("slotmodel:freeGameOutroEntered");
            this.freeGameExited = new clientkernelEventbusApi.Topic("slotmodel:freeGameExited");
            this.updateFreeGameCounter = new clientkernelEventbusApi.Topic("slotmodel:updateFreeGameCounter");
            this.performSpin = new clientkernelEventbusApi.Topic("slotmodel:performSpin");
            this.performRetrigger = new clientkernelEventbusApi.Topic("slotmodel:performRetrigger");
            this.performPlayerDecision = new clientkernelEventbusApi.Topic("slotmodel:performPlayerDecision");
            this.performOutro = new clientkernelEventbusApi.Topic("slotmodel:performOutro");
            this.leaveFreeGame = new clientkernelEventbusApi.Topic("slotmodel:leaveFreeGame");
            this.initiateFreeGameOutro = new clientkernelEventbusApi.Topic("slotmodel:initiateFreeGameOutro");
            this.enterFreeGame = new clientkernelEventbusApi.Topic("slotmodel:enterFreeGame");
            this.displayRetriggerNotification = new clientkernelEventbusApi.Topic("slotmodel:displayRetriggerNotification");
            this.decideFreeGameFlow = new clientkernelEventbusApi.Topic("slotmodel:decideFreeGameFlow");
            this.bootstrapFreeGame = new clientkernelEventbusApi.Topic("slotmodel:bootstrapFreeGame");
            this.bootstrapFreeGame.connect(channel);
            this.decideFreeGameFlow.connect(channel);
            this.displayRetriggerNotification.connect(channel);
            this.enterFreeGame.connect(channel);
            this.initiateFreeGameOutro.connect(channel);
            this.leaveFreeGame.connect(channel);
            this.performOutro.connect(channel);
            this.performPlayerDecision.connect(channel);
            this.performRetrigger.connect(channel);
            this.performSpin.connect(channel);
            this.updateFreeGameCounter.connect(channel);
            this.freeGameExited.connect(channel);
            this.freeGameOutroEntered.connect(channel);
            this.freeGameOutroExited.connect(channel);
            this.retriggerNotificationFinished.connect(channel);
        };
        slotModelApi.FreeSpinStagePort = ck_implements(slotModelApi.FreeSpinStagePort, slotModelApi.IFreeSpinStagePort);
        slotModelApi.FreeSpinStagePort = ck_implements(slotModelApi.FreeSpinStagePort, slotModelApi.IFreeSpinStageImplementationPort);
        slotModelApi.FreeSpinStagePort.__interfaces__ = [slotModelApi.IFreeSpinStagePort, slotModelApi.IFreeSpinStageImplementationPort];
        slotModelApi.FreeSpinStagePort.__name__ = ["slotModelApi", "FreeSpinStagePort"];
        slotModelApi.FreeSpinStagePort.prototype.bootstrapFreeGame = null;
        slotModelApi.FreeSpinStagePort.prototype.decideFreeGameFlow = null;
        slotModelApi.FreeSpinStagePort.prototype.displayRetriggerNotification = null;
        slotModelApi.FreeSpinStagePort.prototype.enterFreeGame = null;
        slotModelApi.FreeSpinStagePort.prototype.initiateFreeGameOutro = null;
        slotModelApi.FreeSpinStagePort.prototype.leaveFreeGame = null;
        slotModelApi.FreeSpinStagePort.prototype.performOutro = null;
        slotModelApi.FreeSpinStagePort.prototype.performPlayerDecision = null;
        slotModelApi.FreeSpinStagePort.prototype.performRetrigger = null;
        slotModelApi.FreeSpinStagePort.prototype.performSpin = null;
        slotModelApi.FreeSpinStagePort.prototype.updateFreeGameCounter = null;
        slotModelApi.FreeSpinStagePort.prototype.freeGameExited = null;
        slotModelApi.FreeSpinStagePort.prototype.freeGameOutroEntered = null;
        slotModelApi.FreeSpinStagePort.prototype.freeGameOutroExited = null;
        slotModelApi.FreeSpinStagePort.prototype.retriggerNotificationFinished = null;
        slotModelApi.FreeSpinStagePort.prototype.getBootstrapFreeGame = function() {
            return this.bootstrapFreeGame;
        };
        slotModelApi.FreeSpinStagePort.prototype.getDecideFreeGameFlow = function() {
            return this.decideFreeGameFlow;
        };
        slotModelApi.FreeSpinStagePort.prototype.getDisplayRetriggerNotification = function() {
            return this.displayRetriggerNotification;
        };
        slotModelApi.FreeSpinStagePort.prototype.getEnterFreeGame = function() {
            return this.enterFreeGame;
        };
        slotModelApi.FreeSpinStagePort.prototype.getInitiateFreeGameOutro = function() {
            return this.initiateFreeGameOutro;
        };
        slotModelApi.FreeSpinStagePort.prototype.getLeaveFreeGame = function() {
            return this.leaveFreeGame;
        };
        slotModelApi.FreeSpinStagePort.prototype.getPerformOutro = function() {
            return this.performOutro;
        };
        slotModelApi.FreeSpinStagePort.prototype.getPerformPlayerDecision = function() {
            return this.performPlayerDecision;
        };
        slotModelApi.FreeSpinStagePort.prototype.getPerformRetrigger = function() {
            return this.performRetrigger;
        };
        slotModelApi.FreeSpinStagePort.prototype.getPerformSpin = function() {
            return this.performSpin;
        };
        slotModelApi.FreeSpinStagePort.prototype.getUpdateFreeGameCounter = function() {
            return this.updateFreeGameCounter;
        };
        slotModelApi.FreeSpinStagePort.prototype.getFreeGameExited = function() {
            return this.freeGameExited;
        };
        slotModelApi.FreeSpinStagePort.prototype.getFreeGameOutroEntered = function() {
            return this.freeGameOutroEntered;
        };
        slotModelApi.FreeSpinStagePort.prototype.getFreeGameOutroExited = function() {
            return this.freeGameOutroExited;
        };
        slotModelApi.FreeSpinStagePort.prototype.getRetriggerNotificationFinished = function() {
            return this.retriggerNotificationFinished;
        };
        slotModelApi.FreeSpinStagePort.provide = function(channel) {
            return new slotModelApi.FreeSpinStagePort(channel);
        };
        slotModelApi.FreeSpinStagePort["use"] = function(channel) {
            return new slotModelApi.FreeSpinStagePort(channel);
        };
        slotModelApi.FreeSpinStagePort.prototype.__class__ = slotModelApi.FreeSpinStagePort;

        slotModelApi.IDraftIdleStagePort = function() {}
        slotModelApi.IDraftIdleStagePort.prototype = {

            getConfirmSelectedStake: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenHelp: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenPaytable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getCloseHelp: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getClosePaytable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpOpened: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableOpened: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpClosed: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableClosed: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IDraftIdleStageImplementationPort = function() {}
        slotModelApi.IDraftIdleStageImplementationPort.prototype = {

            getConfirmSelectedStake: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenHelp: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenPaytable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getCloseHelp: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getClosePaytable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpOpened: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableOpened: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpClosed: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableClosed: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.DraftIdleStagePort = function(channel) {
            this.paytableClosed = new clientkernelEventbusApi.Topic("slotmodel:paytableClosed");
            this.helpClosed = new clientkernelEventbusApi.Topic("slotmodel:helpClosed");
            this.paytableOpened = new clientkernelEventbusApi.Topic("slotmodel:paytableOpened");
            this.helpOpened = new clientkernelEventbusApi.Topic("slotmodel:helpOpened");
            this.closeHelp = new clientkernelEventbusApi.Topic("slotmodel:closeHelp");
            this.closePaytable = new clientkernelEventbusApi.Topic("slotmodel:closePaytable");
            this.openPaytable = new clientkernelEventbusApi.Topic("slotmodel:openPaytable");
            this.openHelp = new clientkernelEventbusApi.Topic("slotmodel:openHelp");
            this.confirmSelectedStake = new clientkernelEventbusApi.Topic("slotmodel:confirmSelectedStake");
            this.confirmSelectedStake.connect(channel);
            this.openHelp.connect(channel);
            this.openPaytable.connect(channel);
            this.closeHelp.connect(channel);
            this.closePaytable.connect(channel);
            this.helpOpened.connect(channel);
            this.paytableOpened.connect(channel);
            this.helpClosed.connect(channel);
            this.paytableClosed.connect(channel);
        };
        slotModelApi.DraftIdleStagePort = ck_implements(slotModelApi.DraftIdleStagePort, slotModelApi.IDraftIdleStagePort);
        slotModelApi.DraftIdleStagePort = ck_implements(slotModelApi.DraftIdleStagePort, slotModelApi.IDraftIdleStageImplementationPort);
        slotModelApi.DraftIdleStagePort.__interfaces__ = [slotModelApi.IDraftIdleStagePort, slotModelApi.IDraftIdleStageImplementationPort];
        slotModelApi.DraftIdleStagePort.__name__ = ["slotModelApi", "DraftIdleStagePort"];
        slotModelApi.DraftIdleStagePort.prototype.confirmSelectedStake = null;
        slotModelApi.DraftIdleStagePort.prototype.openHelp = null;
        slotModelApi.DraftIdleStagePort.prototype.openPaytable = null;
        slotModelApi.DraftIdleStagePort.prototype.closePaytable = null;
        slotModelApi.DraftIdleStagePort.prototype.closeHelp = null;
        slotModelApi.DraftIdleStagePort.prototype.helpOpened = null;
        slotModelApi.DraftIdleStagePort.prototype.paytableOpened = null;
        slotModelApi.DraftIdleStagePort.prototype.helpClosed = null;
        slotModelApi.DraftIdleStagePort.prototype.paytableClosed = null;
        slotModelApi.DraftIdleStagePort.prototype.getConfirmSelectedStake = function() {
            return this.confirmSelectedStake;
        };
        slotModelApi.DraftIdleStagePort.prototype.getOpenHelp = function() {
            return this.openHelp;
        };
        slotModelApi.DraftIdleStagePort.prototype.getOpenPaytable = function() {
            return this.openPaytable;
        };
        slotModelApi.DraftIdleStagePort.prototype.getCloseHelp = function() {
            return this.closeHelp;
        };
        slotModelApi.DraftIdleStagePort.prototype.getClosePaytable = function() {
            return this.closePaytable;
        };
        slotModelApi.DraftIdleStagePort.prototype.getHelpOpened = function() {
            return this.helpOpened;
        };
        slotModelApi.DraftIdleStagePort.prototype.getPaytableOpened = function() {
            return this.paytableOpened;
        };
        slotModelApi.DraftIdleStagePort.prototype.getHelpClosed = function() {
            return this.helpClosed;
        };
        slotModelApi.DraftIdleStagePort.prototype.getPaytableClosed = function() {
            return this.paytableClosed;
        };
        slotModelApi.DraftIdleStagePort.provide = function(channel) {
            return new slotModelApi.DraftIdleStagePort(channel);
        };
        slotModelApi.DraftIdleStagePort["use"] = function(channel) {
            return new slotModelApi.DraftIdleStagePort(channel);
        };
        slotModelApi.DraftIdleStagePort.prototype.__class__ = slotModelApi.DraftIdleStagePort;

        slotModelApi.IIntroImplementationPort = function() {}
        slotModelApi.IIntroImplementationPort.prototype = {

            getCloseIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getShowIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmCloseIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmShowIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIntroScreenCancelled: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIntroScreenTimedOut: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIntroScreenCompletelyClosed: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IIntroPort = function() {}
        slotModelApi.IIntroPort.prototype = {

            getCloseIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getShowIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmCloseIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmShowIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIntroScreenCancelled: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIntroScreenTimedOut: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIntroScreenCompletelyClosed: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.IntroPort = function(channel) {
            this.introScreenCompletelyClosed = new clientkernelEventbusApi.Topic("slotmodel:introScreenCompletelyClosed");
            this.introScreenTimedOut = new clientkernelEventbusApi.Topic("slotmodel:introScreenTimedOut");
            this.introScreenCancelled = new clientkernelEventbusApi.Topic("slotmodel:introScreenCancelled");
            this.confirmShowIntroScreen = new clientkernelEventbusApi.Topic("slotmodel:confirmShowIntroScreen");
            this.confirmCloseIntroScreen = new clientkernelEventbusApi.Topic("slotmodel:confirmCloseIntroScreen");
            this.showIntroScreen = new clientkernelEventbusApi.Topic("slotmodel:showIntroScreen");
            this.closeIntroScreen = new clientkernelEventbusApi.Topic("slotmodel:closeIntroScreen");
            this.closeIntroScreen.connect(channel);
            this.showIntroScreen.connect(channel);
            this.confirmCloseIntroScreen.connect(channel);
            this.confirmShowIntroScreen.connect(channel);
            this.introScreenCancelled.connect(channel);
            this.introScreenTimedOut.connect(channel);
            this.introScreenCompletelyClosed.connect(channel);
        };
        slotModelApi.IntroPort = ck_implements(slotModelApi.IntroPort, slotModelApi.IIntroPort);
        slotModelApi.IntroPort = ck_implements(slotModelApi.IntroPort, slotModelApi.IIntroImplementationPort);
        slotModelApi.IntroPort.__interfaces__ = [slotModelApi.IIntroPort, slotModelApi.IIntroImplementationPort];
        slotModelApi.IntroPort.__name__ = ["slotModelApi", "IntroPort"];
        slotModelApi.IntroPort.prototype.closeIntroScreen = null;
        slotModelApi.IntroPort.prototype.showIntroScreen = null;
        slotModelApi.IntroPort.prototype.confirmCloseIntroScreen = null;
        slotModelApi.IntroPort.prototype.confirmShowIntroScreen = null;
        slotModelApi.IntroPort.prototype.introScreenCancelled = null;
        slotModelApi.IntroPort.prototype.introScreenTimedOut = null;
        slotModelApi.IntroPort.prototype.introScreenCompletelyClosed = null;
        slotModelApi.IntroPort.prototype.getCloseIntroScreen = function() {
            return this.closeIntroScreen;
        };
        slotModelApi.IntroPort.prototype.getShowIntroScreen = function() {
            return this.showIntroScreen;
        };
        slotModelApi.IntroPort.prototype.getConfirmCloseIntroScreen = function() {
            return this.confirmCloseIntroScreen;
        };
        slotModelApi.IntroPort.prototype.getConfirmShowIntroScreen = function() {
            return this.confirmShowIntroScreen;
        };
        slotModelApi.IntroPort.prototype.getIntroScreenCancelled = function() {
            return this.introScreenCancelled;
        };
        slotModelApi.IntroPort.prototype.getIntroScreenTimedOut = function() {
            return this.introScreenTimedOut;
        };
        slotModelApi.IntroPort.prototype.getIntroScreenCompletelyClosed = function() {
            return this.introScreenCompletelyClosed;
        };
        slotModelApi.IntroPort.provide = function(channel) {
            return new slotModelApi.IntroPort(channel);
        };
        slotModelApi.IntroPort["use"] = function(channel) {
            return new slotModelApi.IntroPort(channel);
        };
        slotModelApi.IntroPort.prototype.__class__ = slotModelApi.IntroPort;

        slotModelApi.IReplayStageImplementationPort = function() {}
        slotModelApi.IReplayStageImplementationPort.prototype = {

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

        slotModelApi.IReplayStagePort = function() {}
        slotModelApi.IReplayStagePort.prototype = {

            getEnterReplay: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.ReplayStagePort = function(channel) {
            this.enterReplay = new clientkernelEventbusApi.Topic("slotmodel:enterReplay");
            this.enterReplay.connect(channel);
        };
        slotModelApi.ReplayStagePort = ck_implements(slotModelApi.ReplayStagePort, slotModelApi.IReplayStagePort);
        slotModelApi.ReplayStagePort = ck_implements(slotModelApi.ReplayStagePort, slotModelApi.IReplayStageImplementationPort);
        slotModelApi.ReplayStagePort.__interfaces__ = [slotModelApi.IReplayStagePort, slotModelApi.IReplayStageImplementationPort];
        slotModelApi.ReplayStagePort.__name__ = ["slotModelApi", "ReplayStagePort"];
        slotModelApi.ReplayStagePort.prototype.enterReplay = null;
        slotModelApi.ReplayStagePort.prototype.getEnterReplay = function() {
            return this.enterReplay;
        };
        slotModelApi.ReplayStagePort.provide = function(channel) {
            return new slotModelApi.ReplayStagePort(channel);
        };
        slotModelApi.ReplayStagePort["use"] = function(channel) {
            return new slotModelApi.ReplayStagePort(channel);
        };
        slotModelApi.ReplayStagePort.prototype.__class__ = slotModelApi.ReplayStagePort;

        slotModelApi.IDraftResumeStagePort = function() {}
        slotModelApi.IDraftResumeStagePort.prototype = {

            getPrepareResume: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumePrepared: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDisableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEnableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumeDone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getShowResumeIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmDisableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmEnableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmResumeDone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IDraftResumeStageImplementationPort = function() {}
        slotModelApi.IDraftResumeStageImplementationPort.prototype = {

            getPrepareResume: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumePrepared: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDisableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEnableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumeDone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getShowResumeIntroScreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmDisableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmEnableGamePresentation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConfirmResumeDone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.DraftResumeStagePort = function(channel) {
            this.confirmResumeDone = new clientkernelEventbusApi.Topic("slotmodel:confirmResumeDone");
            this.confirmEnableGamePresentation = new clientkernelEventbusApi.Topic("slotmodel:confirmEnableGamePresentation");
            this.confirmDisableGamePresentation = new clientkernelEventbusApi.Topic("slotmodel:confirmDisableGamePresentation");
            this.showResumeIntroScreen = new clientkernelEventbusApi.Topic("slotmodel:showResumeIntroScreen");
            this.resumeDone = new clientkernelEventbusApi.Topic("slotmodel:resumeDone");
            this.enableGamePresentation = new clientkernelEventbusApi.Topic("slotmodel:enableGamePresentation");
            this.disableGamePresentation = new clientkernelEventbusApi.Topic("slotmodel:disableGamePresentation");
            this.resumePrepared = new clientkernelEventbusApi.Topic("slotmodel:resumePrepared");
            this.prepareResume = new clientkernelEventbusApi.Topic("slotmodel:prepareResume");
            this.prepareResume.connect(channel);
            this.resumePrepared.connect(channel);
            this.disableGamePresentation.connect(channel);
            this.enableGamePresentation.connect(channel);
            this.resumeDone.connect(channel);
            this.showResumeIntroScreen.connect(channel);
            this.confirmDisableGamePresentation.connect(channel);
            this.confirmEnableGamePresentation.connect(channel);
            this.confirmResumeDone.connect(channel);
        };
        slotModelApi.DraftResumeStagePort = ck_implements(slotModelApi.DraftResumeStagePort, slotModelApi.IDraftResumeStagePort);
        slotModelApi.DraftResumeStagePort = ck_implements(slotModelApi.DraftResumeStagePort, slotModelApi.IDraftResumeStageImplementationPort);
        slotModelApi.DraftResumeStagePort.__interfaces__ = [slotModelApi.IDraftResumeStagePort, slotModelApi.IDraftResumeStageImplementationPort];
        slotModelApi.DraftResumeStagePort.__name__ = ["slotModelApi", "DraftResumeStagePort"];
        slotModelApi.DraftResumeStagePort.prototype.prepareResume = null;
        slotModelApi.DraftResumeStagePort.prototype.resumePrepared = null;
        slotModelApi.DraftResumeStagePort.prototype.disableGamePresentation = null;
        slotModelApi.DraftResumeStagePort.prototype.enableGamePresentation = null;
        slotModelApi.DraftResumeStagePort.prototype.resumeDone = null;
        slotModelApi.DraftResumeStagePort.prototype.showResumeIntroScreen = null;
        slotModelApi.DraftResumeStagePort.prototype.confirmDisableGamePresentation = null;
        slotModelApi.DraftResumeStagePort.prototype.confirmEnableGamePresentation = null;
        slotModelApi.DraftResumeStagePort.prototype.confirmResumeDone = null;
        slotModelApi.DraftResumeStagePort.prototype.getPrepareResume = function() {
            return this.prepareResume;
        };
        slotModelApi.DraftResumeStagePort.prototype.getDisableGamePresentation = function() {
            return this.disableGamePresentation;
        };
        slotModelApi.DraftResumeStagePort.prototype.getEnableGamePresentation = function() {
            return this.enableGamePresentation;
        };
        slotModelApi.DraftResumeStagePort.prototype.getResumeDone = function() {
            return this.resumeDone;
        };
        slotModelApi.DraftResumeStagePort.prototype.getShowResumeIntroScreen = function() {
            return this.showResumeIntroScreen;
        };
        slotModelApi.DraftResumeStagePort.prototype.getResumePrepared = function() {
            return this.resumePrepared;
        };
        slotModelApi.DraftResumeStagePort.prototype.getConfirmDisableGamePresentation = function() {
            return this.confirmDisableGamePresentation;
        };
        slotModelApi.DraftResumeStagePort.prototype.getConfirmEnableGamePresentation = function() {
            return this.confirmEnableGamePresentation;
        };
        slotModelApi.DraftResumeStagePort.prototype.getConfirmResumeDone = function() {
            return this.confirmResumeDone;
        };
        slotModelApi.DraftResumeStagePort.provide = function(channel) {
            return new slotModelApi.DraftResumeStagePort(channel);
        };
        slotModelApi.DraftResumeStagePort["use"] = function(channel) {
            return new slotModelApi.DraftResumeStagePort(channel);
        };
        slotModelApi.DraftResumeStagePort.prototype.__class__ = slotModelApi.DraftResumeStagePort;

        slotModelApi.IErrorPort = function() {}
        slotModelApi.IErrorPort.prototype = {

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

        slotModelApi.IErrorImplementationPort = function() {}
        slotModelApi.IErrorImplementationPort.prototype = {

            getError: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.ErrorPort = function(channel) {
            this.error = new clientkernelEventbusApi.Topic("slotmodel:error");
            this.error.connect(channel);
        };
        slotModelApi.ErrorPort = ck_implements(slotModelApi.ErrorPort, slotModelApi.IErrorPort);
        slotModelApi.ErrorPort = ck_implements(slotModelApi.ErrorPort, slotModelApi.IErrorImplementationPort);
        slotModelApi.ErrorPort.__interfaces__ = [slotModelApi.IErrorPort, slotModelApi.IErrorImplementationPort];
        slotModelApi.ErrorPort.__name__ = ["slotModelApi", "ErrorPort"];
        slotModelApi.ErrorPort.prototype.error = null;
        slotModelApi.ErrorPort.prototype.getError = function() {
            return this.error;
        };
        slotModelApi.ErrorPort.provide = function(channel) {
            return new slotModelApi.ErrorPort(channel);
        };
        slotModelApi.ErrorPort["use"] = function(channel) {
            return new slotModelApi.ErrorPort(channel);
        };
        slotModelApi.ErrorPort.prototype.__class__ = slotModelApi.ErrorPort;

        slotModelApi.IGameCommandsPort = function() {}
        slotModelApi.IGameCommandsPort.prototype = {

            getStakeCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStartAutoSpinsCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopAutoSpinsCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStakeCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getTestContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStartAutoSpinsCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopAutoSpinsCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFullScreenCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IGameCommandsImplementationPort = function() {}
        slotModelApi.IGameCommandsImplementationPort.prototype = {

            getStakeCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStartAutoSpinsCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopAutoSpinsCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinCommandAvailable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStakeCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHelpCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPaytableCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getTestContinueCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStartAutoSpinsCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopAutoSpinsCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFullScreenCommandExecuted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.GameCommandsPort = function(channel) {
            this.fullScreenCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:fullScreenCommandExecuted");
            this.autoSpinCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:autoSpinCommandExecuted");
            this.stopAutoSpinsCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:stopAutoSpinsCommandExecuted");
            this.startAutoSpinsCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:startAutoSpinsCommandExecuted");
            this.stopCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:stopCommandExecuted");
            this.testContinueCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:testContinueCommandExecuted");
            this.continueCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:continueCommandExecuted");
            this.spinCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:spinCommandExecuted");
            this.stakeCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:stakeCommandExecuted");
            this.paytableCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:paytableCommandExecuted");
            this.helpCommandExecuted = new clientkernelEventbusApi.Topic("slotmodel:helpCommandExecuted");
            this.autoSpinCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:autoSpinCommandAvailable");
            this.stopAutoSpinsCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:stopAutoSpinsCommandAvailable");
            this.startAutoSpinsCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:startAutoSpinsCommandAvailable");
            this.stopCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:stopCommandAvailable");
            this.continueCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:continueCommandAvailable");
            this.spinCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:spinCommandAvailable");
            this.stakeCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:stakeCommandAvailable");
            this.paytableCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:paytableCommandAvailable");
            this.helpCommandAvailable = new clientkernelEventbusApi.Topic("slotmodel:helpCommandAvailable");
            this.helpCommandAvailable.connect(channel);
            this.paytableCommandAvailable.connect(channel);
            this.stakeCommandAvailable.connect(channel);
            this.spinCommandAvailable.connect(channel);
            this.continueCommandAvailable.connect(channel);
            this.stopCommandAvailable.connect(channel);
            this.startAutoSpinsCommandAvailable.connect(channel);
            this.stopAutoSpinsCommandAvailable.connect(channel);
            this.autoSpinCommandAvailable.connect(channel);
            this.helpCommandExecuted.connect(channel);
            this.paytableCommandExecuted.connect(channel);
            this.stakeCommandExecuted.connect(channel);
            this.spinCommandExecuted.connect(channel);
            this.continueCommandExecuted.connect(channel);
            this.testContinueCommandExecuted.connect(channel);
            this.stopCommandExecuted.connect(channel);
            this.startAutoSpinsCommandExecuted.connect(channel);
            this.stopAutoSpinsCommandExecuted.connect(channel);
            this.autoSpinCommandExecuted.connect(channel);
            this.fullScreenCommandExecuted.connect(channel);
        };
        slotModelApi.GameCommandsPort = ck_implements(slotModelApi.GameCommandsPort, slotModelApi.IGameCommandsPort);
        slotModelApi.GameCommandsPort = ck_implements(slotModelApi.GameCommandsPort, slotModelApi.IGameCommandsImplementationPort);
        slotModelApi.GameCommandsPort.__interfaces__ = [slotModelApi.IGameCommandsPort, slotModelApi.IGameCommandsImplementationPort];
        slotModelApi.GameCommandsPort.__name__ = ["slotModelApi", "GameCommandsPort"];
        slotModelApi.GameCommandsPort.prototype.helpCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.paytableCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.stakeCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.spinCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.continueCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.stopCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.startAutoSpinsCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.stopAutoSpinsCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.autoSpinCommandAvailable = null;
        slotModelApi.GameCommandsPort.prototype.helpCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.paytableCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.stakeCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.spinCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.continueCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.testContinueCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.stopCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.startAutoSpinsCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.stopAutoSpinsCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.autoSpinCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.fullScreenCommandExecuted = null;
        slotModelApi.GameCommandsPort.prototype.getStakeCommandAvailable = function() {
            return this.stakeCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getHelpCommandAvailable = function() {
            return this.helpCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getPaytableCommandAvailable = function() {
            return this.paytableCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getSpinCommandAvailable = function() {
            return this.spinCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getContinueCommandAvailable = function() {
            return this.continueCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getStopCommandAvailable = function() {
            return this.stopCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getStartAutoSpinsCommandAvailable = function() {
            return this.startAutoSpinsCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getStopAutoSpinsCommandAvailable = function() {
            return this.stopAutoSpinsCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getAutoSpinCommandAvailable = function() {
            return this.autoSpinCommandAvailable;
        };
        slotModelApi.GameCommandsPort.prototype.getStakeCommandExecuted = function() {
            return this.stakeCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getHelpCommandExecuted = function() {
            return this.helpCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getPaytableCommandExecuted = function() {
            return this.paytableCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getSpinCommandExecuted = function() {
            return this.spinCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getContinueCommandExecuted = function() {
            return this.continueCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getTestContinueCommandExecuted = function() {
            return this.testContinueCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getStopCommandExecuted = function() {
            return this.stopCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getStartAutoSpinsCommandExecuted = function() {
            return this.startAutoSpinsCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getStopAutoSpinsCommandExecuted = function() {
            return this.stopAutoSpinsCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getAutoSpinCommandExecuted = function() {
            return this.autoSpinCommandExecuted;
        };
        slotModelApi.GameCommandsPort.prototype.getFullScreenCommandExecuted = function() {
            return this.fullScreenCommandExecuted;
        };
        slotModelApi.GameCommandsPort.provide = function(channel) {
            return new slotModelApi.GameCommandsPort(channel);
        };
        slotModelApi.GameCommandsPort["use"] = function(channel) {
            return new slotModelApi.GameCommandsPort(channel);
        };
        slotModelApi.GameCommandsPort.prototype.__class__ = slotModelApi.GameCommandsPort;

        slotModelApi.IGameContextPort = function() {}
        slotModelApi.IGameContextPort.prototype = {

            getBalance: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameOptionChangedFromPf: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameOptionChangedFromGf: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IGameContextImplementationPort = function() {}
        slotModelApi.IGameContextImplementationPort.prototype = {

            getBalance: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameOptionChangedFromPf: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameOptionChangedFromGf: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.GameContextPort = function(channel) {
            this.gameOptionChangedFromGf = new clientkernelEventbusApi.Topic("slotmodel:gameOptionChangedFromGf");
            this.gameOptionChangedFromPf = new clientkernelEventbusApi.Topic("slotmodel:gameOptionChangedFromPf");
            this.balance = new clientkernelEventbusApi.Topic("slotmodel:balance");
            this.balance.connect(channel);
            this.gameOptionChangedFromPf.connect(channel);
            this.gameOptionChangedFromGf.connect(channel);
        };
        slotModelApi.GameContextPort = ck_implements(slotModelApi.GameContextPort, slotModelApi.IGameContextPort);
        slotModelApi.GameContextPort = ck_implements(slotModelApi.GameContextPort, slotModelApi.IGameContextImplementationPort);
        slotModelApi.GameContextPort.__interfaces__ = [slotModelApi.IGameContextPort, slotModelApi.IGameContextImplementationPort];
        slotModelApi.GameContextPort.__name__ = ["slotModelApi", "GameContextPort"];
        slotModelApi.GameContextPort.prototype.balance = null;
        slotModelApi.GameContextPort.prototype.gameOptionChangedFromPf = null;
        slotModelApi.GameContextPort.prototype.gameOptionChangedFromGf = null;
        slotModelApi.GameContextPort.prototype.getBalance = function() {
            return this.balance;
        };
        slotModelApi.GameContextPort.prototype.getGameOptionChangedFromPf = function() {
            return this.gameOptionChangedFromPf;
        };
        slotModelApi.GameContextPort.prototype.getGameOptionChangedFromGf = function() {
            return this.gameOptionChangedFromGf;
        };
        slotModelApi.GameContextPort.provide = function(channel) {
            return new slotModelApi.GameContextPort(channel);
        };
        slotModelApi.GameContextPort["use"] = function(channel) {
            return new slotModelApi.GameContextPort(channel);
        };
        slotModelApi.GameContextPort.prototype.__class__ = slotModelApi.GameContextPort;

        slotModelApi.IJackpotImplementationPort = function() {}
        slotModelApi.IJackpotImplementationPort.prototype = {

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

        slotModelApi.IJackpotPort = function() {}
        slotModelApi.IJackpotPort.prototype = {

            getPlayerMessageUpdate: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getMeterUpdate: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.JackpotPort = function(bus) {
            this.playerMessageUpdate = new clientkernelEventbusApi.Topic("Jackpot.PlayerMessageUpdate");
            this.meterUpdate = new clientkernelEventbusApi.Topic("Jackpot.MeterUpdate");
            this.meterUpdate.connect(bus);
            this.playerMessageUpdate.connect(bus);
        };
        slotModelApi.JackpotPort = ck_implements(slotModelApi.JackpotPort, slotModelApi.IJackpotImplementationPort);
        slotModelApi.JackpotPort = ck_implements(slotModelApi.JackpotPort, slotModelApi.IJackpotPort);
        slotModelApi.JackpotPort.__interfaces__ = [slotModelApi.IJackpotImplementationPort, slotModelApi.IJackpotPort];
        slotModelApi.JackpotPort.__name__ = ["slotModelApi", "JackpotPort"];
        slotModelApi.JackpotPort.prototype.meterUpdate = null;
        slotModelApi.JackpotPort.prototype.playerMessageUpdate = null;
        slotModelApi.JackpotPort.prototype.getMeterUpdate = function() {
            return this.meterUpdate;
        };
        slotModelApi.JackpotPort.prototype.getPlayerMessageUpdate = function() {
            return this.playerMessageUpdate;
        };
        slotModelApi.JackpotPort.prototype.__class__ = slotModelApi.JackpotPort;
        slotModelApi.JackpotPortFactory = function() {};
        slotModelApi.JackpotPortFactory = ck_implements(slotModelApi.JackpotPortFactory, componentmodelComponentApi.IPortFactory);
        slotModelApi.JackpotPortFactory.__interfaces__ = [componentmodelComponentApi.IPortFactory];
        slotModelApi.JackpotPortFactory.__name__ = ["slotModelApi", "JackpotPortFactory"];
        slotModelApi.JackpotPortFactory.prototype.provide = function(channel) {
            return new slotModelApi.JackpotPort(channel);
        };
        slotModelApi.JackpotPortFactory.prototype["use"] = function(channel) {
            return new slotModelApi.JackpotPort(channel);
        };
        slotModelApi.JackpotPortFactory.prototype.__class__ = slotModelApi.JackpotPortFactory;
        slotModelApi.AbortSpin = function(nextStage, stake) {
            this.nextStage = nextStage;
            this.stake = stake;
        };
        slotModelApi.AbortSpin.__name__ = ["slotModelApi", "AbortSpin"];
        slotModelApi.AbortSpin.prototype.nextStage = null;
        slotModelApi.AbortSpin.prototype.stake = null;
        slotModelApi.AbortSpin.prototype.__class__ = slotModelApi.AbortSpin;
        slotModelApi.Balance = function(balance, freespin) {
            this.freespin = freespin;
            this.balance = balance;
        };
        slotModelApi.Balance.__name__ = ["slotModelApi", "Balance"];
        slotModelApi.Balance.prototype.balance = null;
        slotModelApi.Balance.prototype.freespin = null;
        slotModelApi.Balance.prototype.__class__ = slotModelApi.Balance;
        slotModelApi.Error = function(id, isFatal, message) {
            this.id = id;
            this.isFatal = isFatal;
            this.message = message;
        };
        slotModelApi.Error.__name__ = ["slotModelApi", "Error"];
        slotModelApi.Error.prototype.id = null;
        slotModelApi.Error.prototype.isFatal = null;
        slotModelApi.Error.prototype.message = null;
        slotModelApi.Error.prototype.__class__ = slotModelApi.Error;
        slotModelApi.PrepareResume = function(initializationProperties, stake, spinOutcome) {
            this.initializationProperties = initializationProperties;
            this.stake = stake;
            this.spinOutcome = spinOutcome;
        };
        slotModelApi.PrepareResume.__name__ = ["slotModelApi", "PrepareResume"];
        slotModelApi.PrepareResume.prototype.initializationProperties = null;
        slotModelApi.PrepareResume.prototype.stake = null;
        slotModelApi.PrepareResume.prototype.spinOutcome = null;
        slotModelApi.PrepareResume.prototype.__class__ = slotModelApi.PrepareResume;
        slotModelApi.PresentationInitialization = function(defaultStake, riskControlSettings, slotDefinition, consoleSettings) {
            this.defaultStake = defaultStake;
            this.riskControlSettings = riskControlSettings;
            this.slotDefinition = slotDefinition;
            this.consoleSettings = consoleSettings;
        };
        slotModelApi.PresentationInitialization.__name__ = ["slotModelApi", "PresentationInitialization"];
        slotModelApi.PresentationInitialization.prototype.defaultStake = null;
        slotModelApi.PresentationInitialization.prototype.riskControlSettings = null;
        slotModelApi.PresentationInitialization.prototype.slotDefinition = null;
        slotModelApi.PresentationInitialization.prototype.consoleSettings = null;
        slotModelApi.PresentationInitialization.prototype.__class__ = slotModelApi.PresentationInitialization;
        slotModelApi.Result = function(totalWin, bigWin) {
            this.totalWin = totalWin;
            this.bigWin = bigWin;
        };
        slotModelApi.Result.__name__ = ["slotModelApi", "Result"];
        slotModelApi.Result.prototype.totalWin = null;
        slotModelApi.Result.prototype.bigWin = null;
        slotModelApi.Result.prototype.__class__ = slotModelApi.Result;
        slotModelApi.SpinOutcome = function(stage, nextStage, baseGame, freeSpin, pickerBonus, previousFreeSpins, acumulatedFreeSpinPayout, acumulatedPayout, awardCapExceeded, customData) {
            this.stage = stage;
            this.nextStage = nextStage;
            this.baseGame = baseGame;
            this.freeSpin = freeSpin;
            this.pickerBonus = pickerBonus;
            this.previousFreeSpins = previousFreeSpins;
            this.acumulatedFreeSpinPayout = acumulatedFreeSpinPayout;
            this.acumulatedPayout = acumulatedPayout;
            this.awardCapExceeded = awardCapExceeded;
            this.customData = customData;
        };
        slotModelApi.SpinOutcome.__name__ = ["slotModelApi", "SpinOutcome"];
        slotModelApi.SpinOutcome.prototype.stage = null;
        slotModelApi.SpinOutcome.prototype.nextStage = null;
        slotModelApi.SpinOutcome.prototype.baseGame = null;
        slotModelApi.SpinOutcome.prototype.freeSpin = null;
        slotModelApi.SpinOutcome.prototype.pickerBonus = null;
        slotModelApi.SpinOutcome.prototype.previousFreeSpins = null;
        slotModelApi.SpinOutcome.prototype.acumulatedFreeSpinPayout = null;
        slotModelApi.SpinOutcome.prototype.acumulatedPayout = null;
        slotModelApi.SpinOutcome.prototype.awardCapExceeded = null;
        slotModelApi.SpinOutcome.prototype.customData = null;
        slotModelApi.SpinOutcome.prototype.__class__ = slotModelApi.SpinOutcome;
        slotModelApi.StakeItems = function(lineCount, betPerLine, sideBet) {
            if (sideBet == null) sideBet = 0;
            this.lineCount = lineCount;
            this.betPerLine = betPerLine;
            this.sideBet = sideBet;
        };
        slotModelApi.StakeItems.__name__ = ["slotModelApi", "StakeItems"];
        slotModelApi.StakeItems.prototype.lineCount = null;
        slotModelApi.StakeItems.prototype.betPerLine = null;
        slotModelApi.StakeItems.prototype.sideBet = null;
        slotModelApi.StakeItems.prototype.__class__ = slotModelApi.StakeItems;
        slotModelApi.StakeItemsWithTotalBet = function(stakeItems, totalBet, totalBetsForSelectedLines, totalBetsForSelectedBetPerLine, outcome) {
            this.stakeItems = stakeItems;
            this.totalBet = totalBet;
            this.totalBetsForSelectedLines = totalBetsForSelectedLines;
            this.totalBetsForSelectedBetPerLine = totalBetsForSelectedBetPerLine;
            this.outcome = outcome;
        };
        slotModelApi.StakeItemsWithTotalBet.__name__ = ["slotModelApi", "StakeItemsWithTotalBet"];
        slotModelApi.StakeItemsWithTotalBet.prototype.stakeItems = null;
        slotModelApi.StakeItemsWithTotalBet.prototype.totalBet = null;
        slotModelApi.StakeItemsWithTotalBet.prototype.outcome = null;
        slotModelApi.StakeItemsWithTotalBet.prototype.totalBetsForSelectedLines = null;
        slotModelApi.StakeItemsWithTotalBet.prototype.totalBetsForSelectedBetPerLine = null;
        slotModelApi.StakeItemsWithTotalBet.prototype.__class__ = slotModelApi.StakeItemsWithTotalBet;
        slotModelApi.AutoSpinInfo = function(current, total) {
            this.current = current;
            this.total = total;
        };
        slotModelApi.AutoSpinInfo.__name__ = ["slotModelApi", "AutoSpinInfo"];
        slotModelApi.AutoSpinInfo.prototype.current = null;
        slotModelApi.AutoSpinInfo.prototype.total = null;
        slotModelApi.AutoSpinInfo.prototype.__class__ = slotModelApi.AutoSpinInfo;
        slotModelApi.AutoSpinsStopReason = function(id, reason) {
            this.id = id;
            this.reason = reason;
        };
        slotModelApi.AutoSpinsStopReason.__name__ = ["slotModelApi", "AutoSpinsStopReason"];
        slotModelApi.AutoSpinsStopReason.prototype.id = null;
        slotModelApi.AutoSpinsStopReason.prototype.reason = null;
        slotModelApi.AutoSpinsStopReason.prototype.__class__ = slotModelApi.AutoSpinsStopReason;
        slotModelApi.AutospinCommandPayload = function(steps, lossLimit, winLimit) {
            this.winLimit = winLimit;
            this.lossLimit = lossLimit;
            this.steps = steps;
        };
        slotModelApi.AutospinCommandPayload.__name__ = ["slotModelApi", "AutospinCommandPayload"];
        slotModelApi.AutospinCommandPayload.prototype.winLimit = null;
        slotModelApi.AutospinCommandPayload.prototype.lossLimit = null;
        slotModelApi.AutospinCommandPayload.prototype.steps = null;
        slotModelApi.AutospinCommandPayload.prototype.__class__ = slotModelApi.AutospinCommandPayload;
        slotModelApi.Pair = function(key, value) {
            this.key = key;
            this.value = value;
        };
        slotModelApi.Pair.__name__ = ["slotModelApi", "Pair"];
        slotModelApi.Pair.prototype.key = null;
        slotModelApi.Pair.prototype.value = null;
        slotModelApi.Pair.prototype.__class__ = slotModelApi.Pair;
        slotModelApi.ReelPicture = function(reels) {
            this.reels = reels;
        };
        slotModelApi.ReelPicture.__name__ = ["slotModelApi", "ReelPicture"];
        slotModelApi.ReelPicture.prototype.reels = null;
        slotModelApi.ReelPicture.prototype.toString = function() {
            if (this.reels == null) return "";
            var reels = this.reels;
            var firstLastLine = "--------------------------";
            var middleLine = "|----|----|----|----|----|";
            var result = "\n" + firstLastLine + "\n";
            var reelLength = 0;
            if (reels[0] != null) reelLength = reels[0].length;
            var _g = 0;
            while (_g < reelLength) {
                var i = _g++;
                var row = "";
                var _g1 = 0;
                while (_g1 < reels.length) {
                    var reel = reels[_g1];
                    ++_g1;
                    if (reel != null && reel[i] != null) row = row + "| " + _hcmn_.StringTools.lpad(reel[i], " ", 2) + " ";
                    else row = row + "| " + "null" + " ";
                }
                row = row + "|";
                result += row + "\n";
                if (i < reelLength - 1) result += middleLine + "\n";
            }
            result += firstLastLine + "\n";
            return result;
        };
        slotModelApi.ReelPicture.prototype.__class__ = slotModelApi.ReelPicture;
        slotModelApi.ReelPictureInfo = function(reelsInfo) {
            this.reelsInfo = reelsInfo;
        };
        slotModelApi.ReelPictureInfo.__name__ = ["slotModelApi", "ReelPictureInfo"];
        slotModelApi.ReelPictureInfo.prototype.reelsInfo = null;
        slotModelApi.ReelPictureInfo.prototype.toString = function() {
            if (this.reelsInfo == null) return "";
            var firstLastLine = "--------------------------";
            var middleLine = "|----|----|----|----|----|";
            var result = "\n" + firstLastLine + "\n";
            var reelLength = 0;
            if (this.reelsInfo[0] != null) reelLength = this.reelsInfo[0].length;
            var _g = 0;
            while (_g < reelLength) {
                var i = _g++;
                var row = "";
                var _g1 = 0;
                var _g2 = this.reelsInfo;
                while (_g1 < _g2.length) {
                    var reelInfo = _g2[_g1];
                    ++_g1;
                    if (reelInfo != null && reelInfo[i] != null) row = row + "| " + _hcmn_.StringTools.lpad(_hcmn_.Std.string(reelInfo[i]), " ", 2) + " ";
                    else row = row + "| " + "null" + " ";
                }
                row = row + "|";
                result += row + "\n";
                if (i < reelLength - 1) result += middleLine + "\n";
            }
            result += firstLastLine + "\n";
            return result;
        };
        slotModelApi.ReelPictureInfo.prototype.__class__ = slotModelApi.ReelPictureInfo;
        slotModelApi.ConsoleSettings = function() {};
        slotModelApi.ConsoleSettings.__name__ = ["slotModelApi", "ConsoleSettings"];
        slotModelApi.ConsoleSettings.prototype.__class__ = slotModelApi.ConsoleSettings;
        slotModelApi.RiskControlSettings = function(currencyFormat, betsPerLine, defaultBetPerLine, defaultSelectedLineCount, denomination, awardCap, softwareId, rgPresentation) {
            if (rgPresentation == null) rgPresentation = false;
            this.currencyFormat = currencyFormat;
            this.betsPerLine = betsPerLine;
            this.defaultBetPerLine = defaultBetPerLine;
            this.defaultSelectedLineCount = defaultSelectedLineCount;
            this.denomination = denomination;
            this.awardCap = awardCap;
            this.softwareId = softwareId;
            this.rgPresentation = rgPresentation;
        };
        slotModelApi.RiskControlSettings.__name__ = ["slotModelApi", "RiskControlSettings"];
        slotModelApi.RiskControlSettings.prototype.currencyFormat = null;
        slotModelApi.RiskControlSettings.prototype.betsPerLine = null;
        slotModelApi.RiskControlSettings.prototype.defaultBetPerLine = null;
        slotModelApi.RiskControlSettings.prototype.defaultSelectedLineCount = null;
        slotModelApi.RiskControlSettings.prototype.denomination = null;
        slotModelApi.RiskControlSettings.prototype.awardCap = null;
        slotModelApi.RiskControlSettings.prototype.softwareId = null;
        slotModelApi.RiskControlSettings.prototype.rgPresentation = null;
        slotModelApi.RiskControlSettings.prototype.__class__ = slotModelApi.RiskControlSettings;
        slotModelApi.AutoSpinDefinition = function(enabled, steps) {
            this.enabled = enabled;
            this.steps = steps;
        };
        slotModelApi.AutoSpinDefinition.__name__ = ["slotModelApi", "AutoSpinDefinition"];
        slotModelApi.AutoSpinDefinition.prototype.enabled = null;
        slotModelApi.AutoSpinDefinition.prototype.steps = null;
        slotModelApi.AutoSpinDefinition.prototype.__class__ = slotModelApi.AutoSpinDefinition;
        slotModelApi.Line = function(id, offsets) {
            this.id = id;
            this.offsets = offsets;
        };
        slotModelApi.Line.__name__ = ["slotModelApi", "Line"];
        slotModelApi.Line.prototype.id = null;
        slotModelApi.Line.prototype.offsets = null;
        slotModelApi.Line.prototype.getLinePath = function(reelPictureSize) {
            if (reelPictureSize == null) return null;
            if (this.offsets == null) return null;
            var linePath = [];
            var reelIndex;
            var _g1 = 0;
            var _g = reelPictureSize.reelCount;
            while (_g1 < _g) {
                var reelIndex1 = _g1++;
                var pathOnReel = [];
                var reelOffset = this.offsets[reelIndex1];
                var symbolIndex;
                var _g3 = 0;
                var _g2 = reelPictureSize.reelLength;
                while (_g3 < _g2) {
                    var symbolIndex1 = _g3++;
                    if (symbolIndex1 == reelOffset) pathOnReel.push(true);
                    else pathOnReel.push(false);
                }
                linePath.push(pathOnReel);
            }
            return linePath;
        };
        slotModelApi.Line.prototype.__class__ = slotModelApi.Line;
        slotModelApi.Reel = function(id, stripes) {
            this.id = id;
            this.stripes = stripes;
        };
        slotModelApi.Reel.__name__ = ["slotModelApi", "Reel"];
        slotModelApi.Reel.prototype.id = null;
        slotModelApi.Reel.prototype.stripes = null;
        slotModelApi.Reel.prototype.__class__ = slotModelApi.Reel;
        slotModelApi.ReelPictureSize = function(reelCount, reelLength) {
            this.reelCount = reelCount;
            this.reelLength = reelLength;
        };
        slotModelApi.ReelPictureSize.__name__ = ["slotModelApi", "ReelPictureSize"];
        slotModelApi.ReelPictureSize.prototype.reelCount = null;
        slotModelApi.ReelPictureSize.prototype.reelLength = null;
        slotModelApi.ReelPictureSize.prototype.__class__ = slotModelApi.ReelPictureSize;
        slotModelApi.Rtp = function(minRTP, maxRTP, singleRTP, minSingleRTP, maxSingleRTP) {
            this.minRTP = minRTP;
            this.maxRTP = maxRTP;
            this.singleRTP = singleRTP;
            this.minSingleRTP = minSingleRTP;
            this.maxSingleRTP = maxSingleRTP;
        };
        slotModelApi.Rtp.__name__ = ["slotModelApi", "Rtp"];
        slotModelApi.Rtp.prototype.singleRTP = null;
        slotModelApi.Rtp.prototype.minSingleRTP = null;
        slotModelApi.Rtp.prototype.maxSingleRTP = null;
        slotModelApi.Rtp.prototype.minRTP = null;
        slotModelApi.Rtp.prototype.maxRTP = null;
        slotModelApi.Rtp.prototype.__class__ = slotModelApi.Rtp;
        slotModelApi.SlotDefinition = function(rtp, reelPictureSize, reelPictureVisibility, symbols, reels, lines, selectableLines, sideBets, startReelPicture, startReelPicturePerBet, startFSReelPicture, startFSReelPicturePerBet, autoSpins, outcomes, stripeLayersMap) {
            this.rtp = rtp;
            this.reelPictureSize = reelPictureSize;
            this.reelPictureVisibility = reelPictureVisibility;
            this.symbols = symbols;
            this.reels = reels;
            this.lines = lines;
            this.selectableLines = selectableLines;
            this.sideBets = sideBets;
            this.startReelPicture = startReelPicture;
            this.startReelPicturePerBet = startReelPicturePerBet;
            this.startFSReelPicture = startFSReelPicture;
            this.startFSReelPicturePerBet = startFSReelPicturePerBet;
            this.autoSpins = autoSpins;
            this.outcomes = outcomes;
            this.stripeLayersMap = stripeLayersMap;
            if (lines != null) {
                this.lineMap = new _hcmn_.haxe_ds_IntMap();
                var line;
                var _g = 0;
                while (_g < lines.length) {
                    var line1 = lines[_g];
                    ++_g;
                    if (line1 != null) this.lineMap.h[line1.id] = line1;
                }
            }
            if (symbols != null) {
                this.symbolMap = new _hcmn_.haxe_ds_StringMap();
                var symbol;
                var _g1 = 0;
                while (_g1 < symbols.length) {
                    var symbol1 = symbols[_g1];
                    ++_g1;
                    if (symbol1 != null) this.symbolMap.set(symbol1.id, symbol1);
                }
            }
        };
        slotModelApi.SlotDefinition.__name__ = ["slotModelApi", "SlotDefinition"];
        slotModelApi.SlotDefinition.prototype.lineMap = null;
        slotModelApi.SlotDefinition.prototype.symbolMap = null;
        slotModelApi.SlotDefinition.prototype.rtp = null;
        slotModelApi.SlotDefinition.prototype.reelPictureSize = null;
        slotModelApi.SlotDefinition.prototype.reelPictureVisibility = null;
        slotModelApi.SlotDefinition.prototype.symbols = null;
        slotModelApi.SlotDefinition.prototype.reels = null;
        slotModelApi.SlotDefinition.prototype.lines = null;
        slotModelApi.SlotDefinition.prototype.selectableLines = null;
        slotModelApi.SlotDefinition.prototype.sideBets = null;
        slotModelApi.SlotDefinition.prototype.startReelPicture = null;
        slotModelApi.SlotDefinition.prototype.startReelPicturePerBet = null;
        slotModelApi.SlotDefinition.prototype.startFSReelPicture = null;
        slotModelApi.SlotDefinition.prototype.startFSReelPicturePerBet = null;
        slotModelApi.SlotDefinition.prototype.autoSpins = null;
        slotModelApi.SlotDefinition.prototype.outcomes = null;
        slotModelApi.SlotDefinition.prototype.stripeLayersMap = null;
        slotModelApi.SlotDefinition.prototype.getLine = function(id) {
            if (this.lineMap == null) return null;
            if (this.lineMap.h.hasOwnProperty(id)) return this.lineMap.h[id];
            return null;
        };
        slotModelApi.SlotDefinition.prototype.getSymbol = function(id) {
            if (this.symbolMap == null) return null;
            if (this.symbolMap.exists(id)) return this.symbolMap.get(id);
            return null;
        };
        slotModelApi.SlotDefinition.prototype.__class__ = slotModelApi.SlotDefinition;
        slotModelApi.Stripe = function(stripeLayer, symbols) {
            this.stripeLayer = stripeLayer;
            this.symbols = symbols;
        };
        slotModelApi.Stripe.__name__ = ["slotModelApi", "Stripe"];
        slotModelApi.Stripe.prototype.stripeLayer = null;
        slotModelApi.Stripe.prototype.symbols = null;
        slotModelApi.Stripe.prototype.__class__ = slotModelApi.Stripe;
        slotModelApi.Symbol = function(id, description, isWild, isBonus, isScatter, hasLandingAnimation, isBleed, block, asset) {
            this.id = id;
            this.description = description;
            this.isWild = isWild;
            this.isBonus = isBonus;
            this.isScatter = isScatter;
            this.hasLandingAnimation = hasLandingAnimation;
            this.isBleed = isBleed;
            this.block = block;
            this.asset = asset;
        };
        slotModelApi.Symbol.__name__ = ["slotModelApi", "Symbol"];
        slotModelApi.Symbol.prototype.id = null;
        slotModelApi.Symbol.prototype.description = null;
        slotModelApi.Symbol.prototype.isWild = null;
        slotModelApi.Symbol.prototype.isBonus = null;
        slotModelApi.Symbol.prototype.isScatter = null;
        slotModelApi.Symbol.prototype.hasLandingAnimation = null;
        slotModelApi.Symbol.prototype.isBleed = null;
        slotModelApi.Symbol.prototype.block = null;
        slotModelApi.Symbol.prototype.asset = null;
        slotModelApi.Symbol.prototype.__class__ = slotModelApi.Symbol;
        slotModelApi.BigWin = function(winGroup, winSegments, customGroups) {
            this.winGroup = winGroup;
            this.winSegments = winSegments;
            this.customGroups = customGroups;
        };
        slotModelApi.BigWin.__name__ = ["slotModelApi", "BigWin"];
        slotModelApi.BigWin.prototype.winGroup = null;
        slotModelApi.BigWin.prototype.winSegments = null;
        slotModelApi.BigWin.prototype.customGroups = null;
        slotModelApi.BigWin.prototype.__class__ = slotModelApi.BigWin;
        slotModelApi.BigWinSegment = function(winGroup, totalWin) {
            this.winGroup = winGroup;
            this.totalWin = totalWin;
        };
        slotModelApi.BigWinSegment.__name__ = ["slotModelApi", "BigWinSegment"];
        slotModelApi.BigWinSegment.prototype.winGroup = null;
        slotModelApi.BigWinSegment.prototype.totalWin = null;
        slotModelApi.BigWinSegment.prototype.__class__ = slotModelApi.BigWinSegment;
        slotModelApi.Win = function(type, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount) {
            this.type = type;
            this.id = id;
            this.name = name;
            this.lineId = lineId;
            this.price = price;
            this.multiplier = multiplier;
            this.payout = payout;
            this.winPath = winPath;
            this.winningSymbol = winningSymbol;
            this.position = position;
            this.symbolCount = symbolCount;
        };
        slotModelApi.Win.__name__ = ["slotModelApi", "Win"];
        slotModelApi.Win.prototype.type = null;
        slotModelApi.Win.prototype.id = null;
        slotModelApi.Win.prototype.name = null;
        slotModelApi.Win.prototype.lineId = null;
        slotModelApi.Win.prototype.price = null;
        slotModelApi.Win.prototype.multiplier = null;
        slotModelApi.Win.prototype.payout = null;
        slotModelApi.Win.prototype.winPath = null;
        slotModelApi.Win.prototype.winningSymbol = null;
        slotModelApi.Win.prototype.position = null;
        slotModelApi.Win.prototype.symbolCount = null;
        slotModelApi.Win.prototype.toString = function() {
            return "type: " + this.type + ", id: " + this.id + ", name: " + this.name + ", lineId: " + this.lineId + ", price: " + this.price + ", multiplier:" + this.multiplier + ",  payout:" + this.payout + ", winPath: " + _hcmn_.Std.string(this.winPath) + ", winningSymbol:" + this.winningSymbol + ", position:" + this.position + ", symbolCount:" + this.symbolCount;
        };
        slotModelApi.Win.prototype.__class__ = slotModelApi.Win;
        slotModelApi.BonusWin = function(type, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount) {
            slotModelApi.Win.call(this, type, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount);
        };
        slotModelApi.BonusWin.__name__ = ["slotModelApi", "BonusWin"];
        slotModelApi.BonusWin.__super__ = slotModelApi.Win;
        for (var k in slotModelApi.Win.prototype) slotModelApi.BonusWin.prototype[k] = slotModelApi.Win.prototype[k];
        slotModelApi.BonusWin.prototype.__class__ = slotModelApi.BonusWin;
        slotModelApi.LineWin = function(name, lineId, price, multiplier, payout, winPath, winningSymbol, symbolCount, lineType) {
            var id = slotModelApi.LineWin.WIN_TYPE + "_" + lineId;
            if (lineType != null) slotModelApi.Win.call(this, lineType, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, slotModelApi.LineWin.WIN_POSITION, symbolCount);
            else slotModelApi.Win.call(this, slotModelApi.LineWin.WIN_TYPE, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, slotModelApi.LineWin.WIN_POSITION, symbolCount);
        };
        slotModelApi.LineWin.__name__ = ["slotModelApi", "LineWin"];
        slotModelApi.LineWin.__super__ = slotModelApi.Win;
        for (var k in slotModelApi.Win.prototype) slotModelApi.LineWin.prototype[k] = slotModelApi.Win.prototype[k];
        slotModelApi.LineWin.prototype.__class__ = slotModelApi.LineWin;
        slotModelApi.Outcome = function(reelStop, reelStopAdditional, lineWins, scatterWins, bonusWins, pickerWins, totalPayout, bigWin, customField) {
            this.reelStop = reelStop;
            this.reelStopAdditional = reelStopAdditional;
            this.lineWins = lineWins;
            this.scatterWins = scatterWins;
            this.bonusWins = bonusWins;
            this.pickerWins = pickerWins;
            this.totalPayout = totalPayout;
            this.bigWin = bigWin;
            this.customField = customField;
        };
        slotModelApi.Outcome.__name__ = ["slotModelApi", "Outcome"];
        slotModelApi.Outcome.prototype.reelStop = null;
        slotModelApi.Outcome.prototype.reelStopAdditional = null;
        slotModelApi.Outcome.prototype.lineWins = null;
        slotModelApi.Outcome.prototype.scatterWins = null;
        slotModelApi.Outcome.prototype.bonusWins = null;
        slotModelApi.Outcome.prototype.pickerWins = null;
        slotModelApi.Outcome.prototype.totalPayout = null;
        slotModelApi.Outcome.prototype.bigWin = null;
        slotModelApi.Outcome.prototype.customField = null;
        slotModelApi.Outcome.prototype.__class__ = slotModelApi.Outcome;
        slotModelApi.Pick = function(name, picked, values, payout) {
            this.name = name;
            this.picked = picked;
            this.values = values;
            this.payout = payout;
        };
        slotModelApi.Pick.__name__ = ["slotModelApi", "Pick"];
        slotModelApi.Pick.prototype.name = null;
        slotModelApi.Pick.prototype.picked = null;
        slotModelApi.Pick.prototype.values = null;
        slotModelApi.Pick.prototype.payout = null;
        slotModelApi.Pick.prototype.__class__ = slotModelApi.Pick;
        slotModelApi.PickerWin = function(name, id, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount, picks, progressMeter, lastPicked) {
            slotModelApi.Win.call(this, slotModelApi.PickerWin.WIN_TYPE, id, name, lineId, price, multiplier, payout, winPath, winningSymbol, position, symbolCount);
            this.picks = picks;
            this.lastPicked = lastPicked;
            this.progressMeter = progressMeter;
        };
        slotModelApi.PickerWin.__name__ = ["slotModelApi", "PickerWin"];
        slotModelApi.PickerWin.__super__ = slotModelApi.Win;
        for (var k in slotModelApi.Win.prototype) slotModelApi.PickerWin.prototype[k] = slotModelApi.Win.prototype[k];
        slotModelApi.PickerWin.prototype.picks = null;
        slotModelApi.PickerWin.prototype.lastPicked = null;
        slotModelApi.PickerWin.prototype.progressMeter = null;
        slotModelApi.PickerWin.prototype.__class__ = slotModelApi.PickerWin;
        slotModelApi.ScatterWin = function(name, price, multiplier, payout, winPath, winningSymbol, symbolCount) {
            var id = slotModelApi.ScatterWin.WIN_TYPE + "_" + name;
            slotModelApi.Win.call(this, slotModelApi.ScatterWin.WIN_TYPE, id, name, slotModelApi.ScatterWin.WIN_LINEID, price, multiplier, payout, winPath, winningSymbol, slotModelApi.ScatterWin.WIN_POSITION, symbolCount);
        };
        slotModelApi.ScatterWin.__name__ = ["slotModelApi", "ScatterWin"];
        slotModelApi.ScatterWin.__super__ = slotModelApi.Win;
        for (var k in slotModelApi.Win.prototype) slotModelApi.ScatterWin.prototype[k] = slotModelApi.Win.prototype[k];
        slotModelApi.ScatterWin.prototype.__class__ = slotModelApi.ScatterWin;
        slotModelApi.BaseGameOutcome = function(outcome) {
            this.outcome = outcome;
        };
        slotModelApi.BaseGameOutcome.__name__ = ["slotModelApi", "BaseGameOutcome"];
        slotModelApi.BaseGameOutcome.prototype.outcome = null;
        slotModelApi.BaseGameOutcome.prototype.__class__ = slotModelApi.BaseGameOutcome;
        slotModelApi.FreeSpinOutcome = function(awarded, isMaxAwarded, isIncrementTriggered, total, current, outcome) {
            this.awarded = awarded;
            this.isMaxAwarded = isMaxAwarded;
            this.isIncrementTriggered = isIncrementTriggered;
            this.total = total;
            this.current = current;
            this.outcome = outcome;
        };
        slotModelApi.FreeSpinOutcome.__name__ = ["slotModelApi", "FreeSpinOutcome"];
        slotModelApi.FreeSpinOutcome.prototype.awarded = null;
        slotModelApi.FreeSpinOutcome.prototype.isMaxAwarded = null;
        slotModelApi.FreeSpinOutcome.prototype.isIncrementTriggered = null;
        slotModelApi.FreeSpinOutcome.prototype.total = null;
        slotModelApi.FreeSpinOutcome.prototype.current = null;
        slotModelApi.FreeSpinOutcome.prototype.outcome = null;
        slotModelApi.FreeSpinOutcome.prototype.__class__ = slotModelApi.FreeSpinOutcome;
        slotModelApi.PickerBonusOutcome = function(outcome, isIncrementTriggered) {
            this.isIncrementTriggered = isIncrementTriggered;
            this.outcome = outcome;
        };
        slotModelApi.PickerBonusOutcome.__name__ = ["slotModelApi", "PickerBonusOutcome"];
        slotModelApi.PickerBonusOutcome.prototype.outcome = null;
        slotModelApi.PickerBonusOutcome.prototype.isIncrementTriggered = null;
        slotModelApi.PickerBonusOutcome.prototype.__class__ = slotModelApi.PickerBonusOutcome;

        slotModelApi.IStagesImplementationPort = function() {}
        slotModelApi.IStagesImplementationPort.prototype = {

            getInitStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumeStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIdleStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAbortStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResultStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPickerBonusStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IStagesPort = function() {}
        slotModelApi.IStagesPort.prototype = {

            getInitStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumeStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getIdleStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAbortStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResultStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPickerBonusStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.StagesPort = function(channel, $use) {
            if ($use) {
                this.baseSpinPort = slotModelApi.SpinStagePort["use"](channel);
                this.idlePort = slotModelApi.IdleStagePort["use"](channel);
                this.resumePort = slotModelApi.ResumeStagePort["use"](channel);
                this.abortPort = slotModelApi.AbortStagePort["use"](channel);
                this.resultPort = slotModelApi.ResultStagePort["use"](channel);
                this.initStagePort = slotModelApi.InitStagePort["use"](channel);
                this.pickerBonusPort = slotModelApi.PickerBonusStagePort["use"](channel);
            } else {
                this.baseSpinPort = slotModelApi.SpinStagePort.provide(channel);
                this.idlePort = slotModelApi.IdleStagePort.provide(channel);
                this.resumePort = slotModelApi.ResumeStagePort.provide(channel);
                this.abortPort = slotModelApi.AbortStagePort.provide(channel);
                this.resultPort = slotModelApi.ResultStagePort.provide(channel);
                this.initStagePort = slotModelApi.InitStagePort.provide(channel);
                this.pickerBonusPort = slotModelApi.PickerBonusStagePort.provide(channel);
            }
        };
        slotModelApi.StagesPort = ck_implements(slotModelApi.StagesPort, slotModelApi.IStagesPort);
        slotModelApi.StagesPort = ck_implements(slotModelApi.StagesPort, slotModelApi.IStagesImplementationPort);
        slotModelApi.StagesPort.__interfaces__ = [slotModelApi.IStagesPort, slotModelApi.IStagesImplementationPort];
        slotModelApi.StagesPort.__name__ = ["slotModelApi", "StagesPort"];
        slotModelApi.StagesPort.prototype.baseSpinPort = null;
        slotModelApi.StagesPort.prototype.idlePort = null;
        slotModelApi.StagesPort.prototype.resumePort = null;
        slotModelApi.StagesPort.prototype.abortPort = null;
        slotModelApi.StagesPort.prototype.resultPort = null;
        slotModelApi.StagesPort.prototype.initStagePort = null;
        slotModelApi.StagesPort.prototype.pickerBonusPort = null;
        slotModelApi.StagesPort.prototype.getSpinStage = function() {
            return this.baseSpinPort;
        };
        slotModelApi.StagesPort.prototype.getIdleStage = function() {
            return this.idlePort;
        };
        slotModelApi.StagesPort.prototype.getResumeStage = function() {
            return this.resumePort;
        };
        slotModelApi.StagesPort.prototype.getAbortStage = function() {
            return this.abortPort;
        };
        slotModelApi.StagesPort.prototype.getResultStage = function() {
            return this.resultPort;
        };
        slotModelApi.StagesPort.prototype.getInitStage = function() {
            return this.initStagePort;
        };
        slotModelApi.StagesPort.prototype.getPickerBonusStage = function() {
            return this.pickerBonusPort;
        };
        slotModelApi.StagesPort.provide = function(channel) {
            return new slotModelApi.StagesPort(channel, false);
        };
        slotModelApi.StagesPort["use"] = function(channel) {
            return new slotModelApi.StagesPort(channel, true);
        };
        slotModelApi.StagesPort.prototype.__class__ = slotModelApi.StagesPort;

        slotModelApi.IAbortStagePort = function() {}
        slotModelApi.IAbortStagePort.prototype = {

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

        slotModelApi.IAbortStageImplementationPort = function() {}
        slotModelApi.IAbortStageImplementationPort.prototype = {

            getAbortSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinAborted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.AbortStagePort = function(channel) {
            this.spinAborted = new clientkernelEventbusApi.Topic("slotmodel:spinAborted");
            this.abortSpin = new clientkernelEventbusApi.Topic("slotmodel:abortSpin");
            this.abortSpin.connect(channel);
            this.spinAborted.connect(channel);
        };
        slotModelApi.AbortStagePort = ck_implements(slotModelApi.AbortStagePort, slotModelApi.IAbortStagePort);
        slotModelApi.AbortStagePort = ck_implements(slotModelApi.AbortStagePort, slotModelApi.IAbortStageImplementationPort);
        slotModelApi.AbortStagePort.__interfaces__ = [slotModelApi.IAbortStagePort, slotModelApi.IAbortStageImplementationPort];
        slotModelApi.AbortStagePort.__name__ = ["slotModelApi", "AbortStagePort"];
        slotModelApi.AbortStagePort.prototype.abortSpin = null;
        slotModelApi.AbortStagePort.prototype.spinAborted = null;
        slotModelApi.AbortStagePort.prototype.getAbortSpin = function() {
            return this.abortSpin;
        };
        slotModelApi.AbortStagePort.prototype.getSpinAborted = function() {
            return this.spinAborted;
        };
        slotModelApi.AbortStagePort.provide = function(channel) {
            return new slotModelApi.AbortStagePort(channel);
        };
        slotModelApi.AbortStagePort["use"] = function(channel) {
            return new slotModelApi.AbortStagePort(channel);
        };
        slotModelApi.AbortStagePort.prototype.__class__ = slotModelApi.AbortStagePort;

        slotModelApi.IIdleStageImplementationPort = function() {}
        slotModelApi.IIdleStageImplementationPort.prototype = {

            getConfirmSelectedStake: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenHelp: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenPaytable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinsStopped: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinStarted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRequestableTopic1: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRequestableTopic2: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IIdleStagePort = function() {}
        slotModelApi.IIdleStagePort.prototype = {

            getConfirmSelectedStake: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenHelp: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOpenPaytable: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinStarted: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinsStopped: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRequestableTopic1: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRequestableTopic2: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.IdleStagePort = function(channel) {
            this.requestableTopic2 = new clientkernelEventbusApi.Request("slotmodel:requestableTopic2");
            this.requestableTopic1 = new clientkernelEventbusApi.Request("slotmodel:requestableTopic1");
            this.autoSpinStarted = new clientkernelEventbusApi.Topic("slotmodel:autoSpinStarted");
            this.autoSpinsStopped = new clientkernelEventbusApi.Topic("slotmodel:autoSpinsStopped");
            this.openPaytable = new clientkernelEventbusApi.Topic("slotmodel:openPaytable");
            this.openHelp = new clientkernelEventbusApi.Topic("slotmodel:openHelp");
            this.confirmSelectedStake = new clientkernelEventbusApi.Topic("slotmodel:confirmSelectedStake");
            this.confirmSelectedStake.connect(channel);
            this.openHelp.connect(channel);
            this.openPaytable.connect(channel);
            this.autoSpinsStopped.connect(channel);
            this.autoSpinStarted.connect(channel);
            this.requestableTopic1.connect(channel);
            this.requestableTopic2.connect(channel);
        };
        slotModelApi.IdleStagePort = ck_implements(slotModelApi.IdleStagePort, slotModelApi.IIdleStagePort);
        slotModelApi.IdleStagePort = ck_implements(slotModelApi.IdleStagePort, slotModelApi.IIdleStageImplementationPort);
        slotModelApi.IdleStagePort.__interfaces__ = [slotModelApi.IIdleStagePort, slotModelApi.IIdleStageImplementationPort];
        slotModelApi.IdleStagePort.__name__ = ["slotModelApi", "IdleStagePort"];
        slotModelApi.IdleStagePort.prototype.confirmSelectedStake = null;
        slotModelApi.IdleStagePort.prototype.openHelp = null;
        slotModelApi.IdleStagePort.prototype.openPaytable = null;
        slotModelApi.IdleStagePort.prototype.autoSpinsStopped = null;
        slotModelApi.IdleStagePort.prototype.autoSpinStarted = null;
        slotModelApi.IdleStagePort.prototype.requestableTopic1 = null;
        slotModelApi.IdleStagePort.prototype.requestableTopic2 = null;
        slotModelApi.IdleStagePort.prototype.getConfirmSelectedStake = function() {
            return this.confirmSelectedStake;
        };
        slotModelApi.IdleStagePort.prototype.getOpenHelp = function() {
            return this.openHelp;
        };
        slotModelApi.IdleStagePort.prototype.getOpenPaytable = function() {
            return this.openPaytable;
        };
        slotModelApi.IdleStagePort.prototype.getAutoSpinsStopped = function() {
            return this.autoSpinsStopped;
        };
        slotModelApi.IdleStagePort.prototype.getAutoSpinStarted = function() {
            return this.autoSpinStarted;
        };
        slotModelApi.IdleStagePort.prototype.getRequestableTopic1 = function() {
            return this.requestableTopic1;
        };
        slotModelApi.IdleStagePort.prototype.getRequestableTopic2 = function() {
            return this.requestableTopic2;
        };
        slotModelApi.IdleStagePort.provide = function(channel) {
            return new slotModelApi.IdleStagePort(channel);
        };
        slotModelApi.IdleStagePort["use"] = function(channel) {
            return new slotModelApi.IdleStagePort(channel);
        };
        slotModelApi.IdleStagePort.prototype.__class__ = slotModelApi.IdleStagePort;

        slotModelApi.IInitStageImplementationPort = function() {}
        slotModelApi.IInitStageImplementationPort.prototype = {

            getInitializeGamePhase: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameLoaded: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameInitialized: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IInitStagePort = function() {}
        slotModelApi.IInitStagePort.prototype = {

            getInitializeGamePhase: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameLoaded: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameInitialized: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.InitStagePort = function(channel, $use) {
            this.initializeReelPicture = new clientkernelEventbusApi.Topic("slotmodel:initializeReelPicture");
            this.gameLoaded = new clientkernelEventbusApi.Topic("slotmodel:presentationLoaded");
            this.gameInitialized = new clientkernelEventbusApi.Topic("slotmodel:gameInitialized");
            this.gameInitialized.connect(channel);
            this.gameLoaded.connect(channel);
            if ($use) this.initializeGamePhasePort = new slotModelApi.InitializeGamePhasePortFactory()["use"](channel);
            else this.initializeGamePhasePort = new slotModelApi.InitializeGamePhasePortFactory().provide(channel);
        };
        slotModelApi.InitStagePort = ck_implements(slotModelApi.InitStagePort, slotModelApi.IInitStagePort);
        slotModelApi.InitStagePort = ck_implements(slotModelApi.InitStagePort, slotModelApi.IInitStageImplementationPort);
        slotModelApi.InitStagePort.__interfaces__ = [slotModelApi.IInitStagePort, slotModelApi.IInitStageImplementationPort];
        slotModelApi.InitStagePort.__name__ = ["slotModelApi", "InitStagePort"];
        slotModelApi.InitStagePort.prototype.gameInitialized = null;
        slotModelApi.InitStagePort.prototype.gameLoaded = null;
        slotModelApi.InitStagePort.prototype.initializeReelPicture = null;
        slotModelApi.InitStagePort.prototype.initializeGamePhasePort = null;
        slotModelApi.InitStagePort.prototype.getInitializeGamePhase = function() {
            return this.initializeGamePhasePort;
        };
        slotModelApi.InitStagePort.prototype.getGameInitialized = function() {
            return this.gameInitialized;
        };
        slotModelApi.InitStagePort.prototype.getGameLoaded = function() {
            return this.gameLoaded;
        };
        slotModelApi.InitStagePort.provide = function(channel) {
            return new slotModelApi.InitStagePort(channel, false);
        };
        slotModelApi.InitStagePort["use"] = function(channel) {
            return new slotModelApi.InitStagePort(channel, true);
        };
        slotModelApi.InitStagePort.prototype.__class__ = slotModelApi.InitStagePort;

        slotModelApi.IInitializeGamePhaseImplementationPort = function() {}
        slotModelApi.IInitializeGamePhaseImplementationPort.prototype = {

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

        slotModelApi.IInitializeGamePhasePort = function() {}
        slotModelApi.IInitializeGamePhasePort.prototype = {

            getInitializeGame: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.InitializeGamePhasePort = function(channel) {
            this.initializeGame = new clientkernelEventbusApi.Topic("slotmodel:initializeGame");
            this.initializeGame.connect(channel);
        };
        slotModelApi.InitializeGamePhasePort = ck_implements(slotModelApi.InitializeGamePhasePort, slotModelApi.IInitializeGamePhasePort);
        slotModelApi.InitializeGamePhasePort = ck_implements(slotModelApi.InitializeGamePhasePort, slotModelApi.IInitializeGamePhaseImplementationPort);
        slotModelApi.InitializeGamePhasePort.__interfaces__ = [slotModelApi.IInitializeGamePhasePort, slotModelApi.IInitializeGamePhaseImplementationPort];
        slotModelApi.InitializeGamePhasePort.__name__ = ["slotModelApi", "InitializeGamePhasePort"];
        slotModelApi.InitializeGamePhasePort.prototype.initializeGame = null;
        slotModelApi.InitializeGamePhasePort.prototype.getInitializeGame = function() {
            return this.initializeGame;
        };
        slotModelApi.InitializeGamePhasePort.prototype.__class__ = slotModelApi.InitializeGamePhasePort;
        slotModelApi.InitializeGamePhasePortFactory = function() {};
        slotModelApi.InitializeGamePhasePortFactory = ck_implements(slotModelApi.InitializeGamePhasePortFactory, componentmodelComponentApi.IPortFactory);
        slotModelApi.InitializeGamePhasePortFactory.__interfaces__ = [componentmodelComponentApi.IPortFactory];
        slotModelApi.InitializeGamePhasePortFactory.__name__ = ["slotModelApi", "InitializeGamePhasePortFactory"];
        slotModelApi.InitializeGamePhasePortFactory.prototype.provide = function(channel) {
            return new slotModelApi.InitializeGamePhasePort(channel);
        };
        slotModelApi.InitializeGamePhasePortFactory.prototype["use"] = function(channel) {
            return new slotModelApi.InitializeGamePhasePort(channel);
        };
        slotModelApi.InitializeGamePhasePortFactory.prototype.__class__ = slotModelApi.InitializeGamePhasePortFactory;

        slotModelApi.IPickerBonusStageImplementationPort = function() {}
        slotModelApi.IPickerBonusStageImplementationPort.prototype = {

            getSelectPickerBonus: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPickerBonusSelected: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPickerBonusSelectedArray: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSetPickerIdle: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IPickerBonusStagePort = function() {}
        slotModelApi.IPickerBonusStagePort.prototype = {

            getSelectPickerBonus: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPickerBonusSelected: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPickerBonusSelectedArray: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSetPickerIdle: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.PickerBonusStagePort = function(channel) {
            this.setPickerIdle = new clientkernelEventbusApi.Topic("slotmodel:setPickerBonusIdle");
            this.pickerBonusSelectedArray = new clientkernelEventbusApi.Topic("slotmodel:pickerBonusSelectedArray");
            this.pickerBonusSelected = new clientkernelEventbusApi.Topic("slotmodel:pickerBonusSelected");
            this.selectPickerBonus = new clientkernelEventbusApi.Topic("slotmodel:selectPickerBonus");
            this.selectPickerBonus.connect(channel);
            this.pickerBonusSelected.connect(channel);
            this.pickerBonusSelectedArray.connect(channel);
            this.setPickerIdle.connect(channel);
        };
        slotModelApi.PickerBonusStagePort = ck_implements(slotModelApi.PickerBonusStagePort, slotModelApi.IPickerBonusStagePort);
        slotModelApi.PickerBonusStagePort = ck_implements(slotModelApi.PickerBonusStagePort, slotModelApi.IPickerBonusStageImplementationPort);
        slotModelApi.PickerBonusStagePort.__interfaces__ = [slotModelApi.IPickerBonusStagePort, slotModelApi.IPickerBonusStageImplementationPort];
        slotModelApi.PickerBonusStagePort.__name__ = ["slotModelApi", "PickerBonusStagePort"];
        slotModelApi.PickerBonusStagePort.prototype.selectPickerBonus = null;
        slotModelApi.PickerBonusStagePort.prototype.pickerBonusSelected = null;
        slotModelApi.PickerBonusStagePort.prototype.pickerBonusSelectedArray = null;
        slotModelApi.PickerBonusStagePort.prototype.setPickerIdle = null;
        slotModelApi.PickerBonusStagePort.prototype.getSelectPickerBonus = function() {
            return this.selectPickerBonus;
        };
        slotModelApi.PickerBonusStagePort.prototype.getPickerBonusSelected = function() {
            return this.pickerBonusSelected;
        };
        slotModelApi.PickerBonusStagePort.prototype.getPickerBonusSelectedArray = function() {
            return this.pickerBonusSelectedArray;
        };
        slotModelApi.PickerBonusStagePort.prototype.getSetPickerIdle = function() {
            return this.setPickerIdle;
        };
        slotModelApi.PickerBonusStagePort.provide = function(channel) {
            return new slotModelApi.PickerBonusStagePort(channel);
        };
        slotModelApi.PickerBonusStagePort["use"] = function(channel) {
            return new slotModelApi.PickerBonusStagePort(channel);
        };
        slotModelApi.PickerBonusStagePort.prototype.__class__ = slotModelApi.PickerBonusStagePort;

        slotModelApi.IResultStageImplementationPort = function() {}
        slotModelApi.IResultStageImplementationPort.prototype = {

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

        slotModelApi.IResultStagePort = function() {}
        slotModelApi.IResultStagePort.prototype = {

            getPresentResult: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResultPresented: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.ResultStagePort = function(channel) {
            this.resultPresented = new clientkernelEventbusApi.Topic("slotmodel:resultPresented");
            this.presentResult = new clientkernelEventbusApi.Topic("slotmodel:presentResult");
            this.presentResult.connect(channel);
            this.resultPresented.connect(channel);
        };
        slotModelApi.ResultStagePort = ck_implements(slotModelApi.ResultStagePort, slotModelApi.IResultStagePort);
        slotModelApi.ResultStagePort = ck_implements(slotModelApi.ResultStagePort, slotModelApi.IResultStageImplementationPort);
        slotModelApi.ResultStagePort.__interfaces__ = [slotModelApi.IResultStagePort, slotModelApi.IResultStageImplementationPort];
        slotModelApi.ResultStagePort.__name__ = ["slotModelApi", "ResultStagePort"];
        slotModelApi.ResultStagePort.prototype.presentResult = null;
        slotModelApi.ResultStagePort.prototype.resultPresented = null;
        slotModelApi.ResultStagePort.prototype.getPresentResult = function() {
            return this.presentResult;
        };
        slotModelApi.ResultStagePort.prototype.getResultPresented = function() {
            return this.resultPresented;
        };
        slotModelApi.ResultStagePort.provide = function(channel) {
            return new slotModelApi.ResultStagePort(channel);
        };
        slotModelApi.ResultStagePort["use"] = function(channel) {
            return new slotModelApi.ResultStagePort(channel);
        };
        slotModelApi.ResultStagePort.prototype.__class__ = slotModelApi.ResultStagePort;

        slotModelApi.IResumeStageImplementationPort = function() {}
        slotModelApi.IResumeStageImplementationPort.prototype = {

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

        slotModelApi.IResumeStagePort = function() {}
        slotModelApi.IResumeStagePort.prototype = {

            getPrepareResume: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getResumePrepared: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.ResumeStagePort = function(channel) {
            this.resumePrepared = new clientkernelEventbusApi.Topic("slotmodel:resumePrepared");
            this.prepareResume = new clientkernelEventbusApi.Topic("slotmodel:prepareResume");
            this.prepareResume.connect(channel);
            this.resumePrepared.connect(channel);
        };
        slotModelApi.ResumeStagePort = ck_implements(slotModelApi.ResumeStagePort, slotModelApi.IResumeStagePort);
        slotModelApi.ResumeStagePort = ck_implements(slotModelApi.ResumeStagePort, slotModelApi.IResumeStageImplementationPort);
        slotModelApi.ResumeStagePort.__interfaces__ = [slotModelApi.IResumeStagePort, slotModelApi.IResumeStageImplementationPort];
        slotModelApi.ResumeStagePort.__name__ = ["slotModelApi", "ResumeStagePort"];
        slotModelApi.ResumeStagePort.prototype.prepareResume = null;
        slotModelApi.ResumeStagePort.prototype.resumePrepared = null;
        slotModelApi.ResumeStagePort.prototype.getPrepareResume = function() {
            return this.prepareResume;
        };
        slotModelApi.ResumeStagePort.prototype.getResumePrepared = function() {
            return this.resumePrepared;
        };
        slotModelApi.ResumeStagePort.provide = function(channel) {
            return new slotModelApi.ResumeStagePort(channel);
        };
        slotModelApi.ResumeStagePort["use"] = function(channel) {
            return new slotModelApi.ResumeStagePort(channel);
        };
        slotModelApi.ResumeStagePort.prototype.__class__ = slotModelApi.ResumeStagePort;

        slotModelApi.ISpinStageImplementationPort = function() {}
        slotModelApi.ISpinStageImplementationPort.prototype = {

            getOutcomePhase: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStartReelSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopReelSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getReelSpinFinished: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.ISpinStagePort = function() {}
        slotModelApi.ISpinStagePort.prototype = {

            getOutcomePhase: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStartReelSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopReelSpin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getReelSpinFinished: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.SpinStagePort = function(channel, $use) {
            this.reelSpinFinished = new clientkernelEventbusApi.Topic("slotmodel:reelSpinFinished");
            this.stopReelSpin = new clientkernelEventbusApi.Topic("slotmodel:stopReelSpin");
            this.startReelSpin = new clientkernelEventbusApi.Topic("slotmodel:startReelSpin");
            this.startReelSpin.connect(channel);
            this.stopReelSpin.connect(channel);
            this.reelSpinFinished.connect(channel);
            if ($use) this.outcomePhasePort = new slotModelApi.OutcomePhasePortFactory()["use"](channel);
            else this.outcomePhasePort = new slotModelApi.OutcomePhasePortFactory().provide(channel);
        };
        slotModelApi.SpinStagePort = ck_implements(slotModelApi.SpinStagePort, slotModelApi.ISpinStagePort);
        slotModelApi.SpinStagePort = ck_implements(slotModelApi.SpinStagePort, slotModelApi.ISpinStageImplementationPort);
        slotModelApi.SpinStagePort.__interfaces__ = [slotModelApi.ISpinStagePort, slotModelApi.ISpinStageImplementationPort];
        slotModelApi.SpinStagePort.__name__ = ["slotModelApi", "SpinStagePort"];
        slotModelApi.SpinStagePort.prototype.startReelSpin = null;
        slotModelApi.SpinStagePort.prototype.stopReelSpin = null;
        slotModelApi.SpinStagePort.prototype.reelSpinFinished = null;
        slotModelApi.SpinStagePort.prototype.outcomePhasePort = null;
        slotModelApi.SpinStagePort.prototype.getOutcomePhase = function() {
            return this.outcomePhasePort;
        };
        slotModelApi.SpinStagePort.prototype.getStartReelSpin = function() {
            return this.startReelSpin;
        };
        slotModelApi.SpinStagePort.prototype.getStopReelSpin = function() {
            return this.stopReelSpin;
        };
        slotModelApi.SpinStagePort.prototype.getReelSpinFinished = function() {
            return this.reelSpinFinished;
        };
        slotModelApi.SpinStagePort.provide = function(channel) {
            return new slotModelApi.SpinStagePort(channel, false);
        };
        slotModelApi.SpinStagePort["use"] = function(channel) {
            return new slotModelApi.SpinStagePort(channel, true);
        };
        slotModelApi.SpinStagePort.prototype.__class__ = slotModelApi.SpinStagePort;

        slotModelApi.IOutcomePhaseImplementationPort = function() {}
        slotModelApi.IOutcomePhaseImplementationPort.prototype = {

            getSpinOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPresentSpinOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinOutcomePresented: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        slotModelApi.IOutcomePhasePort = function() {}
        slotModelApi.IOutcomePhasePort.prototype = {

            getSpinOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPresentSpinOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSpinOutcomePresented: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        slotModelApi.OutcomePhasePort = function(channel) {
            this.spinOutcomePresented = new clientkernelEventbusApi.Topic("slotmodel:spinOutcomePresented");
            this.presentSpinOutcome = new clientkernelEventbusApi.Topic("slotmodel:presentSpinOutcome");
            this.spinOutcome = new clientkernelEventbusApi.Topic("slotmodel:spinOutcome");
            this.spinOutcome.connect(channel);
            this.presentSpinOutcome.connect(channel);
            this.spinOutcomePresented.connect(channel);
        };
        slotModelApi.OutcomePhasePort = ck_implements(slotModelApi.OutcomePhasePort, slotModelApi.IOutcomePhasePort);
        slotModelApi.OutcomePhasePort = ck_implements(slotModelApi.OutcomePhasePort, slotModelApi.IOutcomePhaseImplementationPort);
        slotModelApi.OutcomePhasePort.__interfaces__ = [slotModelApi.IOutcomePhasePort, slotModelApi.IOutcomePhaseImplementationPort];
        slotModelApi.OutcomePhasePort.__name__ = ["slotModelApi", "OutcomePhasePort"];
        slotModelApi.OutcomePhasePort.prototype.spinOutcome = null;
        slotModelApi.OutcomePhasePort.prototype.presentSpinOutcome = null;
        slotModelApi.OutcomePhasePort.prototype.spinOutcomePresented = null;
        slotModelApi.OutcomePhasePort.prototype.getSpinOutcome = function() {
            return this.spinOutcome;
        };
        slotModelApi.OutcomePhasePort.prototype.getPresentSpinOutcome = function() {
            return this.presentSpinOutcome;
        };
        slotModelApi.OutcomePhasePort.prototype.getSpinOutcomePresented = function() {
            return this.spinOutcomePresented;
        };
        slotModelApi.OutcomePhasePort.prototype.__class__ = slotModelApi.OutcomePhasePort;
        slotModelApi.OutcomePhasePortFactory = function() {};
        slotModelApi.OutcomePhasePortFactory = ck_implements(slotModelApi.OutcomePhasePortFactory, componentmodelComponentApi.IPortFactory);
        slotModelApi.OutcomePhasePortFactory.__interfaces__ = [componentmodelComponentApi.IPortFactory];
        slotModelApi.OutcomePhasePortFactory.__name__ = ["slotModelApi", "OutcomePhasePortFactory"];
        slotModelApi.OutcomePhasePortFactory.prototype.provide = function(channel) {
            return new slotModelApi.OutcomePhasePort(channel);
        };
        slotModelApi.OutcomePhasePortFactory.prototype["use"] = function(channel) {
            return new slotModelApi.OutcomePhasePort(channel);
        };
        slotModelApi.OutcomePhasePortFactory.prototype.__class__ = slotModelApi.OutcomePhasePortFactory;
        slotModelApi.LineWin.WIN_TYPE = "Line";;
        slotModelApi.LineWin.WIN_POSITION = 0;;
        slotModelApi.PickerWin.WIN_TYPE = "Picker";;
        slotModelApi.ScatterWin.WIN_TYPE = "Scatter";;
        slotModelApi.ScatterWin.WIN_POSITION = 0;;
        slotModelApi.ScatterWin.WIN_LINEID = 0;;
        return {
            exports: slotModelApi
        };
    });
//# sourceURL=slotModelApi.js