define("pfCommunicatorApi", ["componentmodelComponentApi", "clientkernelEventbusApi"],
    function(componentmodelComponentApi, clientkernelEventbusApi) {
        "use strict";

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

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

        pfCommunicatorApi.IImplementPlatformFrameworkPort = function() {}
        pfCommunicatorApi.IImplementPlatformFrameworkPort.prototype = {

            getClientServicePort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConsoleServicePort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGamePort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getKernelPort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        pfCommunicatorApi.IPlatformFrameworkPort = function() {}
        pfCommunicatorApi.IPlatformFrameworkPort.prototype = {

            getClientServicePort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getConsoleServicePort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGamePort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getKernelPort: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        pfCommunicatorApi.PlatformFrameworkPort = function(clientServiceChannel, consoleServiceChannel, gameChannel, kernelChannel, $use) {
            if ($use) {
                this.clientServicePort = pfCommunicatorApi.ClientServicePort["use"](clientServiceChannel);
                this.consoleServicePort = pfCommunicatorApi.ConsoleServicePort["use"](consoleServiceChannel);
                this.gamePort = pfCommunicatorApi.GamePort["use"](gameChannel);
                this.kernelPort = pfCommunicatorApi.KernelPort["use"](kernelChannel);
            } else {
                this.clientServicePort = pfCommunicatorApi.ClientServicePort.provide(clientServiceChannel);
                this.consoleServicePort = pfCommunicatorApi.ConsoleServicePort.provide(consoleServiceChannel);
                this.gamePort = pfCommunicatorApi.GamePort.provide(gameChannel);
                this.kernelPort = pfCommunicatorApi.KernelPort.provide(kernelChannel);
            }
        };
        pfCommunicatorApi.PlatformFrameworkPort = ck_implements(pfCommunicatorApi.PlatformFrameworkPort, pfCommunicatorApi.IImplementPlatformFrameworkPort);
        pfCommunicatorApi.PlatformFrameworkPort = ck_implements(pfCommunicatorApi.PlatformFrameworkPort, pfCommunicatorApi.IPlatformFrameworkPort);
        pfCommunicatorApi.PlatformFrameworkPort.__interfaces__ = [pfCommunicatorApi.IImplementPlatformFrameworkPort, pfCommunicatorApi.IPlatformFrameworkPort];
        pfCommunicatorApi.PlatformFrameworkPort.__name__ = ["pfCommunicatorApi", "PlatformFrameworkPort"];
        pfCommunicatorApi.PlatformFrameworkPort.prototype.clientServicePort = null;
        pfCommunicatorApi.PlatformFrameworkPort.prototype.consoleServicePort = null;
        pfCommunicatorApi.PlatformFrameworkPort.prototype.gamePort = null;
        pfCommunicatorApi.PlatformFrameworkPort.prototype.kernelPort = null;
        pfCommunicatorApi.PlatformFrameworkPort.prototype.getClientServicePort = function() {
            return this.clientServicePort;
        };
        pfCommunicatorApi.PlatformFrameworkPort.prototype.getConsoleServicePort = function() {
            return this.consoleServicePort;
        };
        pfCommunicatorApi.PlatformFrameworkPort.prototype.getGamePort = function() {
            return this.gamePort;
        };
        pfCommunicatorApi.PlatformFrameworkPort.prototype.getKernelPort = function() {
            return this.kernelPort;
        };
        pfCommunicatorApi.PlatformFrameworkPort.provide = function(clientServiceChannel, consoleServiceChannel, gameChannel, kernelChannel) {
            return new pfCommunicatorApi.PlatformFrameworkPort(clientServiceChannel, consoleServiceChannel, gameChannel, kernelChannel, false);
        };
        pfCommunicatorApi.PlatformFrameworkPort["use"] = function(clientServiceChannel, consoleServiceChannel, gameChannel, kernelChannel) {
            return new pfCommunicatorApi.PlatformFrameworkPort(clientServiceChannel, consoleServiceChannel, gameChannel, kernelChannel, true);
        };
        pfCommunicatorApi.PlatformFrameworkPort.prototype.__class__ = pfCommunicatorApi.PlatformFrameworkPort;

        pfCommunicatorApi.IClientServicePort = function() {}
        pfCommunicatorApi.IClientServicePort.prototype = {

            getGameInit: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAccountBalances: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStateChange: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getErrorHandlerNotify: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopAutospin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getClientEventCapture: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        pfCommunicatorApi.IImplementClientServicePort = function() {}
        pfCommunicatorApi.IImplementClientServicePort.prototype = {

            getGameInit: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAccountBalances: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStateChange: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getErrorHandlerNotify: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStopAutospin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getClientEventCapture: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        pfCommunicatorApi.ClientServicePort = function(channel) {
            this.clientEventCapture = new clientkernelEventbusApi.Topic("CECEvent");
            this.stopAutoSpin = new clientkernelEventbusApi.Topic("Game.StopAutoSpin");
            this.errorHandlerNotify = new clientkernelEventbusApi.Topic("ErrorHandler.Notify");
            this.stateChange = new clientkernelEventbusApi.Request("StateChange");
            this.accountBalances = new clientkernelEventbusApi.Topic("Account.Balances");
            this.gameInit = new clientkernelEventbusApi.Topic("Game.Init");
            this.connect(channel);
        };
        pfCommunicatorApi.ClientServicePort = ck_implements(pfCommunicatorApi.ClientServicePort, pfCommunicatorApi.IClientServicePort);
        pfCommunicatorApi.ClientServicePort = ck_implements(pfCommunicatorApi.ClientServicePort, pfCommunicatorApi.IImplementClientServicePort);
        pfCommunicatorApi.ClientServicePort.__interfaces__ = [pfCommunicatorApi.IClientServicePort, pfCommunicatorApi.IImplementClientServicePort];
        pfCommunicatorApi.ClientServicePort.__name__ = ["pfCommunicatorApi", "ClientServicePort"];
        pfCommunicatorApi.ClientServicePort.prototype.gameInit = null;
        pfCommunicatorApi.ClientServicePort.prototype.accountBalances = null;
        pfCommunicatorApi.ClientServicePort.prototype.stateChange = null;
        pfCommunicatorApi.ClientServicePort.prototype.errorHandlerNotify = null;
        pfCommunicatorApi.ClientServicePort.prototype.stopAutoSpin = null;
        pfCommunicatorApi.ClientServicePort.prototype.clientEventCapture = null;
        pfCommunicatorApi.ClientServicePort.prototype.connect = function(channel) {
            this.gameInit.connect(channel);
            this.accountBalances.connect(channel);
            this.stateChange.connect(channel);
            this.errorHandlerNotify.connect(channel);
            this.stopAutoSpin.connect(channel);
            this.clientEventCapture.connect(channel);
        };
        pfCommunicatorApi.ClientServicePort.prototype.getGameInit = function() {
            return this.gameInit;
        };
        pfCommunicatorApi.ClientServicePort.prototype.getAccountBalances = function() {
            return this.accountBalances;
        };
        pfCommunicatorApi.ClientServicePort.prototype.getStateChange = function() {
            return this.stateChange;
        };
        pfCommunicatorApi.ClientServicePort.prototype.getErrorHandlerNotify = function() {
            return this.errorHandlerNotify;
        };
        pfCommunicatorApi.ClientServicePort.prototype.getStopAutospin = function() {
            return this.stopAutoSpin;
        };
        pfCommunicatorApi.ClientServicePort.prototype.getClientEventCapture = function() {
            return this.clientEventCapture;
        };
        pfCommunicatorApi.ClientServicePort.provide = function(channel) {
            return new pfCommunicatorApi.ClientServicePort(channel);
        };
        pfCommunicatorApi.ClientServicePort["use"] = function(channel) {
            return new pfCommunicatorApi.ClientServicePort(channel);
        };
        pfCommunicatorApi.ClientServicePort.get = function(channel) {
            return new pfCommunicatorApi.ClientServicePort(channel);
        };
        pfCommunicatorApi.ClientServicePort.prototype.__class__ = pfCommunicatorApi.ClientServicePort;
        pfCommunicatorApi.Action = function(action) {
            this.action = action;
        };
        pfCommunicatorApi.Action.__name__ = ["pfCommunicatorApi", "Action"];
        pfCommunicatorApi.Action.prototype.action = null;
        pfCommunicatorApi.Action.prototype.__class__ = pfCommunicatorApi.Action;
        pfCommunicatorApi.Balance = function(balance, balanceValue) {
            this.balance = balance;
            this.balanceValue = balanceValue;
        };
        pfCommunicatorApi.Balance.__name__ = ["pfCommunicatorApi", "Balance"];
        pfCommunicatorApi.Balance.prototype.balance = null;
        pfCommunicatorApi.Balance.prototype.balanceValue = null;
        pfCommunicatorApi.Balance.prototype.__class__ = pfCommunicatorApi.Balance;
        pfCommunicatorApi.CecPayload = function(name, properties) {
            this.name = name;
            this.properties = properties;
        };
        pfCommunicatorApi.CecPayload.__name__ = ["pfCommunicatorApi", "CecPayload"];
        pfCommunicatorApi.CecPayload.prototype.name = null;
        pfCommunicatorApi.CecPayload.prototype.properties = null;
        pfCommunicatorApi.CecPayload.prototype.__class__ = pfCommunicatorApi.CecPayload;
        pfCommunicatorApi.ClientEventCapture = function(topic, payload) {
            this.topic = topic;
            this.payload = payload;
        };
        pfCommunicatorApi.ClientEventCapture.__name__ = ["pfCommunicatorApi", "ClientEventCapture"];
        pfCommunicatorApi.ClientEventCapture.prototype.topic = null;
        pfCommunicatorApi.ClientEventCapture.prototype.payload = null;
        pfCommunicatorApi.ClientEventCapture.prototype.__class__ = pfCommunicatorApi.ClientEventCapture;
        pfCommunicatorApi.StateChange = function(state, nextStage, response) {
            this.state = state;
            this.nextStage = nextStage;
            this.response = response;
        };
        pfCommunicatorApi.StateChange.__name__ = ["pfCommunicatorApi", "StateChange"];
        pfCommunicatorApi.StateChange.prototype.state = null;
        pfCommunicatorApi.StateChange.prototype.nextStage = null;
        pfCommunicatorApi.StateChange.prototype.response = null;
        pfCommunicatorApi.StateChange.prototype.__class__ = pfCommunicatorApi.StateChange;

        pfCommunicatorApi.IConsoleServicePort = function() {}
        pfCommunicatorApi.IConsoleServicePort.prototype = {

            getConsoleControlEvent: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameHelpPage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGamePaytablePage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        pfCommunicatorApi.IImplementConsoleServicePort = function() {}
        pfCommunicatorApi.IImplementConsoleServicePort.prototype = {

            getConsoleControlEvent: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameHelpPage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGamePaytablePage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        pfCommunicatorApi.ConsoleServicePort = function(channel) {
            this.gamePaytablePage = new clientkernelEventbusApi.Topic("Game.PaytablePage");
            this.gameHelpPage = new clientkernelEventbusApi.Topic("Game.HelpPage");
            this.consoleControlEvent = new clientkernelEventbusApi.Topic("Game.Control");
            this.connect(channel);
        };
        pfCommunicatorApi.ConsoleServicePort = ck_implements(pfCommunicatorApi.ConsoleServicePort, pfCommunicatorApi.IConsoleServicePort);
        pfCommunicatorApi.ConsoleServicePort = ck_implements(pfCommunicatorApi.ConsoleServicePort, pfCommunicatorApi.IImplementConsoleServicePort);
        pfCommunicatorApi.ConsoleServicePort.__interfaces__ = [pfCommunicatorApi.IConsoleServicePort, pfCommunicatorApi.IImplementConsoleServicePort];
        pfCommunicatorApi.ConsoleServicePort.__name__ = ["pfCommunicatorApi", "ConsoleServicePort"];
        pfCommunicatorApi.ConsoleServicePort.prototype.consoleControlEvent = null;
        pfCommunicatorApi.ConsoleServicePort.prototype.gameHelpPage = null;
        pfCommunicatorApi.ConsoleServicePort.prototype.gamePaytablePage = null;
        pfCommunicatorApi.ConsoleServicePort.prototype.connect = function(channel) {
            this.consoleControlEvent.connect(channel);
            this.gameHelpPage.connect(channel);
            this.gamePaytablePage.connect(channel);
        };
        pfCommunicatorApi.ConsoleServicePort.prototype.getConsoleControlEvent = function() {
            return this.consoleControlEvent;
        };
        pfCommunicatorApi.ConsoleServicePort.prototype.getGameHelpPage = function() {
            return this.gameHelpPage;
        };
        pfCommunicatorApi.ConsoleServicePort.prototype.getGamePaytablePage = function() {
            return this.gamePaytablePage;
        };
        pfCommunicatorApi.ConsoleServicePort.provide = function(channel) {
            return new pfCommunicatorApi.ConsoleServicePort(channel);
        };
        pfCommunicatorApi.ConsoleServicePort["use"] = function(channel) {
            return new pfCommunicatorApi.ConsoleServicePort(channel);
        };
        pfCommunicatorApi.ConsoleServicePort.get = function(channel) {
            return new pfCommunicatorApi.ConsoleServicePort(channel);
        };
        pfCommunicatorApi.ConsoleServicePort.prototype.__class__ = pfCommunicatorApi.ConsoleServicePort;
        pfCommunicatorApi.ConsoleControlEvent = function(option, value, params) {
            this.option = option;
            this.value = value;
        };
        pfCommunicatorApi.ConsoleControlEvent.__name__ = ["pfCommunicatorApi", "ConsoleControlEvent"];
        pfCommunicatorApi.ConsoleControlEvent.prototype.option = null;
        pfCommunicatorApi.ConsoleControlEvent.prototype.value = null;
        pfCommunicatorApi.ConsoleControlEvent.prototype.__class__ = pfCommunicatorApi.ConsoleControlEvent;

        pfCommunicatorApi.IGamePort = function() {}
        pfCommunicatorApi.IGamePort.prototype = {

            getInitDone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRegister: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameControlEvent: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlay: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDeductStake: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameInfo: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getClose: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFullscreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinOption: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinStopped: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinStart: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        pfCommunicatorApi.IImplementGamePort = function() {}
        pfCommunicatorApi.IImplementGamePort.prototype = {

            getInitDone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRegister: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameControlEvent: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPlay: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getDeductStake: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getGameInfo: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getClose: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getFullscreen: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinOption: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinStopped: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getAutoSpinStart: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        pfCommunicatorApi.GamePort = function(channel) {
            this.autoSpinOption = new clientkernelEventbusApi.Request("Game.AutoSpinOption");
            this.autoSpinStopped = new clientkernelEventbusApi.Topic("Game.AutoSpinStopped");
            this.autoSpinStart = new clientkernelEventbusApi.Topic("Game.AutoSpinStart");
            this.fullscreen = new clientkernelEventbusApi.Topic("Game.Fullscreen");
            this.close = new clientkernelEventbusApi.Topic("Close");
            this.gameInfo = new clientkernelEventbusApi.Topic("Game.GameInfo");
            this.deductStake = new clientkernelEventbusApi.Topic("Game.DeductStake");
            this.play = new clientkernelEventbusApi.Topic("Game.PlayData");
            this.gameControlEvent = new clientkernelEventbusApi.Topic("Game.Control");
            this.register = new clientkernelEventbusApi.Topic("Game.Register");
            this.initDone = new clientkernelEventbusApi.Topic("Game.InitDone");
            this.connect(channel);
        };
        pfCommunicatorApi.GamePort = ck_implements(pfCommunicatorApi.GamePort, pfCommunicatorApi.IGamePort);
        pfCommunicatorApi.GamePort = ck_implements(pfCommunicatorApi.GamePort, pfCommunicatorApi.IImplementGamePort);
        pfCommunicatorApi.GamePort.__interfaces__ = [pfCommunicatorApi.IGamePort, pfCommunicatorApi.IImplementGamePort];
        pfCommunicatorApi.GamePort.__name__ = ["pfCommunicatorApi", "GamePort"];
        pfCommunicatorApi.GamePort.prototype.initDone = null;
        pfCommunicatorApi.GamePort.prototype.register = null;
        pfCommunicatorApi.GamePort.prototype.gameControlEvent = null;
        pfCommunicatorApi.GamePort.prototype.play = null;
        pfCommunicatorApi.GamePort.prototype.deductStake = null;
        pfCommunicatorApi.GamePort.prototype.gameInfo = null;
        pfCommunicatorApi.GamePort.prototype.close = null;
        pfCommunicatorApi.GamePort.prototype.fullscreen = null;
        pfCommunicatorApi.GamePort.prototype.autoSpinStart = null;
        pfCommunicatorApi.GamePort.prototype.autoSpinStopped = null;
        pfCommunicatorApi.GamePort.prototype.autoSpinOption = null;
        pfCommunicatorApi.GamePort.prototype.connect = function(channel) {
            this.initDone.connect(channel);
            this.register.connect(channel);
            this.gameControlEvent.connect(channel);
            this.play.connect(channel);
            this.deductStake.connect(channel);
            this.close.connect(channel);
            this.gameInfo.connect(channel);
            this.fullscreen.connect(channel);
            this.autoSpinStart.connect(channel);
            this.autoSpinStopped.connect(channel);
            this.autoSpinOption.connect(channel);
        };
        pfCommunicatorApi.GamePort.prototype.getInitDone = function() {
            return this.initDone;
        };
        pfCommunicatorApi.GamePort.prototype.getRegister = function() {
            return this.register;
        };
        pfCommunicatorApi.GamePort.prototype.getGameControlEvent = function() {
            return this.gameControlEvent;
        };
        pfCommunicatorApi.GamePort.prototype.getPlay = function() {
            return this.play;
        };
        pfCommunicatorApi.GamePort.prototype.getDeductStake = function() {
            return this.deductStake;
        };
        pfCommunicatorApi.GamePort.prototype.getGameInfo = function() {
            return this.gameInfo;
        };
        pfCommunicatorApi.GamePort.prototype.getClose = function() {
            return this.close;
        };
        pfCommunicatorApi.GamePort.prototype.getFullscreen = function() {
            return this.fullscreen;
        };
        pfCommunicatorApi.GamePort.prototype.getAutoSpinStart = function() {
            return this.autoSpinStart;
        };
        pfCommunicatorApi.GamePort.prototype.getAutoSpinStopped = function() {
            return this.autoSpinStopped;
        };
        pfCommunicatorApi.GamePort.prototype.getAutoSpinOption = function() {
            return this.autoSpinOption;
        };
        pfCommunicatorApi.GamePort.provide = function(channel) {
            return new pfCommunicatorApi.GamePort(channel);
        };
        pfCommunicatorApi.GamePort["use"] = function(channel) {
            return new pfCommunicatorApi.GamePort(channel);
        };
        pfCommunicatorApi.GamePort.get = function(channel) {
            return new pfCommunicatorApi.GamePort(channel);
        };
        pfCommunicatorApi.GamePort.prototype.__class__ = pfCommunicatorApi.GamePort;
        pfCommunicatorApi.ActionInput = function(actionName) {
            this.Action = actionName;
        };
        pfCommunicatorApi.ActionInput.__name__ = ["pfCommunicatorApi", "ActionInput"];
        pfCommunicatorApi.ActionInput.prototype.Action = null;
        pfCommunicatorApi.ActionInput.prototype.__class__ = pfCommunicatorApi.ActionInput;
        pfCommunicatorApi.AutospinPayload = function(steps, lossLimit, winLimit, action) {
            this.action = action;
            this.winLimit = winLimit;
            this.lossLimit = lossLimit;
            this.steps = steps;
        };
        pfCommunicatorApi.AutospinPayload.__name__ = ["pfCommunicatorApi", "AutospinPayload"];
        pfCommunicatorApi.AutospinPayload.prototype.action = null;
        pfCommunicatorApi.AutospinPayload.prototype.winLimit = null;
        pfCommunicatorApi.AutospinPayload.prototype.lossLimit = null;
        pfCommunicatorApi.AutospinPayload.prototype.steps = null;
        pfCommunicatorApi.AutospinPayload.prototype.__class__ = pfCommunicatorApi.AutospinPayload;
        pfCommunicatorApi.Close = function() {};
        pfCommunicatorApi.Close.__name__ = ["pfCommunicatorApi", "Close"];
        pfCommunicatorApi.Close.prototype.__class__ = pfCommunicatorApi.Close;
        pfCommunicatorApi.GameControlEvent = function(name, event, params) {
            this.name = name;
            this.event = event;
            this.params = params;
        };
        pfCommunicatorApi.GameControlEvent.__name__ = ["pfCommunicatorApi", "GameControlEvent"];
        pfCommunicatorApi.GameControlEvent.prototype.name = null;
        pfCommunicatorApi.GameControlEvent.prototype.event = null;
        pfCommunicatorApi.GameControlEvent.prototype.params = null;
        pfCommunicatorApi.GameControlEvent.prototype.__class__ = pfCommunicatorApi.GameControlEvent;
        pfCommunicatorApi.InitDone = function(version) {
            this.version = version;
        };
        pfCommunicatorApi.InitDone.__name__ = ["pfCommunicatorApi", "InitDone"];
        pfCommunicatorApi.InitDone.prototype.version = null;
        pfCommunicatorApi.InitDone.prototype.__class__ = pfCommunicatorApi.InitDone;
        pfCommunicatorApi.Link = function(id, url) {
            this.id = id;
            this.url = url;
        };
        pfCommunicatorApi.Link.__name__ = ["pfCommunicatorApi", "Link"];
        pfCommunicatorApi.Link.prototype.id = null;
        pfCommunicatorApi.Link.prototype.url = null;
        pfCommunicatorApi.Link.prototype.__class__ = pfCommunicatorApi.Link;
        pfCommunicatorApi.Option = function(type, name, text, enabled, value, values, valueText) {
            this.type = type;
            this.name = name;
            this.text = text;
            this.enabled = enabled;
            this.value = value;
            this.values = values;
            this.valueText = valueText;
        };
        pfCommunicatorApi.Option.__name__ = ["pfCommunicatorApi", "Option"];
        pfCommunicatorApi.Option.prototype.type = null;
        pfCommunicatorApi.Option.prototype.name = null;
        pfCommunicatorApi.Option.prototype.text = null;
        pfCommunicatorApi.Option.prototype.enabled = null;
        pfCommunicatorApi.Option.prototype.value = null;
        pfCommunicatorApi.Option.prototype.values = null;
        pfCommunicatorApi.Option.prototype.valueText = null;
        pfCommunicatorApi.Option.prototype.__class__ = pfCommunicatorApi.Option;
        pfCommunicatorApi.Options = function(options) {
            this.options = options;
        };
        pfCommunicatorApi.Options.__name__ = ["pfCommunicatorApi", "Options"];
        pfCommunicatorApi.Options.prototype.options = null;
        pfCommunicatorApi.Options.prototype.__class__ = pfCommunicatorApi.Options;
        pfCommunicatorApi.OptionsInput = function(name, value) {
            if (value == null) value = "";
            var pickObj = {};
            pickObj["@name"] = name;
            pickObj["#text"] = value;
            this.Option = pickObj;
        };
        pfCommunicatorApi.OptionsInput.__name__ = ["pfCommunicatorApi", "OptionsInput"];
        pfCommunicatorApi.OptionsInput.prototype.Option = null;
        pfCommunicatorApi.OptionsInput.prototype.__class__ = pfCommunicatorApi.OptionsInput;
        pfCommunicatorApi.PatternSliderInput = function(BetPerPattern, PatternsBet) {
            this.BetPerPattern = BetPerPattern;
            this.PatternsBet = PatternsBet;
        };
        pfCommunicatorApi.PatternSliderInput.__name__ = ["pfCommunicatorApi", "PatternSliderInput"];
        pfCommunicatorApi.PatternSliderInput.prototype.BetPerPattern = null;
        pfCommunicatorApi.PatternSliderInput.prototype.PatternsBet = null;
        pfCommunicatorApi.PatternSliderInput.prototype.__class__ = pfCommunicatorApi.PatternSliderInput;
        pfCommunicatorApi.PfMessage = function(type, id, message) {
            this.type = type;
            this.id = id;
            this.message = message;
        };
        pfCommunicatorApi.PfMessage.__name__ = ["pfCommunicatorApi", "PfMessage"];
        pfCommunicatorApi.PfMessage.prototype.type = null;
        pfCommunicatorApi.PfMessage.prototype.id = null;
        pfCommunicatorApi.PfMessage.prototype.message = null;
        pfCommunicatorApi.PfMessage.prototype.__class__ = pfCommunicatorApi.PfMessage;
        pfCommunicatorApi.PickerInput = function(names) {
            if (names.length == 1) {
                var pickObj = {};
                pickObj["@name"] = names[0];
                pickObj["#text"] = names[0];
                this.Pick = pickObj;
            } else {
                var pickObjArray = [];
                var _g = 0;
                while (_g < names.length) {
                    var name = names[_g];
                    ++_g;
                    var pickObj1 = {};
                    pickObj1["@name"] = name;
                    pickObj1["#text"] = name;
                    pickObjArray.push(pickObj1);
                }
                this.Pick = pickObjArray;
            }
        };
        pfCommunicatorApi.PickerInput.__name__ = ["pfCommunicatorApi", "PickerInput"];
        pfCommunicatorApi.PickerInput.prototype.Pick = null;
        pfCommunicatorApi.PickerInput.prototype.__class__ = pfCommunicatorApi.PickerInput;
        pfCommunicatorApi.PlayData = function(actionInput, patternSliderInput, wagerInput, pickerInput, optionsInput) {
            this.ActionInput = actionInput;
            this.PatternSliderInput = patternSliderInput;
            this.WagerInput = wagerInput;
            this.PickerInput = pickerInput;
            this.OptionsInput = optionsInput;
        };
        pfCommunicatorApi.PlayData.__name__ = ["pfCommunicatorApi", "PlayData"];
        pfCommunicatorApi.PlayData.prototype.ActionInput = null;
        pfCommunicatorApi.PlayData.prototype.PatternSliderInput = null;
        pfCommunicatorApi.PlayData.prototype.WagerInput = null;
        pfCommunicatorApi.PlayData.prototype.PickerInput = null;
        pfCommunicatorApi.PlayData.prototype.OptionsInput = null;
        pfCommunicatorApi.PlayData.prototype.__class__ = pfCommunicatorApi.PlayData;
        pfCommunicatorApi.Preference = function(pref) {
            this.Preference = pref;
        };
        pfCommunicatorApi.Preference.__name__ = ["pfCommunicatorApi", "Preference"];
        pfCommunicatorApi.Preference.prototype.Preference = null;
        pfCommunicatorApi.Preference.prototype.__class__ = pfCommunicatorApi.Preference;
        pfCommunicatorApi.StateChangeReply = function(state, param) {
            this.state = state;
            this.param = param;
        };
        pfCommunicatorApi.StateChangeReply.__name__ = ["pfCommunicatorApi", "StateChangeReply"];
        pfCommunicatorApi.StateChangeReply.prototype.state = null;
        pfCommunicatorApi.StateChangeReply.prototype.param = null;
        pfCommunicatorApi.StateChangeReply.prototype.__class__ = pfCommunicatorApi.StateChangeReply;
        pfCommunicatorApi.Version = function(gameVersion, gleVersion) {
            this.gameVersion = gameVersion;
            this.gleVersion = gleVersion;
        };
        pfCommunicatorApi.Version.__name__ = ["pfCommunicatorApi", "Version"];
        pfCommunicatorApi.Version.prototype.gameVersion = null;
        pfCommunicatorApi.Version.prototype.gleVersion = null;
        pfCommunicatorApi.Version.prototype.__class__ = pfCommunicatorApi.Version;
        pfCommunicatorApi.WagerInput = function() {
            this.Wager = [];
        };
        pfCommunicatorApi.WagerInput.__name__ = ["pfCommunicatorApi", "WagerInput"];
        pfCommunicatorApi.WagerInput.prototype.Wager = null;
        pfCommunicatorApi.WagerInput.prototype.add = function(name, value) {
            this.Wager.push({
                '@name': name,
                '#text': value
            });
        };
        pfCommunicatorApi.WagerInput.prototype.setName = function(name) {
            this["@name"] = name;
        };
        pfCommunicatorApi.WagerInput.prototype.setWager = function(wager) {
            this.Wager = wager;
        };
        pfCommunicatorApi.WagerInput.prototype.setCustom = function(custom) {
            var _g1 = 0;
            var _g = custom.length;
            while (_g1 < _g) {
                var i = _g1++;
                var item = custom[i];
                _hcmn_.Reflect.setField(this, item.name, item.value);
            }
        };
        pfCommunicatorApi.WagerInput.prototype.__class__ = pfCommunicatorApi.WagerInput;

        pfCommunicatorApi.IImplementKernelPort = function() {}
        pfCommunicatorApi.IImplementKernelPort.prototype = {

            getLoadProgress: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSystemInit: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSystemReady: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        pfCommunicatorApi.IKernelPort = function() {}
        pfCommunicatorApi.IKernelPort.prototype = {

            getLoadProgress: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSystemInit: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getSystemReady: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        pfCommunicatorApi.KernelPort = function(channel) {
            this.systemReady = new clientkernelEventbusApi.Topic("System.Ready");
            this.systemInit = new clientkernelEventbusApi.Topic("System.Init");
            this.loadProgress = new clientkernelEventbusApi.Topic("LoadProgress");
            this.connect(channel);
        };
        pfCommunicatorApi.KernelPort = ck_implements(pfCommunicatorApi.KernelPort, pfCommunicatorApi.IKernelPort);
        pfCommunicatorApi.KernelPort = ck_implements(pfCommunicatorApi.KernelPort, pfCommunicatorApi.IImplementKernelPort);
        pfCommunicatorApi.KernelPort.__interfaces__ = [pfCommunicatorApi.IKernelPort, pfCommunicatorApi.IImplementKernelPort];
        pfCommunicatorApi.KernelPort.__name__ = ["pfCommunicatorApi", "KernelPort"];
        pfCommunicatorApi.KernelPort.prototype.loadProgress = null;
        pfCommunicatorApi.KernelPort.prototype.systemInit = null;
        pfCommunicatorApi.KernelPort.prototype.systemReady = null;
        pfCommunicatorApi.KernelPort.prototype.connect = function(channel) {
            this.loadProgress.connect(channel);
            this.systemInit.connect(channel);
            this.systemReady.connect(channel);
        };
        pfCommunicatorApi.KernelPort.prototype.getLoadProgress = function() {
            return this.loadProgress;
        };
        pfCommunicatorApi.KernelPort.prototype.getSystemInit = function() {
            return this.systemInit;
        };
        pfCommunicatorApi.KernelPort.prototype.getSystemReady = function() {
            return this.systemReady;
        };
        pfCommunicatorApi.KernelPort.provide = function(channel) {
            return new pfCommunicatorApi.KernelPort(channel);
        };
        pfCommunicatorApi.KernelPort["use"] = function(channel) {
            return new pfCommunicatorApi.KernelPort(channel);
        };
        pfCommunicatorApi.KernelPort.get = function(channel) {
            return new pfCommunicatorApi.KernelPort(channel);
        };
        pfCommunicatorApi.KernelPort.prototype.__class__ = pfCommunicatorApi.KernelPort;
        pfCommunicatorApi.LoadProgress = function(complete, current, id, items) {
            this.complete = complete;
            this.current = current;
            this.id = id;
            this.items = items;
        };
        pfCommunicatorApi.LoadProgress.__name__ = ["pfCommunicatorApi", "LoadProgress"];
        pfCommunicatorApi.LoadProgress.prototype.complete = null;
        pfCommunicatorApi.LoadProgress.prototype.current = null;
        pfCommunicatorApi.LoadProgress.prototype.id = null;
        pfCommunicatorApi.LoadProgress.prototype.items = null;
        pfCommunicatorApi.LoadProgress.prototype.__class__ = pfCommunicatorApi.LoadProgress;
        return {
            exports: pfCommunicatorApi
        };
    });
//# sourceURL=pfCommunicatorApi3.js