//! Script# Browser Compat Layer
//! Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
//! http://projects.nikhilk.net
//!

function __loadCompatLayer(w) {
    w.Debug = function() {
    };
    w.Debug._fail = function(message) {
        throw new Error(message);
    };
    w.Debug.writeln = function(text) {
        if (window.console) {
            if (window.console.debug) {
                window.console.debug(text);
                return;
            }
            else if (window.console.log) {
                window.console.log(text);
                return;
            }
        }
        else if (window.opera &&
            window.opera.postError) {
            window.opera.postError(text);
            return;
        }
    };

    w.__getNonTextNode = function(node) {
        try {
            while (node && (node.nodeType != 1)) {
                node = node.parentNode;
            }
        }
        catch (ex) {
            node = null;
        }
        return node;
    };
    
    w.__getLocation = function(e) {
        var loc = {x : 0, y : 0};
        while (e) {
            loc.x += e.offsetLeft;
            loc.y += e.offsetTop;
            e = e.offsetParent;
        }
        return loc;
    };

    // Allow caching regex objects for performance
    RegExp._cacheable = true;

    // Skip RegExp.test in String.quote to improve performance.
    String._quoteSkipTest = true;

    w.navigate = function(url) {
        window.setTimeout('window.location = "' + url + '";', 0);
    };

    var attachEventProxy = function(eventName, eventHandler) {
        eventHandler._mozillaEventHandler = function(e) {
            window.event = e;
            eventHandler();
            if (!e.avoidReturn) {
                return e.returnValue;
            }
        };
        this.addEventListener(eventName.slice(2), eventHandler._mozillaEventHandler, false);
    };

    var detachEventProxy = function (eventName, eventHandler) {
        if (eventHandler._mozillaEventHandler) {
            var mozillaEventHandler = eventHandler._mozillaEventHandler;
            delete eventHandler._mozillaEventHandler;
            
            this.removeEventListener(eventName.slice(2), mozillaEventHandler, false);
        }
    };

    w.attachEvent = attachEventProxy;
    w.detachEvent = detachEventProxy;
    w.HTMLDocument.prototype.attachEvent = attachEventProxy;
    w.HTMLDocument.prototype.detachEvent = detachEventProxy;
    w.HTMLElement.prototype.attachEvent = attachEventProxy;
    w.HTMLElement.prototype.detachEvent = detachEventProxy;

    w.Event.prototype.__defineGetter__('srcElement', function() {
        // __getNonTextNode(this.target) is the expected implementation.
        // However script.load has target set to the Document object... so we
        // need to throw in currentTarget as well.
        return __getNonTextNode(this.target) || this.currentTarget;
    });
    w.Event.prototype.__defineGetter__('cancelBubble', function() {
        return this._bubblingCanceled || false;
    });
    w.Event.prototype.__defineSetter__('cancelBubble', function(v) {
        if (v) {
            this._bubblingCanceled = true;
            this.stopPropagation();
        }
    });
    w.Event.prototype.__defineGetter__('returnValue', function() {
        return !this._cancelDefault;
    });
    w.Event.prototype.__defineSetter__('returnValue', function(v) {
        if (!v) {
            this._cancelDefault = true;
            this.preventDefault();
        }
    });
    w.Event.prototype.__defineGetter__('fromElement', function () {
        var n;
        if (this.type == 'mouseover') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseout') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    w.Event.prototype.__defineGetter__('toElement', function () {
        var n;
        if (this.type == 'mouseout') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseover') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    w.Event.prototype.__defineGetter__('button', function() {
        return (this.which == 1) ? 1 : (this.which == 3) ? 2 : 0
    });
    w.Event.prototype.__defineGetter__('offsetX', function() {
        return window.pageXOffset + this.clientX - __getLocation(this.srcElement).x;
    });
    w.Event.prototype.__defineGetter__('offsetY', function() {
        return window.pageYOffset + this.clientY - __getLocation(this.srcElement).y;
    });

    w.HTMLElement.prototype.__defineGetter__('parentElement', function() {
        return this.parentNode;
    });
    w.HTMLElement.prototype.__defineGetter__('children', function() {
        var children = [];
        var childCount = this.childNodes.length;
        for (var i = 0; i < childCount; i++) {
            var childNode = this.childNodes[i];
            if (childNode.nodeType == 1) {
                children.push(childNode);
            }
        }
        return children;
    });
    w.HTMLElement.prototype.__defineGetter__('innerText', function() {    
        try {
            return this.textContent
        } 
        catch (ex) {
            var text = '';
            for (var i=0; i < this.childNodes.length; i++) {
                if (this.childNodes[i].nodeType == 3) {
                    text += this.childNodes[i].textContent;
                }
            }
            return str;
        }
    });
    w.HTMLElement.prototype.__defineSetter__('innerText', function(v) {
        var textNode = document.createTextNode(v);
        this.innerHTML = '';
        this.appendChild(textNode);
    });
    w.HTMLElement.prototype.__defineGetter__('currentStyle', function() {
        return window.getComputedStyle(this, null);
    });
    w.HTMLElement.prototype.__defineGetter__('runtimeStyle', function() {
        return window.getOverrideStyle(this, null);
    });
    w.HTMLElement.prototype.removeNode = function(b) {
        return this.parentNode.removeChild(this)
    };
    w.HTMLElement.prototype.contains = function(el) {
        while (el != null && el != this) {
            el = el.parentNode;
        }
        return (el!=null)
    };

    w.HTMLStyleElement.prototype.__defineGetter__('styleSheet', function() {
        return this.sheet;
    });
    w.CSSStyleSheet.prototype.__defineGetter__('rules', function() {
        return this.cssRules;
    });
    w.CSSStyleSheet.prototype.addRule = function(selector, style, index) {
        this.insertRule(selector + '{' + style + '}', index);
    };
    w.CSSStyleSheet.prototype.removeRule = function(index) {
        this.deleteRule(index);
    };
    w.CSSStyleDeclaration.prototype.__defineGetter__('styleFloat', function() {
        return this.cssFloat;
    });
    w.CSSStyleDeclaration.prototype.__defineSetter__('styleFloat', function(v) {
        this.cssFloat = v;
    });
    DocumentFragment.prototype.getElementById = function(id) {
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;
        
        for (c = 0; c < childNodes.length; c++) {
            node = childNodes[c];
            if (node.nodeType == 1) {
                nodeQueue.push(node);
            }
        }

        while (nodeQueue.length) {
            node = nodeQueue.dequeue();
            if (node.id == id) {
                return node;
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return null;
    };

    DocumentFragment.prototype.getElementsByTagName = function(tagName) {
        var elements = [];
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;

        for (c = 0; c < childNodes.length; c++) {
            node = childNodes[c];
            if (node.nodeType == 1) {
                nodeQueue.push(node);
            }
        }

        while (nodeQueue.length) {
            node = nodeQueue.dequeue();
            if (node.tagName == tagName) {
                elements.add(node);
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return elements;
    };

    DocumentFragment.prototype.createElement = function(tagName) {
        return document.createElement(tagName);
    };

    var selectNodes = function(doc, path, contextNode) {
        contextNode = contextNode ? contextNode : doc;
        var xpath = new XPathEvaluator();
        var result = xpath.evaluate(path, contextNode,
                                    doc.createNSResolver(doc.documentElement),
                                    XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        var nodeList = new Array(result.snapshotLength);
        for(var i = 0; i < result.snapshotLength; i++) {
            nodeList[i] = result.snapshotItem(i);
        }

        return nodeList;
    };

    var selectSingleNode = function(doc, path, contextNode) {
        path += '[1]';
        var nodes = selectNodes(doc, path, contextNode);
        if (nodes.length != 0) {
            for (var i = 0; i < nodes.length; i++) {
                if (nodes[i]) {
                    return nodes[i];
                }
            }
        }
        return null;
    };

    w.XMLDocument.prototype.selectNodes = function(path, contextNode) {
        return selectNodes(this, path, contextNode);
    };

    w.XMLDocument.prototype.selectSingleNode = function(path, contextNode) {
        return selectSingleNode(this, path, contextNode);
    };

    w.XMLDocument.prototype.transformNode = function(xsl) {
        var xslProcessor = new XSLTProcessor();
        xslProcessor.importStylesheet(xsl);

        var ownerDocument = document.implementation.createDocument("", "", null);
        var transformedDoc = xslProcessor.transformToDocument(this);
        
        return transformedDoc.xml;
    };

    Node.prototype.selectNodes = function(path) {
        var doc = this.ownerDocument;
        return doc.selectNodes(path, this);
    };

    Node.prototype.selectSingleNode = function(path) {
        var doc = this.ownerDocument;
        return doc.selectSingleNode(path, this);
    };

    Node.prototype.__defineGetter__('baseName', function() {
        return this.localName;
    });

    Node.prototype.__defineGetter__('text', function() {
        return this.textContent;
    });
    Node.prototype.__defineSetter__('text', function(value) {
        this.textContent = value;
    });

    Node.prototype.__defineGetter__('xml', function() {
        return (new XMLSerializer()).serializeToString(this);
    });
}

function __supportsCompatLayer(ua) {
    // Supported browsers:
    //  - Firefox 1.5+
    //  - WebKit 500+
    //  - Opera 9.5+
    return (ua.indexOf('Gecko') >= 0) || (ua.indexOf('AppleWebKit') >= 0) || (ua.indexOf('Opera') >= 0);
}

if (__supportsCompatLayer(window.navigator.userAgent)) {
    try {
        __loadCompatLayer(window);
    }
    catch (e) {
    }
}
//! Script# Core Runtime
//! Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
//! http://projects.nikhilk.net
//!

///////////////////////////////////////////////////////////////////////////////
// Globals

function isUndefined(o) {
    return (o === undefined);
}

function isNull(o) {
    return (o === null);
}

function isNullOrUndefined(o) {
    return (o === null) || (o === undefined);
}

window.__scriptsharp = '0.5.1.0';

function $(id) {
    return document.getElementById(id);
}

document.getElementsBySelector = function getElementsBySelector(cssSelector, root) {
    var all = root ? root.getElementsByTagName('*') : document.getElementsByTagName('*');
    var matches = [];

    // Create a stylesheet we'll use to insert a CSS rule into to do the matching.
    // This is created just once.
    var styleSheet = document.getElementsBySelector.styleSheet;
    if (!styleSheet) {
        var styleSheetNode = document.createElement('style');
        styleSheetNode.type = 'text/css';

        document.getElementsByTagName('head')[0].appendChild(styleSheetNode);
        styleSheet = styleSheetNode.styleSheet || styleSheetNode.sheet;
        
        document.getElementsBySelector.styleSheet = styleSheet;
    }

    if (window.navigator.userAgent.indexOf('MSIE') >= 0) {
        // Add the rule that will be used to match elements
        styleSheet.addRule(cssSelector, 'ssCssMatch:true', 0);

        for (var i = all.length - 1; i >= 0; i--) {
            var element = all[i];

            // Find elements that contain the special css attribute, i.e.
            // the elements that match the specified selector.
            if (element.currentStyle.ssCssMatch) {
                matches[matches.length] = element;
            }
        }

        styleSheet.removeRule(0);
    }
    else {
        var matchValue = document.getElementsBySelector.matchValue;
        if (!matchValue) {
            matchValue = (window.navigator.userAgent.indexOf('Opera') >= 0) ? '"ssCssMatch"' : 'ssCssMatch 1';
            document.getElementsBySelector.matchValue = matchValue;
        }

        // Add the rule that will be used to match elements
        styleSheet.insertRule(cssSelector + ' { counter-increment: ssCssMatch }', 0);

        var docView = document.defaultView;
        for (var i = all.length - 1; i >= 0; i--) {
            var element = all[i];

            // Find elements that contain the special css attribute, i.e.
            // the elements that match the specified selector.
            if (docView.getComputedStyle(element, null).counterIncrement === matchValue) {
                matches[matches.length] = element;
            }
        }

        styleSheet.deleteRule(0);
    }

    if (matches.length > 1) {
        matches.reverse();
    }
    return matches;
}

///////////////////////////////////////////////////////////////////////////////
// Object Extensions

Object.__typeName = 'Object';
Object.__baseType = null;

Object.parse = function Object$parse(s) {
    return eval(s);
}

Object.getKeyCount = function Object$getKeyCount(d) {
    var count = 0;
    for (var n in d) {
        count++;
    }
    return count;
}

Object.clearKeys = function Object$clearKeys(d) {
    for (var n in d) {
        delete d[n];
    }
}

Object.keyExists = function Object$keyExists(d, key) {
    return d[key] !== undefined;
}

///////////////////////////////////////////////////////////////////////////////
// Function Extensions

Function.parse = function Function$parse(s) {
    if (!Function._parseCache) {
        Function._parseCache = { };
    }

    var fn = Function._parseCache[s];
    if (!fn) {
        try {
            eval('fn = ' + s);
            if (typeof(fn) != 'function') {
                fn = null;
            }
            else {
                Function._parseCache[s] = fn;
            }
        }
        catch (ex) {
        }
    }
    return fn;
}

Function.prototype.invoke = function Function$invoke() {
    this.apply(null, arguments);
}

///////////////////////////////////////////////////////////////////////////////
// Boolean Extensions

Boolean.__typeName = 'Boolean';

Boolean.parse = function Boolean$parse(s) {
    return (s.toLowerCase() == 'true');
}

///////////////////////////////////////////////////////////////////////////////
// Number Extensions

Number.__typeName = 'Number';

Number.parse = function Number$parse(s) {
    if (!s || !s.length) {
        return 0;
    }
    if ((s.indexOf('.') >= 0) || (s.indexOf('e') >= 0) ||
        s.endsWith('f') || s.endsWith('F')) {
        return parseFloat(s);
    }
    return parseInt(s, 10);
}

Number.prototype.format = function Number$format(format, useLocale) {
    if (isNullOrUndefined(format) ||
        (format.length == 0) || (format == 'i')) {
        if (useLocale) {
            return this.toLocaleString();
        }
        else {
            return this.toString();
        }
    }

    return this._netFormat(format, useLocale);
}

Number._commaFormat = function Number$_commaFormat(number, groups, decimal, comma) {
    var decimalPart = null;
    var decimalIndex = number.indexOf(decimal);
    if (decimalIndex > 0) {
        decimalPart = number.substr(decimalIndex);
        number = number.substr(0, decimalIndex);
    }

    var negative = number.startsWith('-');
    if (negative) {
        number = number.substr(1);
    }

    var groupIndex = 0;
    var groupSize = groups[groupIndex];
    if (number.length < groupSize) {
        return decimalPart ? number + decimalPart : number;
    }

    var index = number.length;
    var s = '';
    var done = false;
    while (!done) {
        var length = groupSize;
        var startIndex = index - length;
        if (startIndex < 0) {
            groupSize += startIndex;
            length += startIndex;
            startIndex = 0;
            done = true;
        }
        if (!length) {
            break;
        }
        
        var part = number.substr(startIndex, length);
        if (s.length) {
            s = part + comma + s;
        }
        else {
            s = part;
        }
        index -= length;

        if (groupIndex < groups.length - 1) {
            groupIndex++;
            groupSize = groups[groupIndex];
        }
    }

    if (negative) {
        s = '-' + s;
    }    
    return decimalPart ? s + decimalPart : s;
}

Number.prototype._netFormat = function Number$_netFormat(format, useLocale) {
    var nf = useLocale ? CultureInfo.Current.numberFormat : CultureInfo.Neutral.numberFormat;

    var s = '';    
    var precision = -1;
    
    if (format.length > 1) {
        precision = parseInt(format.substr(1));
    }

    var fs = format.charAt(0);
    switch (fs) {
        case 'd': case 'D':
            s = parseInt(Math.abs(this)).toString();
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            if (this < 0) {
                s = '-' + s;
            }
            break;
        case 'x': case 'X':
            s = parseInt(Math.abs(this)).toString(16);
            if (fs == 'X') {
                s = s.toUpperCase();
            }
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            break;
        case 'e': case 'E':
            if (precision == -1) {
                s = this.toExponential();
            }
            else {
                s = this.toExponential(precision);
            }
            if (fs == 'E') {
                s = s.toUpperCase();
            }
            break;
        case 'f': case 'F':
        case 'n': case 'N':
            if (precision == -1) {
                precision = nf.numberDecimalDigits;
            }
            s = this.toFixed(precision).toString();
            if (precision && (nf.numberDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.numberDecimalSeparator + s.substr(index + 1);
            }
            if ((fs == 'n') || (fs == 'N')) {
                s = Number._commaFormat(s, nf.numberGroupSizes, nf.numberDecimalSeparator, nf.numberGroupSeparator);
            }
            break;
        case 'c': case 'C':
            if (precision == -1) {
                precision = nf.currencyDecimalDigits;
            }
            s = Math.abs(this).toFixed(precision).toString();
            if (precision && (nf.currencyDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.currencyDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.currencyGroupSizes, nf.currencyDecimalSeparator, nf.currencyGroupSeparator);
            if (this < 0) {
                s = String.format(nf.currencyNegativePattern, s);
            }
            else {
                s = String.format(nf.currencyPositivePattern, s);
            }
            break;
        case 'p': case 'P':
            if (precision == -1) {
                precision = nf.percentDecimalDigits;
            }
            s = (Math.abs(this) * 100.0).toFixed(precision).toString();
            if (precision && (nf.percentDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.percentDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.percentGroupSizes, nf.percentDecimalSeparator, nf.percentGroupSeparator);
            if (this < 0) {
                s = String.format(nf.percentNegativePattern, s);
            }
            else {
                s = String.format(nf.percentPositivePattern, s);
            }
            break;
    }

    return s;
}

///////////////////////////////////////////////////////////////////////////////
// Math Extensions

Math.truncate = function Math$truncate(n) {
    return (n >= 0) ? Math.floor(n) : Math.ceil(n);
}

///////////////////////////////////////////////////////////////////////////////
// String Extensions

String.__typeName = 'String';
String.Empty = '';

String.compare = function String$compare(s1, s2, ignoreCase) {
    if (ignoreCase) {
        if (s1) {
            s1 = s1.toUpperCase();
        }
        if (s2) {
            s2 = s2.toUpperCase();
        }
    }
    s1 = s1 || '';
    s2 = s2 || '';

    if (s1 == s2) {
        return 0;
    }
    if (s1 < s2) {
        return -1;
    }
    return 1;
}

String.prototype.compareTo = function String$compareTo(s, ignoreCase) {
    return String.compare(this, s, ignoreCase);
}

String.prototype.endsWith = function String$endsWith(suffix) {
    if (!suffix.length) {
        return true;
    }
    if (suffix.length > this.length) {
        return false;
    }
    return (this.substr(this.length - suffix.length) == suffix);
}

String.equals = function String$equals1(s1, s2, ignoreCase) {
    return String.compare(s1, s2, ignoreCase) == 0;
}

String._format = function String$_format(format, values, useLocale) {
    if (!String._formatRE) {
        String._formatRE = /(\{[^\}^\{]+\})/g;
    }

    return format.replace(String._formatRE,
                          function(str, m) {
                              var index = parseInt(m.substr(1));
                              var value = values[index + 1];
                              if (isNullOrUndefined(value)) {
                                  return '';
                              }
                              if (value.format) {
                                  var formatSpec = null;
                                  var formatIndex = m.indexOf(':');
                                  if (formatIndex > 0) {
                                      formatSpec = m.substring(formatIndex + 1, m.length - 1);
                                  }
                                  return value.format.call(value, formatSpec, useLocale);
                              }
                              else {
                                  if (useLocale) {
                                      return value.toLocaleString();
                                  }
                                  return value.toString();
                              }
                          });
}

String.format = function String$format(format) {
    return String._format(format, arguments, /* useLocale */ false);
}

String.fromChar = function String$fromChar(ch, count) {
    var s = ch;
    for (var i = 1; i < count; i++) {
        s += ch;
    }
    return s;
}

String.prototype.htmlDecode = function String$htmlDecode() {
    if (!String._htmlDecRE) {
        String._htmlDecMap = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"' };
        String._htmlDecRE = /(&amp;|&lt;|&gt;|&quot;)/gi;
    }

    var s = this;
    s = s.replace(String._htmlDecRE,
                  function String$htmlDecode$replace(str, m) {
                      return String._htmlDecMap[m];
                  });
    return s;
}

String.prototype.htmlEncode = function String$htmlEncode() {
    if (!String._htmlEncRE) {
        String._htmlEncMap = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
        String._htmlEncRE = /([&<>"])/g;
    }

    var s = this;
    if (String._htmlEncRE.test(s)) {
        s = s.replace(String._htmlEncRE,
                      function String$htmlEncode$replace(str, m) {
                          return String._htmlEncMap[m];
                      });
    }
    return s;
}

String.prototype.indexOfAny = function String$indexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || 0;
    count = count || length;

    var endIndex = startIndex + count - 1;
    if (endIndex >= length) {
        endIndex = length - 1;
    }

    for (var i = startIndex; i <= endIndex; i++) {
        if (chars.indexOf(this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.prototype.insert = function String$insert(index, value) {
    if (!value) {
        return this;
    }
    if (!index) {
        return value + this;
    }
    var s1 = this.substr(0, index);
    var s2 = this.substr(index);
    return s1 + value + s2;
}

String.isNullOrEmpty = function String$isNullOrEmpty(s) {
    return !s || !s.length;
}

String.prototype.lastIndexOfAny = function String$lastIndexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || length - 1;
    count = count || length;

    var endIndex = startIndex - count + 1;
    if (endIndex < 0) {
        endIndex = 0;
    }

    for (var i = startIndex; i >= endIndex; i--) {
        if (chars.indexOf(this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.localeFormat = function String$localeFormat(format) {
    return String._format(format, arguments, /* useLocale */ true);
}

String.prototype.padLeft = function String$padLeft(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return String.fromChar(ch, totalWidth - this.length) + this;
    }
    return this;
}

String.prototype.padRight = function String$padRight(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return this + String.fromChar(ch, totalWidth - this.length);
    }
    return this;
}

String.prototype.quote = function String$quote() {
    if (!String._quoteMap) {
        String._quoteMap = { '\\' : '\\\\',
                             '\'' : '\\\'', '"' : '\\"',
                             '\r' : '\\r', '\n' : '\\n', '\t' : '\\t', '\f' : '\\f',
                             '\b' : '\\b' };
    }
    if (!String._quoteRE || !RegExp._cacheable) {
        String._quoteRE = new RegExp("([\'\"\\\\\x00-\x1F\x7F-\uFFFF])", "g");
    }

    var s = this;
    if (String._quoteSkipTest || String._quoteRE.test(s)) {
        s = this.replace(String._quoteRE,
                         function String$quote$replace(str, m) {
                             var c = String._quoteMap[m];
                             if (c) {
                                 return c;
                             }
                             c = m.charCodeAt(0);
                             return '\\u' + c.toString(16).toUpperCase().padLeft(4, '0');
                         });
    }
    return '"' + s + '"';
}

String.prototype.remove = function String$remove(index, count) {
    if (!count || ((index + count) > this.length)) {
        return this.substr(0, index);
    }
    return this.substr(0, index) + this.substr(index + count);
}

String.prototype._replace = String.prototype.replace;
String.prototype.replace = function String$replace(oldValue, newValue) {
    if (oldValue.constructor == String) {
        newValue = newValue || '';
        return this.split(oldValue).join(newValue);
    }
    return String.prototype._replace.call(this, oldValue, newValue);
}

String.prototype.startsWith = function String$startsWith(prefix) {
    if (!prefix.length) {
        return true;
    }
    if (prefix.length > this.length) {
        return false;
    }
    return (this.substr(0, prefix.length) == prefix);
}

String.prototype.trim = function String$trim() {
    return this.trimEnd().trimStart();
}

String.prototype.trimEnd = function String$trimEnd() {
    return this.replace(/\s*$/, '');
}

String.prototype.trimStart = function String$trimStart() {
    return this.replace(/^\s*/, '');
}

String.prototype.unquote = function String$unquote() {
    return eval('(' + this + ')');
}

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__typeName = 'Array';

Array.prototype.add = function Array$add(item) {
    this[this.length] = item;
}

Array.prototype.addRange = function Array$addRange(items) {
    if (!items) {
        return;
    }
    var length = items.length;
    for (var index = 0; index < length; index++) {
        this[this.length] = items[index];
    }
}

Array.prototype.aggregate = function Array$aggregate(seed, callback) {
    var length = this.length;
    for (var index = 0; index < length; index++) {
        seed = callback(seed, this[index], index, this);
    }
    return seed;
}

Array.prototype.clear = function Array$clear() {
    if (this.length > 0) {
        this.splice(0, this.length);
    }
}

Array.prototype.clone = function Array$clone() {
    var length = this.length;
    var array = new Array(length);
    for (var index = 0; index < length; index++) {
        array[index] = this[index];
    }
    return array;
}

Array.prototype.contains = function Array$contains(item) {
    var index = this.indexOf(item);
    return (index >= 0);
}

Array.prototype.dequeue = function Array$dequeue() {
    return this.shift();
}

Array.prototype.enqueue = function Array$enqueue(item) {
    // We record that this array instance is a queue, so we
    // can implement the right behavior in the peek method.
    this._queue = true;
    this.push(item);
}

Array.prototype.peek = function Array$peek() {
    if (this.length) {
        var index = this._queue ? 0 : this.length - 1;
        return this[index];
    }
    return null;
}

if (!Array.prototype.every) {
    Array.prototype.every = function Array$every(callback) {
        for (var i = this.length - 1; i >= 0; i--) {
            if (!callback(this[i], i, this)) {
                return false;
            }
        }
        return true;
    }
}

Array.prototype.extract = function Array$extract(index, count) {
    if (!count) {
        return this.slice(index);
    }
    return this.slice(index, index + count);
}

if (!Array.prototype.filter) {
    Array.prototype.filter = function Array$filter(callback) {
        var filtered = [];
        for (var i = 0; i < this.length; i++) {
            if (callback(this[i], i, this)) {
                filtered.add(this[i]);
            }
        }
        return filtered;
    }
}

if (!Array.prototype.forEach) {
    Array.prototype.forEach = function Array$forEach(callback) {
        for (var i = 0; i < this.length; i++) {
            callback(this[i], i, this);
        }
    }
}

Array.prototype.groupBy = function Array$groupBy(callback) {
    var length = this.length;
    var groups = [];
    var keys = { };
    for (var index = 0; index < length; index++) {
        var key = callback(this[index], index);
        if (String.isNullOrEmpty(key)) {
            continue;
        }
        var items = keys[key];
        if (!items) {
            items = [];
            items.key = key;

            keys[key] = items;
            groups.add(items);
        }
        items.add(this[index]);
    }
    return groups;
}

Array.prototype.index = function Array$index(callback) {
    var length = this.length;
    var items = { };
    for (var index = 0; index < length; index++) {
        var key = callback(this[index], index);
        if (String.isNullOrEmpty(key)) {
            continue;
        }
        items[key] = this[index];
    }
    return items;
}

Array.prototype.indexOf = function Array$indexOf(item) {
    var length = this.length;
    if (length) {
        for (var index = 0; index < length; index++) {
            if (this[index] === item) {
                return index;
            }
        }
    }
    return -1;
}

Array.prototype.insert = function Array$insert(index, item) {
    this.splice(index, 0, item);
}

Array.prototype.insertRange = function Array$insertRange(index, items) {
    this.splice(index, 0, items);
}

if (!Array.prototype.map) {
    Array.prototype.map = function Array$map(callback) {
        var mapped = new Array(this.length);
        for (var i = this.length - 1; i >= 0; i--) {
            mapped[i] = callback(this[i], i, this);
        }
        return mapped;
    }
}

Array.parse = function Array$parse(s) {
    return eval('(' + s + ')');
}

Array.prototype.remove = function Array$remove(item) {
    var index = this.indexOf(item);
    if (index >= 0) {
        this.splice(index, 1);
        return true;
    }
    return false;
}

Array.prototype.removeAt = function Array$removeAt(index) {
    return this.splice(index, 1)[0];
}

Array.prototype.removeRange = function Array$removeRange(index, count) {
    return this.splice(index, count);
}

if (!Array.prototype.some) {
    Array.prototype.some = function Array$some(callback) {
        for (var i = this.length - 1; i >= 0; i--) {
            if (callback(this[i], i, this)) {
                return true;
            }
        }
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////
// RegExp Extensions

RegExp.__typeName = 'RegExp';

RegExp.parse = function RegExp$parse(s) {
    if (s.startsWith('/')) {
        var endSlashIndex = s.lastIndexOf('/');
        if (endSlashIndex > 1) {
            var expression = s.substring(1, endSlashIndex);
            var flags = s.substr(endSlashIndex + 1);
            return new RegExp(expression, flags);
        }
    }

    return null;    
}

///////////////////////////////////////////////////////////////////////////////
// Date Extensions

Date.__typeName = 'Date';

Date.get_now = function Date$get_now() {
    return new Date();
}

Date.get_today = function Date$get_today() {
    var d = new Date();
    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
}

Date.prototype.format = function Date$format(format, useLocale) {
    if (isNullOrUndefined(format) ||
        (format.length == 0) || (format == 'i')) {
        if (useLocale) {
            return this.toLocaleString();
        }
        else {
            return this.toString();
        }
    }
    if (format == 'id') {
        if (useLocale) {
            return this.toLocaleDateString();
        }
        else {
            return this.toDateString();
        }
    }
    if (format == 'it') {
        if (useLocale) {
            return this.toLocaleTimeString();
        }
        else {
            return this.toTimeString();
        }
    }

    return this._netFormat(format, useLocale);
}

Date.prototype._netFormat = function Date$_netFormat(format, useLocale) {
    var dtf = useLocale ? CultureInfo.Current.dateFormat : CultureInfo.Neutral.dateFormat;
    var useUTC = false;

    if (format.length == 1) {
        switch (format) {
            case 'f': format = dtf.longDatePattern + ' ' + dtf.shortTimePattern;
            case 'F': format = dtf.dateTimePattern; break;

            case 'd': format = dtf.shortDatePattern; break;
            case 'D': format = dtf.longDatePattern; break;

            case 't': format = dtf.shortTimePattern; break;
            case 'T': format = dtf.longTimePattern; break;

            case 'g': format = dtf.shortDatePattern + ' ' + dtf.shortTimePattern; break;
            case 'G': format = dtf.shortDatePattern + ' ' + dtf.longTimePattern; break;

            case 'R': case 'r': format = dtf.gmtDateTimePattern; useUTC = true; break;
            case 'u': format = dtf.universalDateTimePattern; useUTC = true; break;
            case 'U': format = dtf.dateTimePattern; useUTC = true; break;

            case 's': format = dtf.sortableDateTimePattern; break;
        }
    }

    if (format.charAt(0) == '%') {
        format = format.substr(1);
    }

    if (!Date._formatRE) {
        Date._formatRE = /dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z/g;
    }

    var re = Date._formatRE;    
    var sb = new StringBuilder();
    var dt = this;
    if (useUTC) {
        dt = new Date(Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(),
                               dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds()));
    }

    re.lastIndex = 0;
    while (true) {
        var index = re.lastIndex;
        var match = re.exec(format);

        sb.append(format.slice(index, match ? match.index : format.length));
        if (!match) {
            break;
        }

        var fs = match[0];
        var part = fs;
        switch (fs) {
            case 'dddd':
                part = dtf.dayNames[dt.getDay()];
                break;
            case 'ddd':
                part = dtf.shortDayNames[dt.getDay()];
                break;
            case 'dd':
                part = dt.getDate().toString().padLeft(2, '0');
                break;
            case 'd':
                part = dt.getDate();
                break;
            case 'MMMM':
                part = dtf.monthNames[dt.getMonth()];
                break;
            case 'MMM':
                part = dtf.shortMonthNames[dt.getMonth()];
                break;
            case 'MM':
                part = (dt.getMonth() + 1).toString().padLeft(2, '0');
                break;
            case 'M':
                part = (dt.getMonth() + 1);
                break;
            case 'yyyy':
                part = dt.getFullYear();
                break;
            case 'yy':
                part = (dt.getFullYear() % 100).toString().padLeft(2, '0');
                break;
            case 'y':
                part = (dt.getFullYear() % 100);
                break;
            case 'h': case 'hh':
                part = dt.getHours() % 12;
                if (!part) {
                    part = '12';
                }
                else if (fs == 'hh') {
                    part = part.toString().padLeft(2, '0');
                }
                break;
            case 'HH':
                part = dt.getHours().toString().padLeft(2, '0');
                break;
            case 'H':
                part = dt.getHours();
                break;
            case 'mm':
                part = dt.getMinutes().toString().padLeft(2, '0');
                break;
            case 'm':
                part = dt.getMinutes();
                break;
            case 'ss':
                part = dt.getSeconds().toString().padLeft(2, '0');
                break;
            case 's':
                part = dt.getSeconds();
                break;
            case 't': case 'tt':
                part = (dt.getHours() < 12) ? dtf.amDesignator : dtf.pmDesignator;
                if (fs == 't') {
                    part = part.charAt(0);
                }
                break;
            case 'fff':
                part = dt.getMilliseconds().toString().padLeft(3, '0');
                break;
            case 'ff':
                part = dt.getMilliseconds().toString().padLeft(3).substr(0, 2);
                break;
            case 'f':
                part = dt.getMilliseconds().toString().padLeft(3).charAt(0);
                break;
            case 'z':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part));
                break;
            case 'zz': case 'zzz':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part)).toString().padLeft(2, '0');
                if (fs == 'zzz') {
                    part += dtf.timeSeparator + Math.abs(dt.getTimezoneOffset() % 60).toString().padLeft(2, '0');
                }
                break;
        }
        sb.append(part);
    }

    return sb.toString();
}

Date._parse = Date.parse;
Date.parse = function Date$parse(s) {
    // Date.parse by default returns the number of milliseconds
    // and not an actual Date instance
    return new Date(Date._parse(s));
}

///////////////////////////////////////////////////////////////////////////////
// Error Extensions

Error.__typeName = 'Error';

Error.create = function Error$create(message, userData, innerException) {
    var e = new Error(message);
    if (userData) {
        e.userData = userData;
    }
    if (innerException) {
        e.innerException = innerException;
    }
    return e;
}

///////////////////////////////////////////////////////////////////////////////
// Debug Extensions

if (!Debug._fail) {
    Debug._fail = function Debug$_fail(message) {
        Debug.writeln(message);
        eval('debugger;');
    }
}

Debug.assert = function Debug$assert(condition, message) {
    if (!condition) {
        message = 'Assert failed: ' + message;
        if (confirm(message + '\r\n\r\nBreak into debugger?')) {
            Debug._fail(message);
        }
    }
}

Debug._dumpCore = function Debug$_dumpCore(sb, object, name, indentation, dumpedObjects) {
    if (object === null) {
        sb.appendLine(indentation + name + ': null');
        return;
    }
    switch (typeof(object)) {
        case 'undefined':
            sb.appendLine(indentation + name + ': undefined');
            break;
        case 'number':
        case 'string':
        case 'boolean':
            sb.appendLine(indentation + name + ': ' + object);
            break;
        default:
            if (Date.isInstance(object) || RegExp.isInstance(object)) {
                sb.appendLine(indentation + name + ': ' + object);
                break;
            }

            if (dumpedObjects.contains(object)) {
                sb.appendLine(indentation + name + ': ...');
                break;
            }
            dumpedObjects.add(object);

            var type = Type.getInstanceType(object);
            var typeName = type.get_fullName();
            var recursiveIndentation = indentation + '  ';

            if (IArray.isInstance(object)) {
                sb.appendLine(indentation + name + ': {' + typeName + '}');
                var length = object.getLength();
                for (var i = 0; i < length; i++) {
                    Debug._dumpCore(sb, object.getItem(i), '[' + i + ']', recursiveIndentation, dumpedObjects);
                }
            }
            else {
                if (object.tagName) {
                    sb.appendLine(indentation + name + ': <' + object.tagName + '>');
                    var attributes = object.attributes;
                    for (var i = 0; i < attributes.length; i++) {
                        var attrValue = attributes[i].nodeValue;
                        if (attrValue) {
                            Debug._dumpCore(sb, attrValue, attributes[i].nodeName, recursiveIndentation, dumpedObjects);
                        }
                    }
                }
                else {
                    sb.appendLine(indentation + name + ': {' + typeName + '}');
                    for (var field in object) {
                        var v = object[field];
                        if (!Function.isInstance(v)) {
                            Debug._dumpCore(sb, v, field, recursiveIndentation, dumpedObjects);
                        }
                    }
                }
            }

            dumpedObjects.remove(object);
            break;
    }
}

Debug.dump = function Debug$dump(object, name) {
    if ((!name || !name.length) && (object !== null)) {
        name = Type.getInstanceType(object).get_fullName();
    }
    if (!name || !name.length) {
        return;
    }
    var sb = new StringBuilder();
    Debug._dumpCore(sb, object, name, '', []);
    Debug.writeLine(sb.toString());
}

Debug.fail = function Debug$fail(message) {
    Debug._fail(message);
}

Debug.inspect = function Debug$inspect(object, name) {
    var dumped = false;
    if (window.debugService) {
        dumped = window.debugService.inspect(name, object);
    }
    if (!dumped) {
        Debug.dump(object, name);
    }
}

Debug.writeLine = function Debug$writeLine(message) {
    if (window.debugService) {
        window.debugService.trace(message);
        return;
    }
    Debug.writeln(message);

    var traceTextBox = $('_traceTextBox');
    if (traceTextBox) {
        traceTextBox.value = traceTextBox.value + '\r\n' + message;
    }
}

Debug.__typeName = 'Debug';

///////////////////////////////////////////////////////////////////////////////
// Type System Implementation

var Type = Function;
Type.__typeName = 'Type';

var __Namespace = function(name) {
    this.__typeName = name;
}
__Namespace.prototype = {
    __namespace: true,
    getName: function() {
        return this.__typeName;
    }
}

Type.createNamespace = function Type$createNamespace(name) {
    if (!window.__namespaces) {
        window.__namespaces = {};
    }
    if (!window.__rootNamespaces) {
        window.__rootNamespaces = [];
    }

    if (window.__namespaces[name]) {
        return;
    }

    var ns = window;
    var nameParts = name.split('.');

    for (var i = 0; i < nameParts.length; i++) {
        var part = nameParts[i];
        var nso = ns[part];
        if (!nso) {
            ns[part] = nso = new __Namespace(nameParts.slice(0, i + 1).join('.'));
            if (i == 0) {
                window.__rootNamespaces.add(nso);
            }
        }
        ns = nso;
    }

    window.__namespaces[name] = ns;
}

Type.prototype.createClass = function Type$createClass(name, baseType, interfaceType) {
    this.prototype.constructor = this;
    this.__typeName = name;
    this.__class = true;
    this.__baseType = baseType || Object;
    if (baseType) {
        this.__basePrototypePending = true;
    }

    if (interfaceType) {
        this.__interfaces = [];
        for (var i = 2; i < arguments.length; i++) {
            interfaceType = arguments[i];
            this.__interfaces.add(interfaceType);
        }
    }
}

Type.prototype.createInterface = function Type$createInterface(name) {
    this.__typeName = name;
    this.__interface = true;
}

Type.prototype.createEnum = function Type$createEnum(name, flags) {
    for (var field in this.prototype) {
         this[field] = this.prototype[field];
    }

    this.__typeName = name;
    this.__enum = true;
    if (flags) {
        this.__flags = true;
    }
}

Type.prototype.setupBase = function Type$setupBase() {
    if (this.__basePrototypePending) {
        var baseType = this.__baseType;
        if (baseType.__basePrototypePending) {
            baseType.setupBase();
        }

        for (var memberName in baseType.prototype) {
            var memberValue = baseType.prototype[memberName];
            if (!this.prototype[memberName]) {
                this.prototype[memberName] = memberValue;
            }
        }

        delete this.__basePrototypePending;
    }
}

if (!Type.prototype.resolveInheritance) {
    // This function is not used by Script#; Visual Studio relies on it
    // for JavaScript IntelliSense support of derived types.
    Type.prototype.resolveInheritance = Type.prototype.setupBase;
}

Type.prototype.constructBase = function Type$constructBase(instance, args) {
    if (this.__basePrototypePending) {
        this.setupBase();
    }

    if (!args) {
        this.__baseType.apply(instance);
    }
    else {
        this.__baseType.apply(instance, args);
    }
}

Type.prototype.callBase = function Type$callBase(instance, name, args) {
    var baseMethod = this.__baseType.prototype[name];
    if (!args) {
        return baseMethod.apply(instance);
    }
    else {
        return baseMethod.apply(instance, args);
    }
}

Type.prototype.get_baseType = function Type$get_baseType() {
    return this.__baseType || null;
}

Type.prototype.get_fullName = function Type$get_fullName() {
    return this.__typeName;
}

Type.prototype.get_name = function Type$get_name() {
    var fullName = this.__typeName;
    var nsIndex = fullName.lastIndexOf('.');
    if (nsIndex > 0) {
        return fullName.substr(nsIndex + 1);
    }
    return fullName;
}

Type.prototype.isInstance = function Type$isInstance(instance) {
    if (isNullOrUndefined(instance)) {
        return false;
    }
    if ((this == Object) || (instance instanceof this)) {
        return true;
    }

    var type = Type.getInstanceType(instance);
    return this.isAssignableFrom(type);
}

Type.prototype.isAssignableFrom = function Type$isAssignableFrom(type) {
    if ((this == Object) || (this == type)) {
        return true;
    }
    if (this.__class) {
        var baseType = type.__baseType;
        while (baseType) {
            if (this == baseType) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    else if (this.__interface) {
        var interfaces = type.__interfaces;
        if (interfaces && interfaces.contains(this)) {
            return true;
        }

        var baseType = type.__baseType;
        while (baseType) {
            interfaces = baseType.__interfaces;
            if (interfaces && interfaces.contains(this)) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    return false;
}

Type.isClass = function Type$isClass(type) {
    return (type.__class == true);
}

Type.isEnum = function Type$isEnum(type) {
    return (type.__enum == true);
}

Type.isFlagsEnum = function Type$isFlagsEnum(type) {
    return ((type.__enum == true) && (type.__flags == true));
}

Type.isInterface = function Type$isInterface(type) {
    return (type.__interface == true);
}

Type.canCast = function Type$canCast(instance, type) {
    return type.isInstance(instance);
}

Type.safeCast = function Type$safeCast(instance, type) {
    if (type.isInstance(instance)) {
        return instance;
    }
    return null;
}

Type.getInstanceType = function Type$getInstanceType(instance) {
    var ctor = null;

    // NOTE: We have to catch exceptions because the constructor
    //       cannot be looked up on native COM objects
    try {
        ctor = instance.constructor;
    }
    catch (ex) {
    }
    if (!ctor || !ctor.__typeName) {
        ctor = Object;
    }
    return ctor;
}

Type.getType = function Type$getType(typeName) {
    if (!typeName) {
        return null;
    }

    if (!Type.__typeCache) {
        Type.__typeCache = {};
    }

    var type = Type.__typeCache[typeName];
    if (!type) {
        type = eval(typeName);
        Type.__typeCache[typeName] = type;
    }
    return type;
}

Type.parse = function Type$parse(typeName) {
    return Type.getType(typeName);
}

///////////////////////////////////////////////////////////////////////////////
// Enum

var Enum = function() {
}
Enum.createClass('Enum');

Enum.parse = function Enum$parse(enumType, s) {
    var values = enumType.prototype;
    if (!enumType.__flags) {
        for (var f in values) {
            if (f === s) {
                return values[f];
            }
        }
    }
    else {
        var parts = s.split('|');
        var value = 0;
        var parsed = true;

        for (var i = parts.length - 1; i >= 0; i--) {
            var part = parts[i].trim();
            var found = false;

            for (var f in values) {
                if (f === part) {
                    value |= values[f];
                    found = true;
                    break;
                }
            }
            if (!found) {
                parsed = false;
                break;
            }
        }

        if (parsed) {
            return value;
        }
    }
    throw 'Invalid Enumeration Value';
}

Enum.toString = function Enum$toString(enumType, value) {
    var values = enumType.prototype;
    if (!enumType.__flags || (value === 0)) {
        for (var i in values) {
            if (values[i] === value) {
                return i;
            }
        }
        throw 'Invalid Enumeration Value';
    }
    else {
        var parts = [];
        for (var i in values) {
            if (values[i] & value) {
                if (parts.length) {
                    parts.add(' | ');
                }
                parts.add(i);
            }
        }
        if (!parts.length) {
            throw 'Invalid Enumeration Value';
        }
        return parts.join('');
    }
}

///////////////////////////////////////////////////////////////////////////////
// Delegate

var Delegate = function() {
}
Delegate.createClass('Delegate');

Delegate.Null = function() { }

Delegate._create = function Delegate$_create(targets) {
    var delegate = function() {
        if (targets.length == 2) {
            return targets[1].apply(targets[0], arguments);
        }
        else {
            for (var i = 0; i < targets.length; i += 2) {
                targets[i + 1].apply(targets[i], arguments);
            }
            return null;
        }
    };
    delegate.invoke = delegate;
    delegate._targets = targets;

    return delegate;
}

Delegate.create = function Delegate$create(object, method) {
    if (!object) {
        method.invoke = method;
        return method;
    }
    return Delegate._create([object, method]);
}

Delegate.combine = function Delegate$combine(delegate1, delegate2) {
    if (!delegate1) {
        if (!delegate2._targets) {
            return Delegate.create(null, delegate2);
        }
        return delegate2;
    }
    if (!delegate2) {
        if (!delegate1._targets) {
            return Delegate.create(null, delegate1);
        }
        return delegate1;
    }

    var targets1 = delegate1._targets ? delegate1._targets : [null, delegate1];
    var targets2 = delegate2._targets ? delegate2._targets : [null, delegate2];

    return Delegate._create(targets1.concat(targets2));
}

Delegate.remove = function Delegate$remove(delegate1, delegate2) {
    if (!delegate1 || (delegate1 === delegate2)) {
        return null;
    }
    if (!delegate2) {
        return delegate1;
    }

    var targets = delegate1._targets;
    var object = null;
    var method;
    if (delegate2._targets) {
        object = delegate2._targets[0];
        method = delegate2._targets[1];
    }
    else {
        method = delegate2;
    }

    for (var i = 0; i < targets.length; i += 2) {
        if ((targets[i] === object) && (targets[i + 1] === method)) {
            if (targets.length == 2) {
                return null;
            }
            targets.splice(i, 2);
            return Delegate._create(targets);
        }
    }

    return delegate1;
}


Delegate.createExport = function Delegate$createExport(delegate, multiUse) {
    var name = '__' + (new Date()).valueOf();
    Delegate[name] = function() {
        if (!multiUse) {
            Delegate.deleteExport(name);
        }
        delegate.apply(null, arguments);
    };

    return name;
}

Delegate.deleteExport = function Delegate$deleteExport(name) {
    if (Delegate[name]) {
        delete Delegate[name];
    }
}

Delegate.clearExport = function Delegate$clearExport(name) {
    if (Delegate[name]) {
        Delegate[name] = Delegate.Null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// CultureInfo

var CultureInfo = function(name, numberFormat, dateFormat) {
    this.name = name;
    this.numberFormat = numberFormat;
    this.dateFormat = dateFormat;
}
CultureInfo.createClass('CultureInfo');

CultureInfo.Neutral = new CultureInfo('en-US',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',
        
        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: '.',
        percentGroupSeparator: ',',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol:'$',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: '.',
        currencyGroupSeparator: ',',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: '.',
        numberGroupSeparator: ','
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, MMMM dd, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, MMMM dd, yyyy',
        shortDatePattern: 'M/d/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
        shortDayNames: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
        minimizedDayNames: ['Su','Mo','Tu','We','Th','Fr','Sa'],

        monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December',''],
        shortMonthNames: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec','']
    });
CultureInfo.Current = CultureInfo.Neutral;

///////////////////////////////////////////////////////////////////////////////
// IArray

var IArray = function() { };
IArray.prototype = {
    getLength: null,
    getItem: null
}
IArray.createInterface('IArray');

///////////////////////////////////////////////////////////////////////////////
// IEnumerator

var IEnumerator = function() { };
IEnumerator.prototype = {
    get_current: null,
    moveNext: null,
    reset: null
}
IEnumerator.createInterface('IEnumerator');

///////////////////////////////////////////////////////////////////////////////
// IEnumerable

var IEnumerable = function() { };
IEnumerable.prototype = {
    getEnumerator: null
}
IEnumerable.createInterface('IEnumerable');

///////////////////////////////////////////////////////////////////////////////
// ArrayEnumerator

var ArrayEnumerator = function ArrayEnumerator$(array) {
    this._array = array;
    this._index = -1;
}
ArrayEnumerator.prototype = {
    get_current: function ArrayEnumerator$get_current() {
        return this._array[this._index];
    },
    moveNext: function ArrayEnumerator$moveNext() {
        this._index++;
        return (this._index < this._array.length);
    },
    reset: function ArrayEnumerator$reset() {
        this._index = -1;
    }
}

ArrayEnumerator.createClass('ArrayEnumerator', null, IEnumerator);

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__interfaces = [ IArray, IEnumerable ];

Array.prototype.getLength = function Array$getLength() {
    return this.length;
}
Array.prototype.getItem = function Array$getItem(index) {
    return this[index];
}

Array.prototype.getEnumerator = function Array$getEnumerator() {
    return new ArrayEnumerator(this);
}

///////////////////////////////////////////////////////////////////////////////
// IDisposable

var IDisposable = function() { };
IDisposable.prototype = {
    dispose: null
}
IDisposable.createInterface('IDisposable');

///////////////////////////////////////////////////////////////////////////////
// IServiceProvider

var IServiceProvider = function() { };
IServiceProvider.prototype = {
    getService: null
}
IServiceProvider.createInterface('IServiceProvider');

///////////////////////////////////////////////////////////////////////////////
// IServiceContainer

var IServiceContainer = function() { };
IServiceContainer.prototype = {
    registerService: null,
    unregisterService: null
}
IServiceContainer.createInterface('IServiceContainer');

///////////////////////////////////////////////////////////////////////////////
// StringBuilder

var StringBuilder = function StringBuilder$(s) {

    if ((s !== undefined) && (s !== null)) {
        this._parts = [ s ];
    }
    else {
        this._parts = [];
    }
}
StringBuilder.prototype = {
    get_isEmpty: function StringBuilder$get_isEmpty() {
        return (this._parts.length == 0);
    },

    append: function StringBuilder$append(s) {
        if ((s !== undefined) && (s !== null)) {
            this._parts.add(s);
        }
    },

    appendLine: function StringBuilder$appendLine(s) {
        this.append(s);
        this.append('\r\n');
    },

    clear: function StringBuilder$clear() {
        this._parts.clear();
    },

    toString: function StringBuilder$toString() {
        return this._parts.join('');
    }
};

StringBuilder.createClass('StringBuilder');

///////////////////////////////////////////////////////////////////////////////
// EventArgs

var EventArgs = function EventArgs$() {
}
EventArgs.createClass('EventArgs');

EventArgs.Empty = new EventArgs();

///////////////////////////////////////////////////////////////////////////////
// XMLHttpRequest

if (!window.XMLHttpRequest) {
    window.XMLHttpRequest = function() {
        var progIDs = [ 'Msxml2.XMLHTTP', 'Microsoft.XMLHTTP' ];

        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlHttp = new ActiveXObject(progIDs[i]);
                return xmlHttp;
            }
            catch (ex) {
            }
        }

        return null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// XMLDocumentParser

var XMLDocumentParser = function() {
}
XMLDocumentParser.createClass('XMLDocumentParser');

XMLDocumentParser.parse = function XMLDocumentParser$parse(markup) {
    if (!window.DOMParser) {
        var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
        
        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlDOM = new ActiveXObject(progIDs[i]);
                xmlDOM.async = false;
                xmlDOM.loadXML(markup);
                xmlDOM.setProperty('SelectionLanguage', 'XPath');
                
                return xmlDOM;
            }
            catch (ex) {
            }
        }
    }
    else {
        try {
            var domParser = new DOMParser();
            return domParser.parseFromString(markup, 'text/xml');
        }
        catch (ex) {
        }
    }

    return null;
}

////////////////////////////////////////////////////////////////////////////////
// ScriptLoader

var ScriptLoader = function ScriptLoader(scriptURLs) {
    Debug.assert((scriptURLs) && (scriptURLs.length));
    this._scriptURLs = scriptURLs;
    this._scriptLoadIndex = -1;
}
ScriptLoader.prototype = {
    _scriptURLs: null,
    _loadedHandler: null,
    _errorHandler: null,
    _isIE: false,
    _onLoadHandler: null,
    _onErrorHandler: null,
    _scriptLoadIndex: 0,
    _scriptElements: null,
    _loadedScripts: 0,
    _inError: false,
    _loaded: false,
    
    dispose: function ScriptLoader$dispose() {
        if (this._scriptElements) {
            for (var i = 0; i < this._scriptElements.length; i++) {
                var scriptElement = this._scriptElements[i];
                if (this._isIE) {
                    scriptElement.detachEvent('onreadystatechange', this._onLoadHandler);
                }
                else {
                    scriptElement.detachEvent('onload', this._onLoadHandler);
                    scriptElement.detachEvent('onerror', this._onErrorHandler);
                }
            }
            this._scriptElements = null;
        }
    },
    
    load: function ScriptLoader$load(loadInParallel, timeout, loadedHandler, errorHandler) {
        Debug.assert(loadedHandler);
        Debug.assert(errorHandler);
        this._loadedHandler = loadedHandler;
        this._errorHandler = errorHandler;
        this._isIE = (window.navigator.userAgent.indexOf('MSIE') >= 0);
        this._onLoadHandler = Delegate.create(this, this._onScriptLoad);
        if (!this._isIE) {
            this._onErrorHandler = Delegate.create(this, this._onScriptError);
        }
        this._scriptElements = [];
        if (loadInParallel) {
            for (var i = 0; i < this._scriptURLs.length; i++) {
                this._loadScript(this._scriptURLs[i]);
            }
        }
        else {
            this._scriptLoadIndex++;
            this._loadScript(this._scriptURLs[this._scriptLoadIndex]);
        }
        if (timeout) {
            window.setTimeout(Delegate.create(this, this._onScriptError), timeout);
        }
    },
    
    _loadScript: function ScriptLoader$_loadScript(scriptURL) {
        var scriptElement = document.createElement('SCRIPT');
        if (this._isIE) {
            scriptElement.attachEvent('onreadystatechange', this._onLoadHandler);
        }
        else {
            scriptElement.readyState = 'complete';
            scriptElement.attachEvent('onload', this._onLoadHandler);
            scriptElement.attachEvent('onerror', this._onErrorHandler);
        }
        scriptElement.type = 'text/javascript';
        scriptElement.src = scriptURL;
        this._scriptElements.add(scriptElement);
        document.getElementsByTagName('HEAD')[0].appendChild(scriptElement);
    },
    
    _onScriptError: function ScriptLoader$_onScriptError() {
        if ((!this._inError) && (!this._loaded)) {
            this._inError = true;
            this._errorHandler.invoke(this, EventArgs.Empty);
        }
    },
    
    _onScriptLoad: function ScriptLoader$_onScriptLoad() {
        if (this._inError) {
            return;
        }
        var scriptElement = window.event.srcElement;
        if (!scriptElement.readyState) {
            scriptElement = window.event.currentTarget;
        }

        if ((scriptElement.readyState != 'complete') && (scriptElement.readyState != 'loaded')) {
            return;
        }
        if (this._scriptLoadIndex != -1) {
            this._scriptLoadIndex++;
            if (this._scriptLoadIndex != this._scriptURLs.length) {
                this._loadScript(this._scriptURLs[this._scriptLoadIndex]);
                return;
            }
        }
        else {
            this._loadedScripts++;
            if (this._loadedScripts != this._scriptURLs.length) {
                return;
            }
        }
        this._loaded = true;
        this._loadedHandler.invoke(this, EventArgs.Empty);
    }
};

ScriptLoader.createClass('ScriptLoader', null, IDisposable);

////////////////////////////////////////////////////////////////////////////////
// ScriptHost

var ScriptHost = function ScriptHost() {
}
ScriptHost.get_isLoading = function ScriptHost$get_isLoading() {
    return ScriptHost._loading;
}
ScriptHost.add_load = function ScriptHost$add_load(value) {
    if (ScriptHost._loaded) {
        value.invoke(null, EventArgs.Empty);
    }
    else {
        ScriptHost._loadHandler = Delegate.combine(ScriptHost._loadHandler, value);
    }
}
ScriptHost.remove_load = function ScriptHost$remove_load(value) {
    ScriptHost._loadHandler = Delegate.remove(ScriptHost._loadHandler, value);
}
ScriptHost.add_unload = function ScriptHost$add_unload(value) {
    ScriptHost._unloadHandler = Delegate.combine(ScriptHost._unloadHandler, value);
}
ScriptHost.remove_unload = function ScriptHost$remove_unload(value) {
    ScriptHost._unloadHandler = Delegate.remove(ScriptHost._unloadHandler, value);
}
ScriptHost.close = function ScriptHost$close() {
    if (ScriptHost._fxScripts) {
        ScriptHost._fxScripts.dispose();
        ScriptHost._fxScripts = null;
    }
    if (ScriptHost._coreScripts) {
        ScriptHost._coreScripts.dispose();
        ScriptHost._coreScripts = null;
    }
    if (ScriptHost._unloadHandler) {
        ScriptHost._unloadHandler.invoke(null, EventArgs.Empty);
        ScriptHost._unloadHandler = null;
    }
    if (ScriptHost._windowLoadHandler) {
        window.detachEvent('onload', ScriptHost._windowLoadHandler);
        ScriptHost._windowLoadHandler = null;
    }
    if (ScriptHost._windowUnloadHandler) {
        window.detachEvent('onunload', ScriptHost._windowUnloadHandler);
        ScriptHost._windowUnloadHandler = null;
    }
}
ScriptHost.initialize = function ScriptHost$initialize(coreScriptURLs, fxScriptURLs) {
    if (!ScriptHost._initialized) {
        ScriptHost._initialized = true;
        if (ScriptHost._windowLoadHandler) {
            window.detachEvent('onload', ScriptHost._windowLoadHandler);
            ScriptHost._windowLoadHandler = null;
        }
        if ((coreScriptURLs) && (coreScriptURLs.length)) {
            ScriptHost._coreScripts = new ScriptLoader(coreScriptURLs);
        }
        if ((fxScriptURLs) && (fxScriptURLs.length)) {
            ScriptHost._fxScripts = new ScriptLoader(fxScriptURLs);
        }
        if ((!ScriptHost._coreScripts) && (!ScriptHost._fxScripts)) {
            ScriptHost._onLoaded();
        }
        else {
            ScriptHost._loadScripts();
        }
    }
}
ScriptHost._loadScripts = function ScriptHost$_loadScripts() {
    ScriptHost._loading = true;
    if (ScriptHost._coreScripts) {
        ScriptHost._coreScripts.load(false, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
        return;
    }
    else {
        ScriptHost._fxScripts.load(true, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
    }
}
ScriptHost._onLoaded = function ScriptHost$_onLoaded() {
    ScriptHost._loaded = true;
    if (window.main) {
        window.main();
    }
    if (ScriptHost._loadHandler) {
        ScriptHost._loadHandler.invoke(null, EventArgs.Empty);
        ScriptHost._loadHandler = null;
    }
}
ScriptHost._onScriptsCompleted = function ScriptHost$_onScriptsCompleted(sender, e) {
    if (sender == ScriptHost._coreScripts) {
        ScriptHost._coreScripts.dispose();
        ScriptHost._coreScripts = null;
        if (ScriptHost._fxScripts) {
            ScriptHost._fxScripts.load(true, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
            return;
        }
    }
    else {
        ScriptHost._fxScripts.dispose();
        ScriptHost._fxScripts = null;
    }
    ScriptHost._loading = false;
    ScriptHost._onLoaded();
}
ScriptHost._onScriptsError = function ScriptHost$_onScriptsError(sender, e) {
}
ScriptHost._onWindowLoad = function ScriptHost$_onWindowLoad() {
    ScriptHost.initialize(null, null);
}
ScriptHost._onWindowUnload = function ScriptHost$_onWindowUnload() {
    ScriptHost.close();
}

ScriptHost.createClass('ScriptHost');

ScriptHost._coreScripts = null;
ScriptHost._fxScripts = null;
ScriptHost._loadHandler = null;
ScriptHost._unloadHandler = null;
ScriptHost._initialized = false;
ScriptHost._loading = false;
ScriptHost._loaded = false;
ScriptHost._windowLoadHandler = Delegate.create(null, ScriptHost._onWindowLoad);
ScriptHost._windowUnloadHandler = Delegate.create(null, ScriptHost._onWindowUnload);
window.attachEvent('onload', ScriptHost._windowLoadHandler);
window.attachEvent('onunload', ScriptHost._windowUnloadHandler);
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CollectionChangedAction

ScriptFX.CollectionChangedAction = function() { };
ScriptFX.CollectionChangedAction.prototype = {
    add: 0, 
    remove: 1, 
    reset: 2
}
ScriptFX.CollectionChangedAction.createEnum('ScriptFX.CollectionChangedAction', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX._registeredEvent

ScriptFX.$create__registeredEvent = function ScriptFX__registeredEvent(eventType, sender, eventArgs, eventCookie) {
    var $o = { };
    $o.eventType = eventType;
    $o.sender = sender;
    $o.eventArgs = eventArgs;
    $o.eventCookie = eventCookie;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.IEventManager

ScriptFX.IEventManager = function() { };
ScriptFX.IEventManager.prototype = {
    raiseEvent : null,
    registerEvent : null,
    registerEventHandler : null,
    unregisterEvent : null,
    unregisterEventHandler : null
}
ScriptFX.IEventManager.createInterface('ScriptFX.IEventManager');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ISupportInitialize

ScriptFX.ISupportInitialize = function() { };
ScriptFX.ISupportInitialize.prototype = {
    beginInitialize : null,
    endInitialize : null
}
ScriptFX.ISupportInitialize.createInterface('ScriptFX.ISupportInitialize');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyDisposing

ScriptFX.INotifyDisposing = function() { };
ScriptFX.INotifyDisposing.prototype = {
    add_disposing : null,
    remove_disposing : null
}
ScriptFX.INotifyDisposing.createInterface('ScriptFX.INotifyDisposing');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HostName

ScriptFX.HostName = function() { };
ScriptFX.HostName.prototype = {
    other: 0, 
    IE: 1, 
    mozilla: 2, 
    safari: 3, 
    opera: 4
}
ScriptFX.HostName.createEnum('ScriptFX.HostName', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyCollectionChanged

ScriptFX.INotifyCollectionChanged = function() { };
ScriptFX.INotifyCollectionChanged.prototype = {
    add_collectionChanged : null,
    remove_collectionChanged : null
}
ScriptFX.INotifyCollectionChanged.createInterface('ScriptFX.INotifyCollectionChanged');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyPropertyChanged

ScriptFX.INotifyPropertyChanged = function() { };
ScriptFX.INotifyPropertyChanged.prototype = {
    add_propertyChanged : null,
    remove_propertyChanged : null
}
ScriptFX.INotifyPropertyChanged.createInterface('ScriptFX.INotifyPropertyChanged');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ITask

ScriptFX.ITask = function() { };
ScriptFX.ITask.prototype = {
    execute : null
}
ScriptFX.ITask.createInterface('ScriptFX.ITask');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.IObjectWithOwner

ScriptFX.IObjectWithOwner = function() { };
ScriptFX.IObjectWithOwner.prototype = {
    get_owner : null,
    setOwner : null
}
ScriptFX.IObjectWithOwner.createInterface('ScriptFX.IObjectWithOwner');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Application

ScriptFX.Application = function ScriptFX_Application() {
    this._disposableObjects = [];
    this._idleFrequency = 100;
    ScriptHost.add_load(Delegate.create(this, this._onScriptHostLoad));
    ScriptHost.add_unload(Delegate.create(this, this._onScriptHostUnload));
    this._windowUnloadingHandler = Delegate.create(this, this._onWindowUnloading);
    window.attachEvent('onbeforeunload', this._windowUnloadingHandler);
    this._windowErrorHandler = Delegate.create(this, this._onWindowError);
    window.attachEvent('onerror', this._windowErrorHandler);
    var rootElement = document.documentElement;
    var className = rootElement.className;
    if (className.startsWith('$')) {
        var hostInfo = this.get_host();
        className = className.replace('$browser', Enum.toString(ScriptFX.HostName, hostInfo.get_name()));
        className = className.replace('$majorver', hostInfo.get_majorVersion().toString());
        className = className.replace('$minorver', hostInfo.get_minorVersion().toString());
        rootElement.className = className;
    }
}
ScriptFX.Application.prototype = {
    _host: null,
    _isIE: 0,
    _scriptlets: null,
    _loaded: false,
    _disposing: false,
    _firstLoad: false,
    _sessionState: null,
    _history: null,
    _events: null,
    _disposableObjects: null,
    _idleFrequency: 0,
    _idleTimer: 0,
    _taskQueue: null,
    _taskTimer: 0,
    _registeredEventHandlers: null,
    _registeredEventTypes: null,
    _registeredEvents: null,
    _services: null,
    _windowUnloadingHandler: null,
    _windowErrorHandler: null,
    _idleTimerTickHandler: null,
    _taskTimerTickHandler: null,
    
    get_domain: function ScriptFX_Application$get_domain() {
        return window.document.domain;
    },
    set_domain: function ScriptFX_Application$set_domain(value) {
        window.document.domain = value;
        return value;
    },
    
    get__events: function ScriptFX_Application$get__events() {
        if (!this._events) {
            this._events = new ScriptFX.EventList();
        }
        return this._events;
    },
    
    get_history: function ScriptFX_Application$get_history() {
        Debug.assert(this._history, 'History has not been enabled.');
        return this._history;
    },
    
    get_host: function ScriptFX_Application$get_host() {
        if (!this._host) {
            this._host = new ScriptFX.HostInfo();
        }
        return this._host;
    },
    
    get_idleFrequency: function ScriptFX_Application$get_idleFrequency() {
        return this._idleFrequency;
    },
    set_idleFrequency: function ScriptFX_Application$set_idleFrequency(value) {
        Debug.assert(value >= 100, 'IdleFrequency must be atleast 100ms');
        this._idleFrequency = value;
        return value;
    },
    
    get_isFirstLoad: function ScriptFX_Application$get_isFirstLoad() {
        return this._firstLoad;
    },
    
    get_isIE: function ScriptFX_Application$get_isIE() {
        if (!this._isIE) {
            this._isIE = (this.get_host().get_name() === ScriptFX.HostName.IE) ? 1 : -1;
        }
        return (this._isIE === 1) ? true : false;
    },
    
    get_sessionState: function ScriptFX_Application$get_sessionState() {
        Debug.assert(this._loaded, 'You must wait until the load event before accessing session.');
        Debug.assert(this._sessionState, 'In order to use session, you must add an <input type=\"hidden\" id=\"__session\" /> within a <form>.');
        return this._sessionState;
    },
    
    add_error: function ScriptFX_Application$add_error(value) {
        this.get__events().addHandler('error', value);
    },
    remove_error: function ScriptFX_Application$remove_error(value) {
        this.get__events().removeHandler('error', value);
    },
    
    add_idle: function ScriptFX_Application$add_idle(value) {
        this.get__events().addHandler('idle', value);
        if (!this._idleTimer) {
            if (!this._idleTimerTickHandler) {
                this._idleTimerTickHandler = Delegate.create(this, this._onIdleTimerTick);
            }
            this._idleTimer = window.setTimeout(this._idleTimerTickHandler, this._idleFrequency);
        }
    },
    remove_idle: function ScriptFX_Application$remove_idle(value) {
        var isActive = this.get__events().removeHandler('idle', value);
        if ((!isActive) && (this._idleTimer)) {
            window.clearTimeout(this._idleTimer);
            this._idleTimer = 0;
        }
    },
    
    add_load: function ScriptFX_Application$add_load(value) {
        if (this._loaded) {
            value.invoke(this, EventArgs.Empty);
        }
        else {
            this.get__events().addHandler('load', value);
        }
    },
    remove_load: function ScriptFX_Application$remove_load(value) {
        this.get__events().removeHandler('load', value);
    },
    
    add_unload: function ScriptFX_Application$add_unload(value) {
        this.get__events().addHandler('unload', value);
    },
    remove_unload: function ScriptFX_Application$remove_unload(value) {
        this.get__events().removeHandler('unload', value);
    },
    
    add_unloading: function ScriptFX_Application$add_unloading(value) {
        this.get__events().addHandler('unloading', value);
    },
    remove_unloading: function ScriptFX_Application$remove_unloading(value) {
        this.get__events().removeHandler('unloading', value);
    },
    
    addTask: function ScriptFX_Application$addTask(task) {
        if (!this._taskQueue) {
            this._taskQueue = [];
        }
        this._taskQueue.enqueue(task);
        if (!this._taskTimer) {
            if (!this._taskTimerTickHandler) {
                this._taskTimerTickHandler = Delegate.create(this, this._onTaskTimerTick);
            }
            this._taskTimer = window.setTimeout(this._taskTimerTickHandler, 0);
        }
    },
    
    enableHistory: function ScriptFX_Application$enableHistory() {
        if (this._history) {
            return;
        }
        this._history = ScriptFX.HistoryManager._createHistory();
    },
    
    getService: function ScriptFX_Application$getService(serviceType) {
        Debug.assert(serviceType);
        if ((serviceType === IServiceContainer) || (serviceType === ScriptFX.IEventManager)) {
            return this;
        }
        if (this._services) {
            var name = serviceType.get_fullName().replace('.', '$');
            return this._services[name];
        }
        return null;
    },
    
    _onIdleTimerTick: function ScriptFX_Application$_onIdleTimerTick() {
        this._idleTimer = 0;
        var handler = this.get__events().getHandler('idle');
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
            this._idleTimer = window.setTimeout(this._idleTimerTickHandler, this._idleFrequency);
        }
    },
    
    _onScriptHostLoad: function ScriptFX_Application$_onScriptHostLoad(sender, e) {
        var sessionElement = $('__session');
        if (sessionElement) {
            var value = sessionElement.value;
            if (String.isNullOrEmpty(value)) {
                this._firstLoad = true;
                this._sessionState = {};
            }
            else {
                this._sessionState = ScriptFX.JSON.deserialize(value);
                if (isUndefined(this._sessionState['__appLoaded'])) {
                    this._firstLoad = true;
                }
            }
            this._sessionState['__appLoaded'] = true;
        }
        else {
            this._firstLoad = true;
        }
        if (this._scriptlets) {
            for (var i = 0; i < this._scriptlets.length; i += 2) {
                this._scriptlets[i].main(this._scriptlets[i + 1]);
            }
            this._scriptlets = null;
        }
        this._loaded = true;
        var handler = this.get__events().getHandler('load');
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
        }
        if (this._history) {
            this._history._initialize();
        }
    },
    
    _onScriptHostUnload: function ScriptFX_Application$_onScriptHostUnload(sender, e) {
        if (!this._disposing) {
            this._disposing = true;
            if (this._taskTimer) {
                window.clearTimeout(this._taskTimer);
            }
            if (this._idleTimer) {
                window.clearTimeout(this._idleTimer);
            }
            var handler = this.get__events().getHandler('unload');
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
            if (this._taskQueue) {
                while (this._taskQueue.length) {
                    var task = this._taskQueue.dequeue();
                    if (Type.canCast(task, IDisposable)) {
                        (task).dispose();
                    }
                }
            }
            if (this._disposableObjects.length) {
                var $enum1 = this._disposableObjects.getEnumerator();
                while ($enum1.moveNext()) {
                    var disposable = $enum1.get_current();
                    disposable.dispose();
                }
                this._disposableObjects.clear();
            }
            if (this._history) {
                this._history.dispose();
                this._history = null;
            }
            window.detachEvent('onbeforeunload', this._windowUnloadingHandler);
            window.detachEvent('onerror', this._windowErrorHandler);
            this._windowUnloadingHandler = null;
            this._windowErrorHandler = null;
            this._taskTimerTickHandler = null;
            this._idleTimerTickHandler = null;
        }
    },
    
    _onTaskTimerTick: function ScriptFX_Application$_onTaskTimerTick() {
        this._taskTimer = 0;
        if (this._taskQueue.length) {
            var task = this._taskQueue.dequeue();
            if (!task.execute()) {
                this._taskQueue.enqueue(task);
            }
            else {
                if (Type.canCast(task, IDisposable)) {
                    (task).dispose();
                }
            }
            if (this._taskQueue.length) {
                this._taskTimer = window.setTimeout(this._taskTimerTickHandler, 0);
            }
        }
    },
    
    _onWindowError: function ScriptFX_Application$_onWindowError() {
        var handler = this.get__events().getHandler('error');
        if (handler) {
            var ce = new ScriptFX.CancelEventArgs();
            ce.set_canceled(true);
            handler.invoke(this, ce);
            if (ce.get_canceled()) {
                window.event.returnValue = false;
            }
        }
    },
    
    _onWindowUnloading: function ScriptFX_Application$_onWindowUnloading() {
        window.event.avoidReturn = true;
        var handler = this.get__events().getHandler('unloading');
        if (handler) {
            var e = new ScriptFX.ApplicationUnloadingEventArgs();
            handler.invoke(this, e);
        }
        if (this._sessionState) {
            var sessionElement = $('__session');
            sessionElement.value = ScriptFX.JSON.serialize(this._sessionState);
        }
    },
    
    raiseEvent: function ScriptFX_Application$raiseEvent(eventType, sender, e) {
        Debug.assert(String.isNullOrEmpty(eventType));
        Debug.assert(sender);
        Debug.assert(e);
        if (this._registeredEventHandlers) {
            var handler = this._registeredEventHandlers[eventType];
            if (handler) {
                handler.invoke(sender, e);
            }
        }
    },
    
    registerDisposableObject: function ScriptFX_Application$registerDisposableObject(disposableObject) {
        if (!this._disposing) {
            this._disposableObjects.add(disposableObject);
        }
    },
    
    registerEvent: function ScriptFX_Application$registerEvent(eventType, sender, e) {
        Debug.assert(String.isNullOrEmpty(eventType));
        Debug.assert(sender);
        Debug.assert(e);
        if (this._registeredEventHandlers) {
            var handler = this._registeredEventHandlers[eventType];
            if (handler) {
                handler.invoke(sender, e);
            }
        }
        if (!this._registeredEvents) {
            this._registeredEvents = [];
        }
        if (!this._registeredEventTypes) {
            this._registeredEventTypes = {};
            this._registeredEventTypes[eventType] = 1;
        }
        else {
            var eventCount = this._registeredEventTypes[eventType];
            if (isUndefined(eventCount)) {
                this._registeredEventTypes[eventType] = 1;
            }
            else {
                this._registeredEventTypes[eventType] = 1 + eventCount;
            }
        }
        var eventInfo = ScriptFX.$create__registeredEvent(eventType, sender, e, this._registeredEvents.length);
        this._registeredEvents.add(eventInfo);
        return eventInfo.eventCookie;
    },
    
    registerEventHandler: function ScriptFX_Application$registerEventHandler(eventType, handler) {
        Debug.assert(!String.isNullOrEmpty(eventType));
        Debug.assert(handler);
        var existingHandler = null;
        if (!this._registeredEventHandlers) {
            this._registeredEventHandlers = {};
        }
        else {
            existingHandler = this._registeredEventHandlers[eventType];
        }
        this._registeredEventHandlers[eventType] = Delegate.combine(existingHandler, handler);
        if (!isNullOrUndefined(this._registeredEventTypes[eventType])) {
            var $enum1 = this._registeredEvents.getEnumerator();
            while ($enum1.moveNext()) {
                var eventInfo = $enum1.get_current();
                if (!eventInfo) {
                    continue;
                }
                if (eventInfo.eventType === eventType) {
                    handler.invoke(eventInfo.sender, eventInfo.eventArgs);
                }
            }
        }
    },
    
    registerService: function ScriptFX_Application$registerService(serviceType, service) {
        Debug.assert(serviceType);
        Debug.assert(service);
        if (!this._services) {
            this._services = {};
        }
        var name = serviceType.get_fullName().replace('.', '$');
        Debug.assert(!this._services[name]);
        this._services[name] = service;
    },
    
    run: function ScriptFX_Application$run(scriptletType, args) {
        if (this._loaded) {
            scriptletType.main(args);
        }
        else {
            if (!this._scriptlets) {
                this._scriptlets = [];
            }
            this._scriptlets.add(scriptletType);
            this._scriptlets.add(args);
        }
    },
    
    unregisterDisposableObject: function ScriptFX_Application$unregisterDisposableObject(disposableObject) {
        Debug.assert(disposableObject);
        if (!this._disposing) {
            this._disposableObjects.remove(disposableObject);
        }
    },
    
    unregisterEvent: function ScriptFX_Application$unregisterEvent(eventCookie) {
        Debug.assert(eventCookie);
        Debug.assert(Type.canCast(eventCookie, Number));
        Debug.assert(this._registeredEvents);
        Debug.assert(this._registeredEventTypes);
        var eventInfo = this._registeredEvents[eventCookie];
        Debug.assert(eventInfo);
        var eventCount = this._registeredEventTypes[eventInfo.eventType];
        Debug.assert(eventCount >= 1);
        if (eventCount === 1) {
            delete this._registeredEventTypes[eventInfo.eventType];
        }
        else {
            this._registeredEventTypes[eventInfo.eventType] = eventCount - 1;
        }
        this._registeredEvents[eventCookie] = null;
    },
    
    unregisterEventHandler: function ScriptFX_Application$unregisterEventHandler(eventType, handler) {
        Debug.assert(!String.isNullOrEmpty(eventType));
        Debug.assert(handler);
        if (this._registeredEventHandlers) {
            var existingHandler = this._registeredEventHandlers[eventType];
            if (existingHandler) {
                existingHandler = Delegate.remove(existingHandler, handler);
                if (!existingHandler) {
                    delete this._registeredEventHandlers[eventType];
                }
                else {
                    this._registeredEventHandlers[eventType] = existingHandler;
                }
            }
        }
    },
    
    unregisterService: function ScriptFX_Application$unregisterService(serviceType) {
        Debug.assert(serviceType);
        if (this._services) {
            var name = serviceType.get_fullName().replace('.', '$');
            delete this._services[name];
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CancelEventArgs

ScriptFX.CancelEventArgs = function ScriptFX_CancelEventArgs() {
    ScriptFX.CancelEventArgs.constructBase(this);
}
ScriptFX.CancelEventArgs.prototype = {
    _canceled$1: false,
    
    get_canceled: function ScriptFX_CancelEventArgs$get_canceled() {
        return this._canceled$1;
    },
    set_canceled: function ScriptFX_CancelEventArgs$set_canceled(value) {
        this._canceled$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CollectionChangedEventArgs

ScriptFX.CollectionChangedEventArgs = function ScriptFX_CollectionChangedEventArgs(action, item) {
    ScriptFX.CollectionChangedEventArgs.constructBase(this);
    this._action$1 = action;
    this._item$1 = item;
}
ScriptFX.CollectionChangedEventArgs.prototype = {
    _action$1: 0,
    _item$1: null,
    
    get_action: function ScriptFX_CollectionChangedEventArgs$get_action() {
        return this._action$1;
    },
    
    get_item: function ScriptFX_CollectionChangedEventArgs$get_item() {
        return this._item$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ApplicationUnloadingEventArgs

ScriptFX.ApplicationUnloadingEventArgs = function ScriptFX_ApplicationUnloadingEventArgs() {
    ScriptFX.ApplicationUnloadingEventArgs.constructBase(this);
}
ScriptFX.ApplicationUnloadingEventArgs.prototype = {
    
    setUnloadPrompt: function ScriptFX_ApplicationUnloadingEventArgs$setUnloadPrompt(prompt) {
        window.event.returnValue = prompt;
        window.event.avoidReturn = false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HistoryManager

ScriptFX.HistoryManager = function ScriptFX_HistoryManager(enabled, iframe) {
    this._enabled = enabled;
    this._iframe = iframe;
}
ScriptFX.HistoryManager._createHistory = function ScriptFX_HistoryManager$_createHistory() {
    var hostName = ScriptFX.Application.current.get_host().get_name();
    if ((hostName !== ScriptFX.HostName.IE) && (hostName !== ScriptFX.HostName.mozilla)) {
        return new ScriptFX.HistoryManager(false, null);
    }
    var iframe = null;
    if (hostName === ScriptFX.HostName.IE) {
        iframe = $('_historyFrame');
        Debug.assert(iframe, 'You must have an <iframe id=\"_historyFrame\" src=\"Empty.htm\" /> tag on your page.');
    }
    return new ScriptFX.HistoryManager(true, iframe);
}
ScriptFX.HistoryManager.prototype = {
    _enabled: false,
    _iframe: null,
    _emptyPageURL: null,
    _iframeLoadHandler: null,
    _ignoreTimer: false,
    _ignoreIFrame: false,
    _currentEntry: null,
    
    get_isEnabled: function ScriptFX_HistoryManager$get_isEnabled() {
        return this._enabled;
    },
    
    add_navigated: function ScriptFX_HistoryManager$add_navigated(value) {
        this.__navigated = Delegate.combine(this.__navigated, value);
    },
    remove_navigated: function ScriptFX_HistoryManager$remove_navigated(value) {
        this.__navigated = Delegate.remove(this.__navigated, value);
    },
    
    __navigated: null,
    
    addEntry: function ScriptFX_HistoryManager$addEntry(entryName) {
        Debug.assert(!String.isNullOrEmpty(entryName));
        Debug.assert(!$(entryName), 'The entry identifier should not be the same as an element ID.');
        if (!this._enabled) {
            return;
        }
        this._ignoreTimer = true;
        if (this._iframe) {
            this._ignoreIFrame = true;
            this._iframe.src = this._emptyPageURL + entryName;
        }
        else {
            this._setCurrentEntry(entryName);
        }
    },
    
    dispose: function ScriptFX_HistoryManager$dispose() {
        if (this._iframe) {
            this._iframe.detachEvent('onload', this._iframeLoadHandler);
            this._iframe = null;
        }
    },
    
    _getCurrentEntry: function ScriptFX_HistoryManager$_getCurrentEntry() {
        var entryName = window.location.hash;
        if ((entryName.length) && (entryName.charAt(0) === '#')) {
            entryName = entryName.substr(1);
        }
        return entryName;
    },
    
    goBack: function ScriptFX_HistoryManager$goBack() {
        window.history.back();
    },
    
    goForward: function ScriptFX_HistoryManager$goForward() {
        window.history.forward();
    },
    
    _initialize: function ScriptFX_HistoryManager$_initialize() {
        if (!this._enabled) {
            return;
        }
        ScriptFX.Application.current.add_idle(Delegate.create(this, this._onAppIdle));
        if (this._iframe) {
            Debug.assert(this._iframe.src.length, 'You must set the Src attribute of the history iframe element to an empty page.');
            this._emptyPageURL = this._iframe.src + '?';
            this._iframeLoadHandler = Delegate.create(this, this._onIFrameLoad);
            this._iframe.attachEvent('onload', this._iframeLoadHandler);
        }
        this._currentEntry = this._getCurrentEntry();
        this._onNavigated(this._currentEntry);
    },
    
    _onAppIdle: function ScriptFX_HistoryManager$_onAppIdle(sender, e) {
        var entryName = this._getCurrentEntry();
        if (entryName !== this._currentEntry) {
            if (this._ignoreTimer) {
                return;
            }
            this._currentEntry = entryName;
            this._onNavigated(entryName);
        }
        else {
            this._ignoreTimer = false;
        }
    },
    
    _onIFrameLoad: function ScriptFX_HistoryManager$_onIFrameLoad() {
        var entryName = this._iframe.contentWindow.location.search;
        if ((entryName.length) && (entryName.charAt(0) === '?')) {
            entryName = entryName.substr(1);
        }
        this._setCurrentEntry(entryName);
        if (this._ignoreIFrame) {
            this._ignoreIFrame = false;
            return;
        }
        this._onNavigated(entryName);
    },
    
    _onNavigated: function ScriptFX_HistoryManager$_onNavigated(entryName) {
        if (this.__navigated) {
            this.__navigated.invoke(this, new ScriptFX.HistoryEventArgs(entryName));
        }
    },
    
    _setCurrentEntry: function ScriptFX_HistoryManager$_setCurrentEntry(entryName) {
        this._currentEntry = entryName;
        window.location.hash = entryName;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HistoryEventArgs

ScriptFX.HistoryEventArgs = function ScriptFX_HistoryEventArgs(entryName) {
    ScriptFX.HistoryEventArgs.constructBase(this);
    this._entryName$1 = entryName;
}
ScriptFX.HistoryEventArgs.prototype = {
    _entryName$1: null,
    
    get_entryName: function ScriptFX_HistoryEventArgs$get_entryName() {
        return this._entryName$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HostInfo

ScriptFX.HostInfo = function ScriptFX_HostInfo() {
    var userAgent = window.navigator.userAgent.toLowerCase();
    var version = null;
    var index;
    if ((index = userAgent.indexOf('opera')) >= 0) {
        this._name = ScriptFX.HostName.opera;
        version = userAgent.substr(index + 6);
    }
    else if ((index = userAgent.indexOf('msie')) >= 0) {
        this._name = ScriptFX.HostName.IE;
        version = userAgent.substr(index + 5);
    }
    else if ((index = userAgent.indexOf('safari')) >= 0) {
        this._name = ScriptFX.HostName.safari;
        version = userAgent.substr(index + 7);
    }
    else if ((index = userAgent.indexOf('firefox')) >= 0) {
        this._name = ScriptFX.HostName.mozilla;
        version = userAgent.substr(index + 8);
    }
    else if (userAgent.indexOf('gecko') >= 0) {
        this._name = ScriptFX.HostName.mozilla;
        version = window.navigator.appVersion;
    }
    if (version) {
        this._version = parseFloat(version);
        this._majorVersion = parseInt(this._version);
        if ((index = version.indexOf('.')) >= 0) {
            this._minorVersion = parseInt(version.substr(index + 1));
        }
    }
}
ScriptFX.HostInfo.prototype = {
    _name: 0,
    _version: 0,
    _majorVersion: 0,
    _minorVersion: 0,
    
    get_majorVersion: function ScriptFX_HostInfo$get_majorVersion() {
        return this._majorVersion;
    },
    
    get_minorVersion: function ScriptFX_HostInfo$get_minorVersion() {
        return this._minorVersion;
    },
    
    get_name: function ScriptFX_HostInfo$get_name() {
        return this._name;
    },
    
    get_version: function ScriptFX_HostInfo$get_version() {
        return this._version;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.EventList

ScriptFX.EventList = function ScriptFX_EventList() {
}
ScriptFX.EventList.prototype = {
    _events: null,
    
    addHandler: function ScriptFX_EventList$addHandler(key, handler) {
        Debug.assert(!String.isNullOrEmpty(key));
        Debug.assert(handler);
        if (!this._events) {
            this._events = {};
        }
        this._events[key] = Delegate.combine(this._events[key], handler);
    },
    
    getHandler: function ScriptFX_EventList$getHandler(key) {
        Debug.assert(!String.isNullOrEmpty(key));
        if (this._events) {
            return this._events[key];
        }
        return null;
    },
    
    removeHandler: function ScriptFX_EventList$removeHandler(key, handler) {
        Debug.assert(!String.isNullOrEmpty(key));
        Debug.assert(handler);
        if (this._events) {
            var sourceHandler = this._events[key];
            if (sourceHandler) {
                var newHandler = Delegate.remove(sourceHandler, handler);
                this._events[key] = newHandler;
                return (newHandler);
            }
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.JSON

ScriptFX.JSON = function ScriptFX_JSON() {
}
ScriptFX.JSON.deserialize = function ScriptFX_JSON$deserialize(s) {
    if (String.isNullOrEmpty(s)) {
        return null;
    }
    if (!ScriptFX.JSON._dateRegex) {
        ScriptFX.JSON._dateRegex = new RegExp('(\'|\")\\\\@(-?[0-9]+)@(\'|\")', 'gm');
    }
    s = s.replace(ScriptFX.JSON._dateRegex, 'new Date($2)');
    return eval('(' + s + ')');
}
ScriptFX.JSON.serialize = function ScriptFX_JSON$serialize(o) {
    if (isNullOrUndefined(o)) {
        return String.Empty;
    }
    var sb = new StringBuilder();
    ScriptFX.JSON._serializeCore(sb, o);
    return sb.toString();
}
ScriptFX.JSON._serializeCore = function ScriptFX_JSON$_serializeCore(sb, o) {
    if (isNullOrUndefined(o)) {
        sb.append('null');
        return;
    }
    var scriptType = typeof(o);
    switch (scriptType) {
        case 'boolean':
            sb.append(o.toString());
            return;
        case 'number':
            sb.append((isFinite(o)) ? o.toString() : 'null');
            return;
        case 'string':
            sb.append((o).quote());
            return;
        case 'object':
            if (Array.isInstance(o)) {
                sb.append('[');
                var a = o;
                var length = a.length;
                var first = true;
                for (var i = 0; i < length; i++) {
                    if (first) {
                        first = false;
                    }
                    else {
                        sb.append(',');
                    }
                    ScriptFX.JSON._serializeCore(sb, a[i]);
                }
                sb.append(']');
            }
            else if (Date.isInstance(o)) {
                var d = o;
                var utcValue = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
                sb.append('\"\\@');
                sb.append(utcValue.toString());
                sb.append('@\"');
            }
            else if (RegExp.isInstance(o)) {
                sb.append(o.toString());
            }
            else {
                sb.append('{');
                var first = true;
                var $dict1 = o;
                for (var $key2 in $dict1) {
                    var entry = { key: $key2, value: $dict1[$key2] };
                    if ((entry.key).startsWith('$') || Function.isInstance(entry.value)) {
                        continue;
                    }
                    if (first) {
                        first = false;
                    }
                    else {
                        sb.append(',');
                    }
                    sb.append(entry.key);
                    sb.append(':');
                    ScriptFX.JSON._serializeCore(sb, entry.value);
                }
                sb.append('}');
            }
            return;
        default:
            Debug.fail(scriptType + ' is not supported for JSON serialization.');
            sb.append('null');
            return;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.PropertyChangedEventArgs

ScriptFX.PropertyChangedEventArgs = function ScriptFX_PropertyChangedEventArgs(propertyName) {
    ScriptFX.PropertyChangedEventArgs.constructBase(this);
    this._propertyName$1 = propertyName;
}
ScriptFX.PropertyChangedEventArgs.prototype = {
    _propertyName$1: null,
    
    get_propertyName: function ScriptFX_PropertyChangedEventArgs$get_propertyName() {
        return this._propertyName$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ObservableCollection

ScriptFX.ObservableCollection = function ScriptFX_ObservableCollection(owner, disposableItems) {
    this._owner = owner;
    this._items = [];
    this._disposableItems = disposableItems;
}
ScriptFX.ObservableCollection.prototype = {
    _owner: null,
    _items: null,
    _disposableItems: false,
    _handler: null,
    
    add_collectionChanged: function ScriptFX_ObservableCollection$add_collectionChanged(value) {
        this._handler = Delegate.combine(this._handler, value);
    },
    remove_collectionChanged: function ScriptFX_ObservableCollection$remove_collectionChanged(value) {
        this._handler = Delegate.remove(this._handler, value);
    },
    
    add: function ScriptFX_ObservableCollection$add(item) {
        (item).setOwner(this._owner);
        this._items.add(item);
        if (this._handler) {
            this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.add, item));
        }
    },
    
    clear: function ScriptFX_ObservableCollection$clear() {
        if (this._items.length) {
            var $enum1 = this._items.getEnumerator();
            while ($enum1.moveNext()) {
                var item = $enum1.get_current();
                item.setOwner(null);
            }
            this._items.clear();
            if (this._handler) {
                this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.reset, null));
            }
        }
    },
    
    contains: function ScriptFX_ObservableCollection$contains(item) {
        return this._items.contains(item);
    },
    
    dispose: function ScriptFX_ObservableCollection$dispose() {
        if (this._disposableItems) {
            var $enum1 = this._items.getEnumerator();
            while ($enum1.moveNext()) {
                var item = $enum1.get_current();
                item.dispose();
            }
        }
        this._items = null;
        this._owner = null;
        this._handler = null;
    },
    
    getEnumerator: function ScriptFX_ObservableCollection$getEnumerator() {
        return this._items.getEnumerator();
    },
    
    getItem: function ScriptFX_ObservableCollection$getItem(index) {
        return this._items[index];
    },
    
    getItems: function ScriptFX_ObservableCollection$getItems() {
        return this._items;
    },
    
    getLength: function ScriptFX_ObservableCollection$getLength() {
        return this._items.length;
    },
    
    remove: function ScriptFX_ObservableCollection$remove(item) {
        if (this._items.contains(item)) {
            (item).setOwner(null);
            this._items.remove(item);
            if (this._handler) {
                this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.remove, item));
            }
        }
    }
}


Type.createNamespace('ScriptFX.Net');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPStatusCode

ScriptFX.Net.HTTPStatusCode = function() { };
ScriptFX.Net.HTTPStatusCode.prototype = {
    canContinue: 100, 
    switchingProtocols: 101, 
    OK: 200, 
    created: 201, 
    partialContent: 206, 
    accepted: 202, 
    nonAuthoritativeInformation: 203, 
    noContent: 204, 
    resetContent: 205, 
    ambiguous: 300, 
    moved: 301, 
    redirect: 302, 
    redirectMethod: 303, 
    notModified: 304, 
    useProxy: 305, 
    temporaryRedirect: 307, 
    badRequest: 400, 
    methodNotAllowed: 400, 
    unauthorized: 401, 
    paymentRequired: 402, 
    forbidden: 403, 
    notFound: 404, 
    notAcceptable: 406, 
    proxyAuthenticationRequired: 407, 
    requestTimeout: 408, 
    conflict: 409, 
    gone: 410, 
    lengthRequired: 411, 
    preconditionFailed: 412, 
    requestEntityTooLarge: 413, 
    requestUriTooLong: 414, 
    unsupportedMediaType: 415, 
    requestedRangeNotSatisfiable: 416, 
    expectationFailed: 417, 
    internalServerError: 500, 
    notImplemented: 501, 
    badGateway: 502, 
    serviceUnavailable: 503, 
    gatewayTimeout: 504, 
    httpVersionNotSupported: 505
}
ScriptFX.Net.HTTPStatusCode.createEnum('ScriptFX.Net.HTTPStatusCode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequestState

ScriptFX.Net.HTTPRequestState = function() { };
ScriptFX.Net.HTTPRequestState.prototype = {
    inactive: 0, 
    inProgress: 1, 
    completed: 2, 
    aborted: 3, 
    timedOut: 4
}
ScriptFX.Net.HTTPRequestState.createEnum('ScriptFX.Net.HTTPRequestState', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPVerb

ScriptFX.Net.HTTPVerb = function() { };
ScriptFX.Net.HTTPVerb.prototype = {
    GET: 0, 
    POST: 1, 
    PUT: 2, 
    DELETE: 3
}
ScriptFX.Net.HTTPVerb.createEnum('ScriptFX.Net.HTTPVerb', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.IHTTPResponse

ScriptFX.Net.IHTTPResponse = function() { };
ScriptFX.Net.IHTTPResponse.prototype = {
    get_contentLength : null,
    get_contentType : null,
    get_headers : null,
    get_request : null,
    get_statusCode : null,
    get_statusText : null,
    get_timeStamp : null,
    getHeader : null,
    getObject : null,
    getText : null,
    getXML : null
}
ScriptFX.Net.IHTTPResponse.createInterface('ScriptFX.Net.IHTTPResponse');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequest

ScriptFX.Net.HTTPRequest = function ScriptFX_Net_HTTPRequest() {
}
ScriptFX.Net.HTTPRequest.createRequest = function ScriptFX_Net_HTTPRequest$createRequest(uri, verb) {
    Debug.assert(!String.isNullOrEmpty(uri));
    var request = new ScriptFX.Net.HTTPRequest();
    if (!uri.startsWith('{')) {
        request._uri = uri;
    }
    else {
        var uriData = ScriptFX.JSON.deserialize(uri);
        request._uri = uriData['__uri'];
        Debug.assert(!String.isNullOrEmpty(request._uri));
        if (uriData['__nullParams']) {
            request._transportType = uriData['__transportType'];
        }
        else {
            request._transportType = Type.getType(uriData['__transportType']);
            delete uriData.__uri;
            delete uriData.__transportType;
            request._transportParameters = uriData;
        }
        Debug.assert((request._transportType) && ScriptFX.Net.HTTPTransport.isAssignableFrom(request._transportType));
    }
    request._verb = verb;
    return request;
}
ScriptFX.Net.HTTPRequest.createURI = function ScriptFX_Net_HTTPRequest$createURI(uri, parameters) {
    var sb = new StringBuilder(uri);
    if (uri.indexOf('?') < 0) {
        sb.append('?');
    }
    var parameterIndex = 0;
    var $dict1 = parameters;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        if (parameterIndex) {
            sb.append('&');
        }
        sb.append(entry.key);
        sb.append('=');
        sb.append(encodeURIComponent(entry.value.toString()));
        parameterIndex++;
    }
    return sb.toString();
}
ScriptFX.Net.HTTPRequest.prototype = {
    _uri: null,
    _verb: 0,
    _content: null,
    _headers: null,
    _userName: null,
    _password: null,
    _transportType: null,
    _transportParameters: null,
    _timeout: 0,
    _callback: null,
    _context: null,
    _state: 0,
    _transport: null,
    _response: null,
    _timeStamp: null,
    
    get_content: function ScriptFX_Net_HTTPRequest$get_content() {
        return this._content;
    },
    set_content: function ScriptFX_Net_HTTPRequest$set_content(value) {
        Debug.assert(this.get_verb() === ScriptFX.Net.HTTPVerb.POST);
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.inactive);
        this._content = value;
        return value;
    },
    
    get_hasCredentials: function ScriptFX_Net_HTTPRequest$get_hasCredentials() {
        return (!String.isNullOrEmpty(this._userName));
    },
    
    get_hasHeaders: function ScriptFX_Net_HTTPRequest$get_hasHeaders() {
        return (this._headers);
    },
    
    get_headers: function ScriptFX_Net_HTTPRequest$get_headers() {
        if (!this._headers) {
            this._headers = {};
        }
        return this._headers;
    },
    
    get_password: function ScriptFX_Net_HTTPRequest$get_password() {
        return this._password;
    },
    
    get_response: function ScriptFX_Net_HTTPRequest$get_response() {
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.completed);
        return this._response;
    },
    
    get_state: function ScriptFX_Net_HTTPRequest$get_state() {
        return this._state;
    },
    
    get_timeout: function ScriptFX_Net_HTTPRequest$get_timeout() {
        return this._timeout;
    },
    set_timeout: function ScriptFX_Net_HTTPRequest$set_timeout(value) {
        this._timeout = value;
        return value;
    },
    
    get_timeStamp: function ScriptFX_Net_HTTPRequest$get_timeStamp() {
        return this._timeStamp;
    },
    
    get__transport: function ScriptFX_Net_HTTPRequest$get__transport() {
        return this._transport;
    },
    
    get__transportParameters: function ScriptFX_Net_HTTPRequest$get__transportParameters() {
        return this._transportParameters;
    },
    
    get_transportType: function ScriptFX_Net_HTTPRequest$get_transportType() {
        return this._transportType;
    },
    
    get_URI: function ScriptFX_Net_HTTPRequest$get_URI() {
        return this._uri;
    },
    
    get_userName: function ScriptFX_Net_HTTPRequest$get_userName() {
        return this._userName;
    },
    
    get_verb: function ScriptFX_Net_HTTPRequest$get_verb() {
        return this._verb;
    },
    
    abort: function ScriptFX_Net_HTTPRequest$abort() {
        if (this._state === ScriptFX.Net.HTTPRequestState.inProgress) {
            ScriptFX.Net.HTTPRequestManager._abort(this, false);
        }
    },
    
    dispose: function ScriptFX_Net_HTTPRequest$dispose() {
        if (this._transport) {
            this.abort();
        }
    },
    
    invoke: function ScriptFX_Net_HTTPRequest$invoke(callback, context) {
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.inactive);
        this._callback = callback;
        this._context = context;
        ScriptFX.Application.current.registerDisposableObject(this);
        ScriptFX.Net.HTTPRequestManager._beginInvoke(this);
    },
    
    _invokeCallback: function ScriptFX_Net_HTTPRequest$_invokeCallback() {
        ScriptFX.Application.current.unregisterDisposableObject(this);
        if (this._transport) {
            this._transport.dispose();
            this._transport = null;
        }
        if (this._callback) {
            this._callback.invoke(this, this._context);
            this._callback = null;
            this._context = null;
        }
    },
    
    _onAbort: function ScriptFX_Net_HTTPRequest$_onAbort() {
        this._state = ScriptFX.Net.HTTPRequestState.aborted;
        this._invokeCallback();
    },
    
    _onActivate: function ScriptFX_Net_HTTPRequest$_onActivate(transport) {
        this._transport = transport;
        this._state = ScriptFX.Net.HTTPRequestState.inProgress;
        this._timeStamp = new Date();
    },
    
    _onCompleted: function ScriptFX_Net_HTTPRequest$_onCompleted(response) {
        this._response = response;
        this._state = ScriptFX.Net.HTTPRequestState.completed;
        this._invokeCallback();
    },
    
    _onTimeout: function ScriptFX_Net_HTTPRequest$_onTimeout() {
        this._state = ScriptFX.Net.HTTPRequestState.timedOut;
        this._invokeCallback();
    },
    
    setContentAsForm: function ScriptFX_Net_HTTPRequest$setContentAsForm(data) {
        Debug.assert(data);
        this.get_headers()['Content-Type'] = 'application/x-www-form-urlencoded';
        var sb = new StringBuilder();
        var firstValue = true;
        var $dict1 = data;
        for (var $key2 in $dict1) {
            var e = { key: $key2, value: $dict1[$key2] };
            if (!firstValue) {
                sb.append('&');
            }
            sb.append(e.key);
            sb.append('=');
            sb.append(encodeURIComponent(e.value.toString()));
            firstValue = false;
        }
        this.set_content(sb.toString());
    },
    
    setContentAsJSON: function ScriptFX_Net_HTTPRequest$setContentAsJSON(data) {
        Debug.assert(data);
        this.get_headers()['Content-Type'] = 'text/json';
        this.set_content(ScriptFX.JSON.serialize(data));
    },
    
    setCredentials: function ScriptFX_Net_HTTPRequest$setCredentials(userName, password) {
        Debug.assert(!String.isNullOrEmpty(userName));
        Debug.assert(!String.isNullOrEmpty(password));
        this._userName = userName;
        this._password = password;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequestManager

ScriptFX.Net.HTTPRequestManager = function ScriptFX_Net_HTTPRequestManager() {
}
ScriptFX.Net.HTTPRequestManager.add_requestInvoking = function ScriptFX_Net_HTTPRequestManager$add_requestInvoking(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoking = Delegate.combine(ScriptFX.Net.HTTPRequestManager.__requestInvoking, value);
}
ScriptFX.Net.HTTPRequestManager.remove_requestInvoking = function ScriptFX_Net_HTTPRequestManager$remove_requestInvoking(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoking = Delegate.remove(ScriptFX.Net.HTTPRequestManager.__requestInvoking, value);
}
ScriptFX.Net.HTTPRequestManager.add_requestInvoked = function ScriptFX_Net_HTTPRequestManager$add_requestInvoked(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoked = Delegate.combine(ScriptFX.Net.HTTPRequestManager.__requestInvoked, value);
}
ScriptFX.Net.HTTPRequestManager.remove_requestInvoked = function ScriptFX_Net_HTTPRequestManager$remove_requestInvoked(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoked = Delegate.remove(ScriptFX.Net.HTTPRequestManager.__requestInvoked, value);
}
ScriptFX.Net.HTTPRequestManager.get_online = function ScriptFX_Net_HTTPRequestManager$get_online() {
    return window.navigator.onLine;
}
ScriptFX.Net.HTTPRequestManager.get_timeoutInterval = function ScriptFX_Net_HTTPRequestManager$get_timeoutInterval() {
    return ScriptFX.Net.HTTPRequestManager._timeoutInterval;
}
ScriptFX.Net.HTTPRequestManager.set_timeoutInterval = function ScriptFX_Net_HTTPRequestManager$set_timeoutInterval(value) {
    ScriptFX.Net.HTTPRequestManager._timeoutInterval = value;
    return value;
}
ScriptFX.Net.HTTPRequestManager._abort = function ScriptFX_Net_HTTPRequestManager$_abort(request, timedOut) {
    var transport = request.get__transport();
    if (transport) {
        transport.abort();
        ScriptFX.Net.HTTPRequestManager._endInvoke(request, null, timedOut);
    }
}
ScriptFX.Net.HTTPRequestManager.abortAll = function ScriptFX_Net_HTTPRequestManager$abortAll() {
    var requests = ScriptFX.Net.HTTPRequestManager._activeRequests;
    ScriptFX.Net.HTTPRequestManager._activeRequests = [];
    var $enum1 = requests.getEnumerator();
    while ($enum1.moveNext()) {
        var request = $enum1.get_current();
        ScriptFX.Net.HTTPRequestManager._abort(request, false);
    }
}
ScriptFX.Net.HTTPRequestManager._beginInvoke = function ScriptFX_Net_HTTPRequestManager$_beginInvoke(request) {
    if (ScriptFX.Net.HTTPRequestManager.__requestInvoking) {
        var e = new ScriptFX.Net.PreHTTPRequestEventArgs(request);
        ScriptFX.Net.HTTPRequestManager.__requestInvoking.invoke(null, e);
        if (e.get_isSuppressed()) {
            request._onCompleted(e.get_response());
            return;
        }
    }
    var transportType = request.get_transportType();
    if (!transportType) {
        transportType = ScriptFX.Net._xmlhttpTransport;
    }
    var transport = new transportType(request);
    request._onActivate(transport);
    ScriptFX.Net.HTTPRequestManager._activeRequests.add(request);
    transport.invoke();
    if (((ScriptFX.Net.HTTPRequestManager._timeoutInterval) || (request.get_timeout())) && (!ScriptFX.Net.HTTPRequestManager._appIdleHandler)) {
        ScriptFX.Net.HTTPRequestManager._appIdleHandler = Delegate.create(null, ScriptFX.Net.HTTPRequestManager._onApplicationIdle);
        ScriptFX.Application.current.add_idle(ScriptFX.Net.HTTPRequestManager._appIdleHandler);
    }
}
ScriptFX.Net.HTTPRequestManager._endInvoke = function ScriptFX_Net_HTTPRequestManager$_endInvoke(request, response, timedOut) {
    ScriptFX.Net.HTTPRequestManager._activeRequests.remove(request);
    if (response) {
        request._onCompleted(response);
    }
    else if (timedOut) {
        request._onTimeout();
    }
    else {
        request._onAbort();
    }
    if (ScriptFX.Net.HTTPRequestManager.__requestInvoked) {
        var e = new ScriptFX.Net.PostHTTPRequestEventArgs(request, response);
        ScriptFX.Net.HTTPRequestManager.__requestInvoked.invoke(null, e);
    }
    if ((!ScriptFX.Net.HTTPRequestManager._activeRequests.length) && (ScriptFX.Net.HTTPRequestManager._appIdleHandler)) {
        ScriptFX.Application.current.remove_idle(ScriptFX.Net.HTTPRequestManager._appIdleHandler);
        ScriptFX.Net.HTTPRequestManager._appIdleHandler = null;
    }
}
ScriptFX.Net.HTTPRequestManager._onApplicationIdle = function ScriptFX_Net_HTTPRequestManager$_onApplicationIdle(sender, e) {
    if (!ScriptFX.Net.HTTPRequestManager._activeRequests.length) {
        return;
    }
    var timedOutRequests = null;
    var currentTimeValue = (new Date()).getTime();
    var $enum1 = ScriptFX.Net.HTTPRequestManager._activeRequests.getEnumerator();
    while ($enum1.moveNext()) {
        var request = $enum1.get_current();
        var timeStampValue = request.get_timeStamp().getTime();
        var interval = request.get_timeout();
        if (!interval) {
            interval = ScriptFX.Net.HTTPRequestManager._timeoutInterval;
            if (!interval) {
                continue;
            }
        }
        if ((currentTimeValue - timeStampValue) > interval) {
            if (!timedOutRequests) {
                timedOutRequests = [];
            }
            timedOutRequests.add(request);
        }
    }
    if (timedOutRequests) {
        var $enum2 = timedOutRequests.getEnumerator();
        while ($enum2.moveNext()) {
            var request = $enum2.get_current();
            ScriptFX.Net.HTTPRequestManager._abort(request, true);
        }
    }
}
ScriptFX.Net.HTTPRequestManager._onCompleted = function ScriptFX_Net_HTTPRequestManager$_onCompleted(request, response) {
    ScriptFX.Net.HTTPRequestManager._endInvoke(request, response, false);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPTransport

ScriptFX.Net.HTTPTransport = function ScriptFX_Net_HTTPTransport(request) {
    this._request = request;
}
ScriptFX.Net.HTTPTransport.createURI = function ScriptFX_Net_HTTPTransport$createURI(uri, transportType, parameters) {
    Debug.assert(!String.isNullOrEmpty(uri));
    Debug.assert((transportType) && ScriptFX.Net.HTTPTransport.isAssignableFrom(transportType));
    if (!parameters) {
        return '{__nullParams: true, __uri:\'' + uri + '\', __transportType: ' + transportType.get_fullName() + '}';
    }
    else {
        parameters['__uri'] = uri;
        parameters['__transportType'] = transportType.get_fullName();
        return ScriptFX.JSON.serialize(parameters);
    }
}
ScriptFX.Net.HTTPTransport.prototype = {
    _request: null,
    
    get_parameters: function ScriptFX_Net_HTTPTransport$get_parameters() {
        return this._request.get__transportParameters();
    },
    
    get_request: function ScriptFX_Net_HTTPTransport$get_request() {
        return this._request;
    },
    
    getMethod: function ScriptFX_Net_HTTPTransport$getMethod() {
        return Enum.toString(ScriptFX.Net.HTTPVerb, this._request.get_verb());
    },
    
    onCompleted: function ScriptFX_Net_HTTPTransport$onCompleted(response) {
        ScriptFX.Net.HTTPRequestManager._onCompleted(this._request, response);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.PostHTTPRequestEventArgs

ScriptFX.Net.PostHTTPRequestEventArgs = function ScriptFX_Net_PostHTTPRequestEventArgs(request, response) {
    ScriptFX.Net.PostHTTPRequestEventArgs.constructBase(this);
    this._request$1 = request;
    this._response$1 = response;
}
ScriptFX.Net.PostHTTPRequestEventArgs.prototype = {
    _request$1: null,
    _response$1: null,
    
    get_request: function ScriptFX_Net_PostHTTPRequestEventArgs$get_request() {
        return this._request$1;
    },
    
    get_response: function ScriptFX_Net_PostHTTPRequestEventArgs$get_response() {
        return this._response$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.PreHTTPRequestEventArgs

ScriptFX.Net.PreHTTPRequestEventArgs = function ScriptFX_Net_PreHTTPRequestEventArgs(request) {
    ScriptFX.Net.PreHTTPRequestEventArgs.constructBase(this);
    this._request$1 = request;
}
ScriptFX.Net.PreHTTPRequestEventArgs.prototype = {
    _request$1: null,
    _response$1: null,
    _suppressed$1: false,
    
    get_isSuppressed: function ScriptFX_Net_PreHTTPRequestEventArgs$get_isSuppressed() {
        return this._suppressed$1;
    },
    
    get_request: function ScriptFX_Net_PreHTTPRequestEventArgs$get_request() {
        return this._request$1;
    },
    
    get_response: function ScriptFX_Net_PreHTTPRequestEventArgs$get_response() {
        return this._response$1;
    },
    
    suppressRequest: function ScriptFX_Net_PreHTTPRequestEventArgs$suppressRequest(response) {
        this._suppressed$1 = true;
        this._response$1 = response;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._xmlhttpResponse

ScriptFX.Net._xmlhttpResponse = function ScriptFX_Net__xmlhttpResponse(request, xmlHTTP) {
    this._timeStamp = new Date();
    this._request = request;
    this._xmlHTTP = xmlHTTP;
}
ScriptFX.Net._xmlhttpResponse.prototype = {
    _request: null,
    _xmlHTTP: null,
    _headers: null,
    _timeStamp: null,
    _text: null,
    _object: null,
    _xml: null,
    
    get_contentLength: function ScriptFX_Net__xmlhttpResponse$get_contentLength() {
        return this.getText().length;
    },
    
    get_contentType: function ScriptFX_Net__xmlhttpResponse$get_contentType() {
        return this._xmlHTTP.getResponseHeader('Content-Type');
    },
    
    get_headers: function ScriptFX_Net__xmlhttpResponse$get_headers() {
        if (!this._headers) {
            var headers = this._xmlHTTP.getAllResponseHeaders();
            var parts = headers.split('\n');
            this._headers = {};
            var $enum1 = parts.getEnumerator();
            while ($enum1.moveNext()) {
                var part = $enum1.get_current();
                var colonIndex = part.indexOf(':');
                this._headers[part.substr(0, colonIndex)] = part.substr(colonIndex + 1).trim();
            }
        }
        return this._headers;
    },
    
    get_request: function ScriptFX_Net__xmlhttpResponse$get_request() {
        return this._request;
    },
    
    get_statusCode: function ScriptFX_Net__xmlhttpResponse$get_statusCode() {
        return this._xmlHTTP.status;
    },
    
    get_statusText: function ScriptFX_Net__xmlhttpResponse$get_statusText() {
        return this._xmlHTTP.statusText;
    },
    
    get_timeStamp: function ScriptFX_Net__xmlhttpResponse$get_timeStamp() {
        return this._timeStamp;
    },
    
    getHeader: function ScriptFX_Net__xmlhttpResponse$getHeader(name) {
        return this._xmlHTTP.getResponseHeader(name);
    },
    
    getObject: function ScriptFX_Net__xmlhttpResponse$getObject() {
        if (!this._object) {
            this._object = ScriptFX.JSON.deserialize(this.getText());
        }
        return this._object;
    },
    
    getText: function ScriptFX_Net__xmlhttpResponse$getText() {
        if (!this._text) {
            this._text = this._xmlHTTP.responseText;
        }
        return this._text;
    },
    
    getXML: function ScriptFX_Net__xmlhttpResponse$getXML() {
        if (!this._xml) {
            var xml = this._xmlHTTP.responseXML;
            if ((!xml) || (!xml.documentElement)) {
                try {
                    xml = XMLDocumentParser.parse(this._xmlHTTP.responseText);
                    if ((xml) && (xml.documentElement)) {
                        this._xml = xml;
                    }
                }
                catch ($e1) {
                }
            }
            else {
                this._xml = xml;
                if (ScriptFX.Application.current.get_isIE()) {
                    xml.setProperty('SelectionLanguage', 'XPath');
                }
            }
        }
        return this._xml;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._xmlhttpTransport

ScriptFX.Net._xmlhttpTransport = function ScriptFX_Net__xmlhttpTransport(request) {
    ScriptFX.Net._xmlhttpTransport.constructBase(this, [ request ]);
}
ScriptFX.Net._xmlhttpTransport.prototype = {
    _xmlHTTP$1: null,
    
    abort: function ScriptFX_Net__xmlhttpTransport$abort() {
        if (this._xmlHTTP$1) {
            this._xmlHTTP$1.onreadystatechange = Delegate.Null;
            this._xmlHTTP$1.abort();
            this._xmlHTTP$1 = null;
        }
    },
    
    dispose: function ScriptFX_Net__xmlhttpTransport$dispose() {
        this.abort();
    },
    
    invoke: function ScriptFX_Net__xmlhttpTransport$invoke() {
        var request = this.get_request();
        this._xmlHTTP$1 = new XMLHttpRequest();
        this._xmlHTTP$1.onreadystatechange = Delegate.create(this, this._onReadyStateChange$1);
        if (!this.get_request().get_hasCredentials()) {
            this._xmlHTTP$1.open(this.getMethod(), request.get_URI(), true);
        }
        else {
            this._xmlHTTP$1.open(this.getMethod(), request.get_URI(), true, request.get_userName(), request.get_password());
        }
        var headers = (request.get_hasHeaders()) ? request.get_headers() : null;
        if (headers) {
            var $dict1 = headers;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                this._xmlHTTP$1.setRequestHeader(entry.key, entry.value);
            }
        }
        var body = request.get_content();
        if ((body) && ((!headers) || (!headers['Content-Type']))) {
            this._xmlHTTP$1.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
        }
        this._xmlHTTP$1.send(body);
    },
    
    _onReadyStateChange$1: function ScriptFX_Net__xmlhttpTransport$_onReadyStateChange$1() {
        if (this._xmlHTTP$1.readyState === 4) {
            var response = new ScriptFX.Net._xmlhttpResponse(this.get_request(), this._xmlHTTP$1);
            this._xmlHTTP$1.onreadystatechange = Delegate.Null;
            this._xmlHTTP$1 = null;
            this.onCompleted(response);
        }
    }
}


Type.createNamespace('ScriptFX.UI');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationStopState

ScriptFX.UI.AnimationStopState = function() { };
ScriptFX.UI.AnimationStopState.prototype = {
    complete: 0, 
    abort: 1, 
    revert: 2
}
ScriptFX.UI.AnimationStopState.createEnum('ScriptFX.UI.AnimationStopState', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Bounds

ScriptFX.UI.$create_Bounds = function ScriptFX_UI_Bounds(left, top, width, height) {
    var $o = { };
    $o.left = left;
    $o.top = top;
    $o.width = width;
    $o.height = height;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropData

ScriptFX.UI.$create_DragDropData = function ScriptFX_UI_DragDropData(mode, dataType, data) {
    var $o = { };
    $o.mode = mode;
    $o.dataType = dataType;
    $o.data = data;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragMode

ScriptFX.UI.DragMode = function() { };
ScriptFX.UI.DragMode.prototype = {
    move: 0, 
    copy: 1
}
ScriptFX.UI.DragMode.createEnum('ScriptFX.UI.DragMode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IAction

ScriptFX.UI.IAction = function() { };
ScriptFX.UI.IAction.prototype = {
    get_actionArgument : null,
    get_actionName : null,
    add_action : null,
    remove_action : null
}
ScriptFX.UI.IAction.createInterface('ScriptFX.UI.IAction');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDragDrop

ScriptFX.UI.IDragDrop = function() { };
ScriptFX.UI.IDragDrop.prototype = {
    get_supportsDataTransfer : null,
    dragDrop : null
}
ScriptFX.UI.IDragDrop.createInterface('ScriptFX.UI.IDragDrop');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDragSource

ScriptFX.UI.IDragSource = function() { };
ScriptFX.UI.IDragSource.prototype = {
    get_domElement : null,
    onDragStart : null,
    onDrag : null,
    onDragEnd : null
}
ScriptFX.UI.IDragSource.createInterface('ScriptFX.UI.IDragSource');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDropTarget

ScriptFX.UI.IDropTarget = function() { };
ScriptFX.UI.IDropTarget.prototype = {
    get_domElement : null,
    supportsDataObject : null,
    drop : null,
    onDragEnter : null,
    onDragLeave : null,
    onDragOver : null
}
ScriptFX.UI.IDropTarget.createInterface('ScriptFX.UI.IDropTarget');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IEditableText

ScriptFX.UI.IEditableText = function() { };
ScriptFX.UI.IEditableText.prototype = {
    get_text : null,
    set_text : null,
    add_textChanged : null,
    remove_textChanged : null
}
ScriptFX.UI.IEditableText.createInterface('ScriptFX.UI.IEditableText');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IStaticText

ScriptFX.UI.IStaticText = function() { };
ScriptFX.UI.IStaticText.prototype = {
    get_text : null
}
ScriptFX.UI.IStaticText.createInterface('ScriptFX.UI.IStaticText');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IToggle

ScriptFX.UI.IToggle = function() { };
ScriptFX.UI.IToggle.prototype = {
    get_checked : null,
    add_checkedChanged : null,
    remove_checkedChanged : null
}
ScriptFX.UI.IToggle.createInterface('ScriptFX.UI.IToggle');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IValidator

ScriptFX.UI.IValidator = function() { };
ScriptFX.UI.IValidator.prototype = {
    get_isValid : null,
    get_validationGroup : null
}
ScriptFX.UI.IValidator.createInterface('ScriptFX.UI.IValidator');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Key

ScriptFX.UI.Key = function() { };
ScriptFX.UI.Key.prototype = {
    backspace: 8, 
    tab: 9, 
    enter: 13, 
    escape: 27, 
    space: 32, 
    pageUp: 33, 
    pageDown: 34, 
    end: 35, 
    home: 36, 
    left: 37, 
    up: 38, 
    right: 39, 
    down: 40, 
    del: 127
}
ScriptFX.UI.Key.createEnum('ScriptFX.UI.Key', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Location

ScriptFX.UI.$create_Location = function ScriptFX_UI_Location(left, top) {
    var $o = { };
    $o.left = left;
    $o.top = top;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.OverlayOptions

ScriptFX.UI.$create_OverlayOptions = function ScriptFX_UI_OverlayOptions(cssClass) {
    var $o = { };
    $o.cssClass = cssClass;
    $o.fadeInOutInterval = 250;
    $o.opacity = 0.75;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupMode

ScriptFX.UI.PopupMode = function() { };
ScriptFX.UI.PopupMode.prototype = {
    center: 0, 
    anchorTopLeft: 1, 
    anchorTopRight: 2, 
    anchorBottomRight: 3, 
    anchorBottomLeft: 4, 
    alignTopLeft: 5, 
    alignTopRight: 6, 
    alignBottomRight: 7, 
    alignBottomLeft: 8
}
ScriptFX.UI.PopupMode.createEnum('ScriptFX.UI.PopupMode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupOptions

ScriptFX.UI.$create_PopupOptions = function ScriptFX_UI_PopupOptions(referenceElement, mode) {
    var $o = { };
    $o.referenceElement = referenceElement;
    $o.mode = mode;
    $o.id = null;
    $o.xOffset = 0;
    $o.yOffset = 0;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Size

ScriptFX.UI.$create_Size = function ScriptFX_UI_Size(width, height) {
    var $o = { };
    $o.width = width;
    $o.height = height;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Animation

ScriptFX.UI.Animation = function ScriptFX_UI_Animation(domElement) {
    if (!domElement) {
        domElement = document.documentElement;
    }
    this._domElement = domElement;
    this._repeatCount = 1;
    ScriptFX.Application.current.registerDisposableObject(this);
}
ScriptFX.UI.Animation.prototype = {
    _domElement: null,
    _repeatCount: 0,
    _autoReverse: false,
    _repeatDelay: 0,
    _completed: false,
    _isPlaying: false,
    _isRepeating: false,
    _repetitions: 0,
    _repeatTimeStamp: 0,
    _reversed: false,
    
    add_repeating: function ScriptFX_UI_Animation$add_repeating(value) {
        this.__repeating = Delegate.combine(this.__repeating, value);
    },
    remove_repeating: function ScriptFX_UI_Animation$remove_repeating(value) {
        this.__repeating = Delegate.remove(this.__repeating, value);
    },
    
    __repeating: null,
    
    add_starting: function ScriptFX_UI_Animation$add_starting(value) {
        this.__starting = Delegate.combine(this.__starting, value);
    },
    remove_starting: function ScriptFX_UI_Animation$remove_starting(value) {
        this.__starting = Delegate.remove(this.__starting, value);
    },
    
    __starting: null,
    
    add_stopped: function ScriptFX_UI_Animation$add_stopped(value) {
        this.__stopped = Delegate.combine(this.__stopped, value);
    },
    remove_stopped: function ScriptFX_UI_Animation$remove_stopped(value) {
        this.__stopped = Delegate.remove(this.__stopped, value);
    },
    
    __stopped: null,
    
    get_autoReverse: function ScriptFX_UI_Animation$get_autoReverse() {
        return this._autoReverse;
    },
    set_autoReverse: function ScriptFX_UI_Animation$set_autoReverse(value) {
        Debug.assert(!this.get_isPlaying());
        this._autoReverse = value;
        return value;
    },
    
    get_completed: function ScriptFX_UI_Animation$get_completed() {
        return this._completed;
    },
    
    get_domElement: function ScriptFX_UI_Animation$get_domElement() {
        return this._domElement;
    },
    
    get_isPlaying: function ScriptFX_UI_Animation$get_isPlaying() {
        return this._isPlaying;
    },
    
    get_isReversed: function ScriptFX_UI_Animation$get_isReversed() {
        return this._reversed;
    },
    
    get_repeatCount: function ScriptFX_UI_Animation$get_repeatCount() {
        return this._repeatCount;
    },
    set_repeatCount: function ScriptFX_UI_Animation$set_repeatCount(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._repeatCount = value;
        return value;
    },
    
    get_repeatDelay: function ScriptFX_UI_Animation$get_repeatDelay() {
        return this._repeatDelay;
    },
    set_repeatDelay: function ScriptFX_UI_Animation$set_repeatDelay(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._repeatDelay = value;
        return value;
    },
    
    get_repetitions: function ScriptFX_UI_Animation$get_repetitions() {
        return this._repetitions;
    },
    
    dispose: function ScriptFX_UI_Animation$dispose() {
        if (this._isPlaying) {
            this.stop(ScriptFX.UI.AnimationStopState.abort);
        }
        if (this._domElement) {
            this._domElement = null;
            ScriptFX.Application.current.unregisterDisposableObject(this);
        }
    },
    
    _onPlay: function ScriptFX_UI_Animation$_onPlay(reversed) {
        if (this.__starting) {
            this.__starting.invoke(this, EventArgs.Empty);
        }
        this.performSetup();
        this._isPlaying = true;
        this._repetitions = 1;
        this._reversed = reversed;
        this.playCore();
    },
    
    _onStop: function ScriptFX_UI_Animation$_onStop(completed, stopState) {
        this.stopCore(completed, stopState);
        this._completed = completed;
        this._isPlaying = false;
        this.performCleanup();
        if (this.__stopped) {
            this.__stopped.invoke(this, EventArgs.Empty);
        }
    },
    
    _onProgress: function ScriptFX_UI_Animation$_onProgress(timeStamp) {
        if (this._isRepeating) {
            if ((this._repeatDelay) && ((this._repeatTimeStamp + this._repeatDelay) > timeStamp)) {
                return false;
            }
        }
        var completed = this.progressCore(this._isRepeating, timeStamp);
        this._isRepeating = false;
        if (completed && ((!this._repeatCount) || (this._repeatCount > this._repetitions))) {
            completed = false;
            this._repetitions++;
            if (this.__repeating) {
                var ce = new ScriptFX.CancelEventArgs();
                this.__repeating.invoke(this, ce);
                completed = ce.get_canceled();
            }
            if (!completed) {
                this._isRepeating = true;
                if (this._autoReverse) {
                    this._reversed = !this._reversed;
                }
                this._repeatTimeStamp = timeStamp;
                this.performRepetition(this._reversed);
            }
        }
        return completed;
    },
    
    performCleanup: function ScriptFX_UI_Animation$performCleanup() {
    },
    
    performRepetition: function ScriptFX_UI_Animation$performRepetition(reversed) {
    },
    
    performSetup: function ScriptFX_UI_Animation$performSetup() {
    },
    
    play: function ScriptFX_UI_Animation$play() {
        Debug.assert(!this.get_isPlaying());
        this._completed = false;
        ScriptFX.UI.AnimationManager._play(this);
    },
    
    stop: function ScriptFX_UI_Animation$stop(stopState) {
        Debug.assert(this.get_isPlaying());
        ScriptFX.UI.AnimationManager._stop(this, stopState);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationManager

ScriptFX.UI.AnimationManager = function ScriptFX_UI_AnimationManager() {
}
ScriptFX.UI.AnimationManager.get_FPS = function ScriptFX_UI_AnimationManager$get_FPS() {
    return ScriptFX.UI.AnimationManager._fps;
}
ScriptFX.UI.AnimationManager.set_FPS = function ScriptFX_UI_AnimationManager$set_FPS(value) {
    Debug.assert((value > 0) && (value <= 100));
    ScriptFX.UI.AnimationManager._fps = value;
    return value;
}
ScriptFX.UI.AnimationManager._onTick = function ScriptFX_UI_AnimationManager$_onTick() {
    ScriptFX.UI.AnimationManager._timerCookie = 0;
    if (!ScriptFX.UI.AnimationManager._activeAnimations.length) {
        return;
    }
    var timeStamp = (new Date()).getTime();
    var currentAnimations = ScriptFX.UI.AnimationManager._activeAnimations;
    var newAnimations = [];
    ScriptFX.UI.AnimationManager._activeAnimations = null;
    var $enum1 = currentAnimations.getEnumerator();
    while ($enum1.moveNext()) {
        var animation = $enum1.get_current();
        var completed = animation._onProgress(timeStamp);
        if (completed) {
            animation._onStop(true, ScriptFX.UI.AnimationStopState.complete);
        }
        else {
            newAnimations.add(animation);
        }
    }
    if (newAnimations.length) {
        ScriptFX.UI.AnimationManager._activeAnimations = newAnimations;
        if (!ScriptFX.UI.AnimationManager._timerCookie) {
            ScriptFX.UI.AnimationManager._timerCookie = window.setTimeout(Delegate.create(null, ScriptFX.UI.AnimationManager._onTick), 1000 / ScriptFX.UI.AnimationManager._fps);
        }
    }
}
ScriptFX.UI.AnimationManager._play = function ScriptFX_UI_AnimationManager$_play(animation) {
    if (!ScriptFX.UI.AnimationManager._activeAnimations) {
        ScriptFX.UI.AnimationManager._activeAnimations = [];
    }
    ScriptFX.UI.AnimationManager._activeAnimations.add(animation);
    animation._onPlay(false);
    if (!ScriptFX.UI.AnimationManager._timerCookie) {
        ScriptFX.UI.AnimationManager._timerCookie = window.setTimeout(Delegate.create(null, ScriptFX.UI.AnimationManager._onTick), 1000 / ScriptFX.UI.AnimationManager._fps);
    }
}
ScriptFX.UI.AnimationManager._stop = function ScriptFX_UI_AnimationManager$_stop(animation, stopState) {
    Debug.assert(ScriptFX.UI.AnimationManager._activeAnimations);
    animation._onStop(false, stopState);
    ScriptFX.UI.AnimationManager._activeAnimations.remove(animation);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationSequence

ScriptFX.UI.AnimationSequence = function ScriptFX_UI_AnimationSequence(animations) {
    ScriptFX.UI.AnimationSequence.constructBase(this, [ null ]);
    Debug.assert((animations) && (animations.length > 1));
    this._animations$1 = animations;
    this._current$1 = -1;
}
ScriptFX.UI.AnimationSequence.prototype = {
    _animations$1: null,
    _successionDelay$1: 0,
    _current$1: 0,
    _nextAnimation$1: false,
    _successionTimeStamp$1: 0,
    
    get_successionDelay: function ScriptFX_UI_AnimationSequence$get_successionDelay() {
        return this._successionDelay$1;
    },
    set_successionDelay: function ScriptFX_UI_AnimationSequence$set_successionDelay(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._successionDelay$1 = value;
        return value;
    },
    
    playCore: function ScriptFX_UI_AnimationSequence$playCore() {
        Debug.assert(this._current$1 === -1);
        if (!this.get_isReversed()) {
            this._current$1 = 0;
        }
        else {
            this._current$1 = this._animations$1.length - 1;
        }
        this._animations$1[this._current$1]._onPlay(this.get_isReversed());
    },
    
    progressCore: function ScriptFX_UI_AnimationSequence$progressCore(startRepetition, timeStamp) {
        if (startRepetition) {
            if (!this.get_isReversed()) {
                this._current$1 = 0;
            }
            else {
                this._current$1 = this._animations$1.length - 1;
            }
            this._nextAnimation$1 = true;
        }
        var animation = this._animations$1[this._current$1];
        if (this._nextAnimation$1) {
            if ((this._successionDelay$1) && ((this._successionTimeStamp$1 + this._successionDelay$1) > timeStamp)) {
                return false;
            }
            this._nextAnimation$1 = false;
            animation._onPlay(this.get_isReversed());
        }
        var completed = animation._onProgress(timeStamp);
        if (completed) {
            animation._onStop(true, ScriptFX.UI.AnimationStopState.complete);
            if (!this.get_isReversed()) {
                this._current$1++;
            }
            else {
                this._current$1--;
            }
            this._nextAnimation$1 = true;
            this._successionTimeStamp$1 = timeStamp;
        }
        return completed && ((this._current$1 === this._animations$1.length) || (this._current$1 === -1));
    },
    
    stopCore: function ScriptFX_UI_AnimationSequence$stopCore(completed, stopState) {
        if (!completed) {
            var animation = this._animations$1[this._current$1];
            animation._onStop(false, stopState);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Behavior

ScriptFX.UI.Behavior = function ScriptFX_UI_Behavior(domElement, id) {
    Debug.assert(domElement);
    ScriptFX.Application.current.registerDisposableObject(this);
    this._domElement = domElement;
    this._id = id;
    if (!String.isNullOrEmpty(id)) {
        if (id === 'control') {
            var existingControl = domElement[id];
            if ((existingControl) && (Type.getInstanceType(existingControl) === ScriptFX.UI._genericControl)) {
                delete domElement.control;
                ScriptFX.Application.current.unregisterDisposableObject(existingControl);
                this._events = existingControl.get__eventsInternal();
            }
        }
        Debug.assert(isUndefined(domElement[id]));
        domElement[id] = this;
    }
    if (id !== 'control') {
        var existingControl = domElement.control;
        if (!existingControl) {
            existingControl = new ScriptFX.UI._genericControl(domElement);
        }
    }
    var behaviors = domElement._behaviors;
    if (!behaviors) {
        behaviors = [];
        domElement._behaviors = behaviors;
    }
    behaviors.add(this);
}
ScriptFX.UI.Behavior.getBehavior = function ScriptFX_UI_Behavior$getBehavior(domElement, type) {
    Debug.assert(domElement);
    Debug.assert(type);
    var behaviors = domElement._behaviors;
    if (behaviors) {
        var $enum1 = behaviors.getEnumerator();
        while ($enum1.moveNext()) {
            var behavior = $enum1.get_current();
            if (type.isAssignableFrom(Type.getInstanceType(behavior))) {
                return behavior;
            }
        }
    }
    return null;
}
ScriptFX.UI.Behavior.getBehaviors = function ScriptFX_UI_Behavior$getBehaviors(domElement, type) {
    Debug.assert(domElement);
    var behaviors = domElement._behaviors;
    if (isNullOrUndefined(behaviors) || (!behaviors.length)) {
        return null;
    }
    if (!type) {
        return behaviors.clone();
    }
    return behaviors.filter(Delegate.create(null, function(behavior) {
        return type.isAssignableFrom(Type.getInstanceType(behavior));
    }));
}
ScriptFX.UI.Behavior.getNamedBehavior = function ScriptFX_UI_Behavior$getNamedBehavior(domElement, id) {
    Debug.assert(domElement);
    Debug.assert(!String.isNullOrEmpty(id));
    return domElement[id];
}
ScriptFX.UI.Behavior.prototype = {
    _domElement: null,
    _id: null,
    _domEvents: null,
    _events: null,
    _initializing: false,
    
    get_domElement: function ScriptFX_UI_Behavior$get_domElement() {
        return this._domElement;
    },
    
    get_domEvents: function ScriptFX_UI_Behavior$get_domEvents() {
        if (!this._domEvents) {
            this._domEvents = new ScriptFX.UI.DOMEventList(this._domElement);
        }
        return this._domEvents;
    },
    
    get_events: function ScriptFX_UI_Behavior$get_events() {
        if (!this._events) {
            this._events = new ScriptFX.EventList();
        }
        return this._events;
    },
    
    get__eventsInternal: function ScriptFX_UI_Behavior$get__eventsInternal() {
        return this._events;
    },
    
    get_isDisposed: function ScriptFX_UI_Behavior$get_isDisposed() {
        return (!this._domElement);
    },
    
    get_isInitializing: function ScriptFX_UI_Behavior$get_isInitializing() {
        return this._initializing;
    },
    
    add_propertyChanged: function ScriptFX_UI_Behavior$add_propertyChanged(value) {
        this.get_events().addHandler('PropertyChanged', value);
    },
    remove_propertyChanged: function ScriptFX_UI_Behavior$remove_propertyChanged(value) {
        this.get_events().removeHandler('PropertyChanged', value);
    },
    
    beginInitialize: function ScriptFX_UI_Behavior$beginInitialize() {
        this._initializing = true;
    },
    
    dispose: function ScriptFX_UI_Behavior$dispose() {
        if (this._domEvents) {
            this._domEvents.dispose();
        }
        if (this._domElement) {
            if (this._id) {
                if (ScriptFX.Application.current.get_isIE()) {
                    this._domElement.removeAttribute(this._id);
                }
                else {
                    delete this._domElement[this._id];
                }
            }
            var behaviors = this._domElement._behaviors;
            Debug.assert(behaviors);
            behaviors.remove(this);
            this._domElement = null;
            ScriptFX.Application.current.unregisterDisposableObject(this);
        }
    },
    
    endInitialize: function ScriptFX_UI_Behavior$endInitialize() {
        this._initializing = false;
    },
    
    raisePropertyChanged: function ScriptFX_UI_Behavior$raisePropertyChanged(propertyName) {
        var propChangedHandler = this.get_events().getHandler('PropertyChanged');
        if (propChangedHandler) {
            propChangedHandler.invoke(this, new ScriptFX.PropertyChangedEventArgs(propertyName));
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Color

ScriptFX.UI.Color = function ScriptFX_UI_Color(red, green, blue) {
    Debug.assert(red >= 0 && red <= 255);
    Debug.assert(green >= 0 && green <= 255);
    Debug.assert(blue >= 0 && blue <= 255);
    this._red = red;
    this._green = green;
    this._blue = blue;
}
ScriptFX.UI.Color.format = function ScriptFX_UI_Color$format(red, green, blue) {
    return String.format('#{0:X2}{1:X2}{2:X2}', red, green, blue);
}
ScriptFX.UI.Color.parse = function ScriptFX_UI_Color$parse(s) {
    if (String.isNullOrEmpty(s)) {
        return null;
    }
    if ((s.length === 7) && s.startsWith('#')) {
        var red = parseInt(s.substr(1, 2), 16);
        var green = parseInt(s.substr(3, 2), 16);
        var blue = parseInt(s.substr(5, 2), 16);
        return new ScriptFX.UI.Color(red, green, blue);
    }
    else if (s.startsWith('rgb(') && s.endsWith(')')) {
        var parts = s.substring(4, s.length - 1).split(',');
        if (parts.length === 3) {
            return new ScriptFX.UI.Color(parseInt(parts[0].trim()), parseInt(parts[1].trim()), parseInt(parts[2].trim()));
        }
    }
    return null;
}
ScriptFX.UI.Color.prototype = {
    _red: 0,
    _green: 0,
    _blue: 0,
    
    get_blue: function ScriptFX_UI_Color$get_blue() {
        return this._blue;
    },
    
    get_green: function ScriptFX_UI_Color$get_green() {
        return this._green;
    },
    
    get_red: function ScriptFX_UI_Color$get_red() {
        return this._red;
    },
    
    toString: function ScriptFX_UI_Color$toString() {
        return ScriptFX.UI.Color.format(this._red, this._green, this._blue);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Control

ScriptFX.UI.Control = function ScriptFX_UI_Control(domElement) {
    ScriptFX.UI.Control.constructBase(this, [ domElement, 'control' ]);
}
ScriptFX.UI.Control.getControl = function ScriptFX_UI_Control$getControl(domElement) {
    return ScriptFX.UI.Behavior.getNamedBehavior(domElement, 'control');
}
ScriptFX.UI.Control.prototype = {
    
    add_disposing: function ScriptFX_UI_Control$add_disposing(value) {
        this.get_events().addHandler('disposing', value);
    },
    remove_disposing: function ScriptFX_UI_Control$remove_disposing(value) {
        this.get_events().removeHandler('disposing', value);
    },
    
    dispose: function ScriptFX_UI_Control$dispose() {
        var element = this.get_domElement();
        if (element) {
            var disposingHandler = this.get_events().getHandler('disposing');
            if (disposingHandler) {
                disposingHandler.invoke(this, EventArgs.Empty);
            }
            var behaviors = ScriptFX.UI.Behavior.getBehaviors(element, null);
            Debug.assert((behaviors) && (behaviors.length > 0));
            if (behaviors.length > 1) {
                var $enum1 = behaviors.getEnumerator();
                while ($enum1.moveNext()) {
                    var behavior = $enum1.get_current();
                    if (behavior !== this) {
                        behavior.dispose();
                    }
                }
            }
        }
        ScriptFX.UI.Control.callBase(this, 'dispose');
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DOMEventList

ScriptFX.UI.DOMEventList = function ScriptFX_UI_DOMEventList(element) {
    Debug.assert(element);
    this._element = element;
    this._handlers = {};
}
ScriptFX.UI.DOMEventList.prototype = {
    _element: null,
    _handlers: null,
    
    attach: function ScriptFX_UI_DOMEventList$attach(eventName, handler) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        Debug.assert(handler);
        Debug.assert(!this.isAttached(eventName));
        this._element.attachEvent(eventName, handler);
        this._handlers[eventName] = handler;
    },
    
    detach: function ScriptFX_UI_DOMEventList$detach(eventName) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        var handler = this._handlers[eventName];
        if (handler) {
            this._element.detachEvent(eventName, handler);
            delete this._handlers[eventName];
            return true;
        }
        return false;
    },
    
    dispose: function ScriptFX_UI_DOMEventList$dispose() {
        if (this._element) {
            var $dict1 = this._handlers;
            for (var $key2 in $dict1) {
                var e = { key: $key2, value: $dict1[$key2] };
                this._element.detachEvent(e.key, e.value);
            }
            this._element = null;
            this._handlers = null;
        }
    },
    
    isAttached: function ScriptFX_UI_DOMEventList$isAttached(eventName) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        return (this._handlers[eventName]) ? true : false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropEventArgs

ScriptFX.UI.DragDropEventArgs = function ScriptFX_UI_DragDropEventArgs(dataObject) {
    ScriptFX.UI.DragDropEventArgs.constructBase(this);
    this._dataObject$1 = dataObject;
}
ScriptFX.UI.DragDropEventArgs.prototype = {
    _dataObject$1: null,
    
    get_dataObject: function ScriptFX_UI_DragDropEventArgs$get_dataObject() {
        return this._dataObject$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropManager

ScriptFX.UI.DragDropManager = function ScriptFX_UI_DragDropManager() {
}
ScriptFX.UI.DragDropManager.get_canDragDrop = function ScriptFX_UI_DragDropManager$get_canDragDrop() {
    return (ScriptFX.UI.DragDropManager._dragDropImplementation);
}
ScriptFX.UI.DragDropManager.get_supportsDataTransfer = function ScriptFX_UI_DragDropManager$get_supportsDataTransfer() {
    Debug.assert(ScriptFX.UI.DragDropManager.get_canDragDrop());
    return ScriptFX.UI.DragDropManager._dragDropImplementation.get_supportsDataTransfer();
}
ScriptFX.UI.DragDropManager.add_dragDropEnding = function ScriptFX_UI_DragDropManager$add_dragDropEnding(value) {
    ScriptFX.UI.DragDropManager._dragEndingHandler = Delegate.combine(ScriptFX.UI.DragDropManager._dragEndingHandler, value);
}
ScriptFX.UI.DragDropManager.remove_dragDropEnding = function ScriptFX_UI_DragDropManager$remove_dragDropEnding(value) {
    ScriptFX.UI.DragDropManager._dragEndingHandler = Delegate.remove(ScriptFX.UI.DragDropManager._dragEndingHandler, value);
}
ScriptFX.UI.DragDropManager.add_dragDropStarting = function ScriptFX_UI_DragDropManager$add_dragDropStarting(value) {
    ScriptFX.UI.DragDropManager._dragStartingHandler = Delegate.combine(ScriptFX.UI.DragDropManager._dragStartingHandler, value);
}
ScriptFX.UI.DragDropManager.remove_dragDropStarting = function ScriptFX_UI_DragDropManager$remove_dragDropStarting(value) {
    ScriptFX.UI.DragDropManager._dragStartingHandler = Delegate.remove(ScriptFX.UI.DragDropManager._dragStartingHandler, value);
}
ScriptFX.UI.DragDropManager._endDragDrop = function ScriptFX_UI_DragDropManager$_endDragDrop() {
    if (ScriptFX.UI.DragDropManager._dragEndingHandler) {
        ScriptFX.UI.DragDropManager._dragEndingHandler.invoke(null, new ScriptFX.UI.DragDropEventArgs(ScriptFX.UI.DragDropManager._currentDataObject));
    }
    ScriptFX.UI.DragDropManager._currentDataObject = null;
}
ScriptFX.UI.DragDropManager.registerDragDropImplementation = function ScriptFX_UI_DragDropManager$registerDragDropImplementation(dragDrop) {
    ScriptFX.UI.DragDropManager._dragDropImplementation = dragDrop;
}
ScriptFX.UI.DragDropManager.registerDropTarget = function ScriptFX_UI_DragDropManager$registerDropTarget(target) {
    ScriptFX.UI.DragDropManager._dropTargets.add(target);
}
ScriptFX.UI.DragDropManager.startDragDrop = function ScriptFX_UI_DragDropManager$startDragDrop(data, dragVisual, dragOffset, source, context) {
    Debug.assert(ScriptFX.UI.DragDropManager.get_canDragDrop());
    if (ScriptFX.UI.DragDropManager._currentDataObject) {
        return false;
    }
    var validDropTargets = [];
    var $enum1 = ScriptFX.UI.DragDropManager._dropTargets.getEnumerator();
    while ($enum1.moveNext()) {
        var dropTarget = $enum1.get_current();
        if (dropTarget.supportsDataObject(data)) {
            validDropTargets.add(dropTarget);
        }
    }
    if (!validDropTargets.length) {
        return false;
    }
    ScriptFX.UI.DragDropManager._currentDataObject = data;
    if (ScriptFX.UI.DragDropManager._dragStartingHandler) {
        ScriptFX.UI.DragDropManager._dragStartingHandler.invoke(null, new ScriptFX.UI.DragDropEventArgs(data));
    }
    ScriptFX.UI.DragDropManager._dragDropImplementation.dragDrop(new ScriptFX.UI._dragDropTracker(source), context, validDropTargets, dragVisual, dragOffset, ScriptFX.UI.DragDropManager._currentDataObject);
    return true;
}
ScriptFX.UI.DragDropManager.unregisterDropTarget = function ScriptFX_UI_DragDropManager$unregisterDropTarget(target) {
    ScriptFX.UI.DragDropManager._dropTargets.remove(target);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI._dragDropTracker

ScriptFX.UI._dragDropTracker = function ScriptFX_UI__dragDropTracker(actualSource) {
    this._actualSource = actualSource;
}
ScriptFX.UI._dragDropTracker.prototype = {
    _actualSource: null,
    
    get_domElement: function ScriptFX_UI__dragDropTracker$get_domElement() {
        return this._actualSource.get_domElement();
    },
    
    onDragStart: function ScriptFX_UI__dragDropTracker$onDragStart(context) {
        if (this._actualSource) {
            this._actualSource.onDragStart(context);
        }
    },
    
    onDrag: function ScriptFX_UI__dragDropTracker$onDrag(context) {
        if (this._actualSource) {
            this._actualSource.onDrag(context);
        }
    },
    
    onDragEnd: function ScriptFX_UI__dragDropTracker$onDragEnd(canceled, context) {
        if (this._actualSource) {
            this._actualSource.onDragEnd(canceled, context);
        }
        ScriptFX.UI.DragDropManager._endDragDrop();
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Element

ScriptFX.UI.Element = function ScriptFX_UI_Element() {
}
ScriptFX.UI.Element.addCSSClass = function ScriptFX_UI_Element$addCSSClass(element, className) {
    var cssClass = element.className;
    if ((' ' + cssClass + ' ').indexOf(' ' + className + ' ') < 0) {
        element.className = cssClass + ' ' + className;
    }
}
ScriptFX.UI.Element.containsCSSClass = function ScriptFX_UI_Element$containsCSSClass(element, className) {
    return element.className.split(' ').contains(className);
}
ScriptFX.UI.Element.getBounds = function ScriptFX_UI_Element$getBounds(element) {
    var location = ScriptFX.UI.Element.getLocation(element);
    return ScriptFX.UI.$create_Bounds(location.left, location.top, element.offsetWidth, element.offsetHeight);
}
ScriptFX.UI.Element.getLocation = function ScriptFX_UI_Element$getLocation(element) {
    var offsetX = 0;
    var offsetY = 0;
    for (var parentElement = element; parentElement; parentElement = parentElement.offsetParent) {
        offsetX += parentElement.offsetLeft;
        offsetY += parentElement.offsetTop;
    }
    return ScriptFX.UI.$create_Location(offsetX, offsetY);
}
ScriptFX.UI.Element.getSize = function ScriptFX_UI_Element$getSize(element) {
    return ScriptFX.UI.$create_Size(element.offsetWidth, element.offsetHeight);
}
ScriptFX.UI.Element.removeCSSClass = function ScriptFX_UI_Element$removeCSSClass(element, className) {
    var cssClass = ' ' + element.className + ' ';
    var index = cssClass.indexOf(' ' + className + ' ');
    if (index >= 0) {
        var newClass = cssClass.substr(0, index) + ' ' + cssClass.substr(index + className.length + 1);
        element.className = newClass;
    }
}
ScriptFX.UI.Element.setLocation = function ScriptFX_UI_Element$setLocation(element, location) {
    element.style.left = location.left + 'px';
    element.style.top = location.top + 'px';
}
ScriptFX.UI.Element.setSize = function ScriptFX_UI_Element$setSize(element, size) {
    element.style.width = size.width + 'px';
    element.style.height = size.height + 'px';
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.FadeEffect

ScriptFX.UI.FadeEffect = function ScriptFX_UI_FadeEffect(domElement, duration, opacity) {
    ScriptFX.UI.FadeEffect.constructBase(this, [ domElement, duration ]);
    this._opacity$2 = opacity;
}
ScriptFX.UI.FadeEffect.prototype = {
    _fadingIn$2: false,
    _opacity$2: 0,
    
    get_isFadingIn: function ScriptFX_UI_FadeEffect$get_isFadingIn() {
        return this._fadingIn$2;
    },
    
    fadeIn: function ScriptFX_UI_FadeEffect$fadeIn() {
        if (this.get_isPlaying()) {
            this.stop(ScriptFX.UI.AnimationStopState.complete);
        }
        this._fadingIn$2 = true;
        this.play();
    },
    
    fadeOut: function ScriptFX_UI_FadeEffect$fadeOut() {
        if (this.get_isPlaying()) {
            this.stop(ScriptFX.UI.AnimationStopState.complete);
        }
        this._fadingIn$2 = false;
        this.play();
    },
    
    performCleanup: function ScriptFX_UI_FadeEffect$performCleanup() {
        ScriptFX.UI.FadeEffect.callBase(this, 'performCleanup');
        if (!this._fadingIn$2) {
            this._setOpacity$2(0);
            this.get_domElement().style.display = 'none';
        }
    },
    
    performSetup: function ScriptFX_UI_FadeEffect$performSetup() {
        ScriptFX.UI.FadeEffect.callBase(this, 'performSetup');
        if (this._fadingIn$2) {
            this._setOpacity$2(0);
            this.get_domElement().style.display = '';
        }
    },
    
    performTweening: function ScriptFX_UI_FadeEffect$performTweening(frame) {
        if (this._fadingIn$2) {
            this._setOpacity$2(this._opacity$2 * frame);
        }
        else {
            this._setOpacity$2(this._opacity$2 * (1 - frame));
        }
    },
    
    _setOpacity$2: function ScriptFX_UI_FadeEffect$_setOpacity$2(opacity) {
        if (ScriptFX.Application.current.get_isIE()) {
            this.get_domElement().style.filter = 'alpha(opacity=' + (opacity * 100) + ')';
        }
        else {
            this.get_domElement().style.opacity = opacity.toString();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI._genericControl

ScriptFX.UI._genericControl = function ScriptFX_UI__genericControl(domElement) {
    ScriptFX.UI._genericControl.constructBase(this, [ domElement ]);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.OverlayBehavior

ScriptFX.UI.OverlayBehavior = function ScriptFX_UI_OverlayBehavior(domElement, options) {
    ScriptFX.UI.OverlayBehavior.constructBase(this, [ domElement, options.id ]);
    this._overlayElement$1 = document.createElement('div');
    this._overlayElement$1.className = options.cssClass;
    var overlayStyle = this._overlayElement$1.style;
    overlayStyle.display = 'none';
    overlayStyle.top = '0px';
    overlayStyle.left = '0px';
    overlayStyle.width = '100%';
    if (ScriptFX.Application.current.get_isIE() && (ScriptFX.Application.current.get_host().get_majorVersion() < 7)) {
        overlayStyle.position = 'absolute';
    }
    else {
        this._fixedOverlayElement$1 = true;
        overlayStyle.position = 'fixed';
        overlayStyle.height = '100%';
    }
    document.body.appendChild(this._overlayElement$1);
    if (options.fadeInOutInterval) {
        this._fade$1 = new ScriptFX.UI.FadeEffect(this._overlayElement$1, options.fadeInOutInterval, options.opacity);
        this._fade$1.set_easingFunction(Delegate.create(null, ScriptFX.UI.TimedAnimation.easeInOut));
        this._fade$1.add_stopped(Delegate.create(this, this._onAnimationStopped$1));
    }
}
ScriptFX.UI.OverlayBehavior.prototype = {
    _overlayElement$1: null,
    _fixedOverlayElement$1: false,
    _fade$1: null,
    _resizeHandler$1: null,
    _visible$1: false,
    
    get_isVisible: function ScriptFX_UI_OverlayBehavior$get_isVisible() {
        return this._visible$1;
    },
    
    add_visibilityChanged: function ScriptFX_UI_OverlayBehavior$add_visibilityChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1, value);
    },
    remove_visibilityChanged: function ScriptFX_UI_OverlayBehavior$remove_visibilityChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1, value);
    },
    
    dispose: function ScriptFX_UI_OverlayBehavior$dispose() {
        if (this._fade$1) {
            this._fade$1.dispose();
            this._fade$1 = null;
        }
        if (this._resizeHandler$1) {
            window.detachEvent('onresize', this._resizeHandler$1);
            this._resizeHandler$1 = null;
        }
        ScriptFX.UI.OverlayBehavior.callBase(this, 'dispose');
    },
    
    hide: function ScriptFX_UI_OverlayBehavior$hide() {
        if ((!this._visible$1) || this._fade$1.get_isPlaying()) {
            return;
        }
        if (this._resizeHandler$1) {
            window.detachEvent('onresize', this._resizeHandler$1);
            this._resizeHandler$1 = null;
        }
        if (this._fade$1) {
            this._fade$1.fadeOut();
        }
        else {
            this._overlayElement$1.style.display = 'none';
            this._visible$1 = false;
            var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
        }
    },
    
    _onAnimationStopped$1: function ScriptFX_UI_OverlayBehavior$_onAnimationStopped$1(sender, e) {
        this._visible$1 = this._fade$1.get_isFadingIn();
        var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
        }
    },
    
    _onWindowResize$1: function ScriptFX_UI_OverlayBehavior$_onWindowResize$1() {
        this._overlayElement$1.style.height = document.documentElement.offsetHeight + 'px';
    },
    
    show: function ScriptFX_UI_OverlayBehavior$show() {
        if (this._visible$1 || this._fade$1.get_isPlaying()) {
            return;
        }
        if (!this._fixedOverlayElement$1) {
            this._overlayElement$1.style.height = document.documentElement.offsetHeight + 'px';
            this._resizeHandler$1 = Delegate.create(this, this._onWindowResize$1);
            window.attachEvent('onresize', this._resizeHandler$1);
        }
        if (this._fade$1) {
            this._fade$1.fadeIn();
        }
        else {
            this._overlayElement$1.style.display = '';
            this._visible$1 = true;
            var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupBehavior

ScriptFX.UI.PopupBehavior = function ScriptFX_UI_PopupBehavior(domElement, options) {
    ScriptFX.UI.PopupBehavior.constructBase(this, [ domElement, options.id ]);
    this._options$1 = options;
    domElement.style.position = 'absolute';
    domElement.style.display = 'none';
}
ScriptFX.UI.PopupBehavior.prototype = {
    _options$1: null,
    _iframe$1: null,
    
    dispose: function ScriptFX_UI_PopupBehavior$dispose() {
        if (this.get_domElement()) {
            this.hide();
        }
        ScriptFX.UI.PopupBehavior.callBase(this, 'dispose');
    },
    
    hide: function ScriptFX_UI_PopupBehavior$hide() {
        this.get_domElement().style.display = 'none';
        if (this._iframe$1) {
            this._iframe$1.parentNode.removeChild(this._iframe$1);
            this._iframe$1 = null;
        }
    },
    
    show: function ScriptFX_UI_PopupBehavior$show() {
        var parentElement = this.get_domElement().offsetParent;
        if (!parentElement) {
            parentElement = document.documentElement;
        }
        this.get_domElement().style.display = 'block';
        var x = 0;
        var y = 0;
        var xOffsetDirection = 1;
        var yOffsetDirection = 1;
        var alignment = false;
        var parentBounds = ScriptFX.UI.Element.getBounds(parentElement);
        var elementBounds = ScriptFX.UI.Element.getBounds(this.get_domElement());
        var referenceBounds = ScriptFX.UI.Element.getBounds(this._options$1.referenceElement);
        var xDelta = referenceBounds.left - parentBounds.left;
        var yDelta = referenceBounds.top - parentBounds.top;
        switch (this._options$1.mode) {
            case ScriptFX.UI.PopupMode.center:
                x = Math.round(referenceBounds.width / 2 - elementBounds.width / 2);
                y = Math.round(referenceBounds.height / 2 - elementBounds.height / 2);
                break;
            case ScriptFX.UI.PopupMode.anchorTopLeft:
                x = 0;
                y = -elementBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorTopRight:
                x = referenceBounds.width - elementBounds.width;
                y = -elementBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorBottomRight:
                x = referenceBounds.width - elementBounds.width;
                y = referenceBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorBottomLeft:
                x = 0;
                y = referenceBounds.height;
                break;
            case ScriptFX.UI.PopupMode.alignTopLeft:
                x = referenceBounds.left;
                y = referenceBounds.top;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignTopRight:
                x = referenceBounds.left + referenceBounds.width - elementBounds.width;
                y = referenceBounds.top;
                xOffsetDirection = -1;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignBottomRight:
                x = referenceBounds.left + referenceBounds.width - elementBounds.width;
                y = referenceBounds.top + referenceBounds.height - elementBounds.height;
                xOffsetDirection = -1;
                yOffsetDirection = -1;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignBottomLeft:
                x = referenceBounds.left;
                y = referenceBounds.top + referenceBounds.height - elementBounds.height;
                yOffsetDirection = -1;
                alignment = true;
                break;
        }
        if (!alignment) {
            x += xDelta + this._options$1.xOffset;
            y += yDelta + this._options$1.yOffset;
        }
        else {
            x += xDelta + this._options$1.xOffset * xOffsetDirection;
            y += yDelta + this._options$1.yOffset * yOffsetDirection;
        }
        var docWidth = document.body.clientWidth;
        if (x + elementBounds.width > docWidth - 2) {
            x -= (x + elementBounds.width - docWidth + 2);
        }
        if (x < 0) {
            x = 2;
        }
        if (y < 0) {
            y = 2;
        }
        ScriptFX.UI.Element.setLocation(this.get_domElement(), ScriptFX.UI.$create_Location(x, y));
        var host = ScriptFX.Application.current.get_host();
        if ((host.get_name() === ScriptFX.HostName.IE) && (host.get_majorVersion() < 7)) {
            this._iframe$1 = document.createElement('IFRAME');
            this._iframe$1.src = 'javascript:false;';
            this._iframe$1.scrolling = 'no';
            this._iframe$1.style.position = 'absolute';
            this._iframe$1.style.display = 'block';
            this._iframe$1.style.border = 'none';
            this._iframe$1.style.filter = 'progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)';
            this._iframe$1.style.left = x + 'px';
            this._iframe$1.style.top = y + 'px';
            this._iframe$1.style.width = elementBounds.width + 'px';
            this._iframe$1.style.height = elementBounds.height + 'px';
            this._iframe$1.style.zIndex = 1;
            this.get_domElement().parentNode.insertBefore(this._iframe$1, this.get_domElement());
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.TimedAnimation

ScriptFX.UI.TimedAnimation = function ScriptFX_UI_TimedAnimation(domElement, duration) {
    ScriptFX.UI.TimedAnimation.constructBase(this, [ domElement ]);
    Debug.assert(duration > 0);
    this._duration$1 = duration;
}
ScriptFX.UI.TimedAnimation.easeIn = function ScriptFX_UI_TimedAnimation$easeIn(t) {
    return t * t;
}
ScriptFX.UI.TimedAnimation.easeInOut = function ScriptFX_UI_TimedAnimation$easeInOut(t) {
    t = t * 2;
    if (t < 1) {
        return t * t / 2;
    }
    return -((--t) * (t - 2) - 1) / 2;
}
ScriptFX.UI.TimedAnimation.easeOut = function ScriptFX_UI_TimedAnimation$easeOut(t) {
    return -t * (t - 2);
}
ScriptFX.UI.TimedAnimation.prototype = {
    _duration$1: 0,
    _easingFunction$1: null,
    _startTimeStamp$1: 0,
    
    get_duration: function ScriptFX_UI_TimedAnimation$get_duration() {
        return this._duration$1;
    },
    set_duration: function ScriptFX_UI_TimedAnimation$set_duration(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(this._duration$1 >= 0);
        this._duration$1 = value;
        return value;
    },
    
    get_easingFunction: function ScriptFX_UI_TimedAnimation$get_easingFunction() {
        return this._easingFunction$1;
    },
    set_easingFunction: function ScriptFX_UI_TimedAnimation$set_easingFunction(value) {
        Debug.assert(!this.get_isPlaying());
        this._easingFunction$1 = value;
        return value;
    },
    
    playCore: function ScriptFX_UI_TimedAnimation$playCore() {
        this._startTimeStamp$1 = (new Date()).getTime();
        this.progressCore(false, this._startTimeStamp$1);
    },
    
    progressCore: function ScriptFX_UI_TimedAnimation$progressCore(startRepetition, timeStamp) {
        var frame = 0;
        var completed = false;
        if (!startRepetition) {
            frame = (timeStamp - this._startTimeStamp$1) / this._duration$1;
            if (!this.get_isReversed()) {
                completed = (frame >= 1);
                frame = Math.min(1, frame);
            }
            else {
                frame = 1 - frame;
                completed = (frame <= 0);
                frame = Math.max(0, frame);
            }
            if ((!completed) && (this._easingFunction$1)) {
                frame = this._easingFunction$1.invoke(frame);
            }
        }
        else {
            this._startTimeStamp$1 = timeStamp;
            if (this.get_isReversed()) {
                frame = 1;
            }
        }
        this.performTweening(frame);
        return completed;
    },
    
    stopCore: function ScriptFX_UI_TimedAnimation$stopCore(completed, stopState) {
        if (!completed) {
            if (stopState === ScriptFX.UI.AnimationStopState.complete) {
                this.performTweening(1);
            }
            else if (stopState === ScriptFX.UI.AnimationStopState.revert) {
                this.performTweening(0);
            }
        }
    }
}


ScriptFX.Application.createClass('ScriptFX.Application', null, IServiceProvider, IServiceContainer, ScriptFX.IEventManager);
ScriptFX.CancelEventArgs.createClass('ScriptFX.CancelEventArgs', EventArgs);
ScriptFX.CollectionChangedEventArgs.createClass('ScriptFX.CollectionChangedEventArgs', EventArgs);
ScriptFX.ApplicationUnloadingEventArgs.createClass('ScriptFX.ApplicationUnloadingEventArgs', EventArgs);
ScriptFX.HistoryManager.createClass('ScriptFX.HistoryManager', null, IDisposable);
ScriptFX.HistoryEventArgs.createClass('ScriptFX.HistoryEventArgs', EventArgs);
ScriptFX.HostInfo.createClass('ScriptFX.HostInfo');
ScriptFX.EventList.createClass('ScriptFX.EventList');
ScriptFX.JSON.createClass('ScriptFX.JSON');
ScriptFX.PropertyChangedEventArgs.createClass('ScriptFX.PropertyChangedEventArgs', EventArgs);
ScriptFX.ObservableCollection.createClass('ScriptFX.ObservableCollection', null, IDisposable, IArray, IEnumerable, ScriptFX.INotifyCollectionChanged);
ScriptFX.Net.HTTPRequest.createClass('ScriptFX.Net.HTTPRequest', null, IDisposable);
ScriptFX.Net.HTTPRequestManager.createClass('ScriptFX.Net.HTTPRequestManager');
ScriptFX.Net.HTTPTransport.createClass('ScriptFX.Net.HTTPTransport', null, IDisposable);
ScriptFX.Net.PostHTTPRequestEventArgs.createClass('ScriptFX.Net.PostHTTPRequestEventArgs', EventArgs);
ScriptFX.Net.PreHTTPRequestEventArgs.createClass('ScriptFX.Net.PreHTTPRequestEventArgs', EventArgs);
ScriptFX.Net._xmlhttpResponse.createClass('ScriptFX.Net._xmlhttpResponse', null, ScriptFX.Net.IHTTPResponse);
ScriptFX.Net._xmlhttpTransport.createClass('ScriptFX.Net._xmlhttpTransport', ScriptFX.Net.HTTPTransport);
ScriptFX.UI.Animation.createClass('ScriptFX.UI.Animation', null, IDisposable);
ScriptFX.UI.AnimationManager.createClass('ScriptFX.UI.AnimationManager');
ScriptFX.UI.AnimationSequence.createClass('ScriptFX.UI.AnimationSequence', ScriptFX.UI.Animation);
ScriptFX.UI.Behavior.createClass('ScriptFX.UI.Behavior', null, IDisposable, ScriptFX.ISupportInitialize, ScriptFX.INotifyPropertyChanged);
ScriptFX.UI.Color.createClass('ScriptFX.UI.Color');
ScriptFX.UI.Control.createClass('ScriptFX.UI.Control', ScriptFX.UI.Behavior, ScriptFX.INotifyDisposing);
ScriptFX.UI.DOMEventList.createClass('ScriptFX.UI.DOMEventList', null, IDisposable);
ScriptFX.UI.DragDropEventArgs.createClass('ScriptFX.UI.DragDropEventArgs', EventArgs);
ScriptFX.UI.DragDropManager.createClass('ScriptFX.UI.DragDropManager');
ScriptFX.UI._dragDropTracker.createClass('ScriptFX.UI._dragDropTracker', null, ScriptFX.UI.IDragSource);
ScriptFX.UI.Element.createClass('ScriptFX.UI.Element');
ScriptFX.UI.TimedAnimation.createClass('ScriptFX.UI.TimedAnimation', ScriptFX.UI.Animation);
ScriptFX.UI.FadeEffect.createClass('ScriptFX.UI.FadeEffect', ScriptFX.UI.TimedAnimation);
ScriptFX.UI._genericControl.createClass('ScriptFX.UI._genericControl', ScriptFX.UI.Control);
ScriptFX.UI.OverlayBehavior.createClass('ScriptFX.UI.OverlayBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.PopupBehavior.createClass('ScriptFX.UI.PopupBehavior', ScriptFX.UI.Behavior);
ScriptFX.Application.current = new ScriptFX.Application();
ScriptFX.JSON._dateRegex = null;
ScriptFX.Net.HTTPRequestManager.__requestInvoking = null;
ScriptFX.Net.HTTPRequestManager.__requestInvoked = null;
ScriptFX.Net.HTTPRequestManager._timeoutInterval = 0;
ScriptFX.Net.HTTPRequestManager._activeRequests = [];
ScriptFX.Net.HTTPRequestManager._appIdleHandler = null;
ScriptFX.UI.AnimationManager._fps = 100;
ScriptFX.UI.AnimationManager._activeAnimations = null;
ScriptFX.UI.AnimationManager._timerCookie = 0;
ScriptFX.UI.DragDropManager._dragDropImplementation = null;
ScriptFX.UI.DragDropManager._dropTargets = [];
ScriptFX.UI.DragDropManager._dragStartingHandler = null;
ScriptFX.UI.DragDropManager._dragEndingHandler = null;
ScriptFX.UI.DragDropManager._currentDataObject = null;
ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1 = 'visibilityChanged';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2006, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.Reflection');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MemberInfoType

ScriptFX.Reflection.MemberInfoType = function() { };
ScriptFX.Reflection.MemberInfoType.prototype = {
    Field: 0, 
    Method: 1, 
    Property: 2, 
    Event: 3
}
ScriptFX.Reflection.MemberInfoType.createEnum('ScriptFX.Reflection.MemberInfoType', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.TypeInfoType

ScriptFX.Reflection.TypeInfoType = function() { };
ScriptFX.Reflection.TypeInfoType.prototype = {
    Class: 0, 
    Interface: 1, 
    Enumeration: 2, 
    FlagsEnumeration: 3
}
ScriptFX.Reflection.TypeInfoType.createEnum('ScriptFX.Reflection.TypeInfoType', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.ParameterInfo

ScriptFX.Reflection.ParameterInfo = function ScriptFX_Reflection_ParameterInfo(name) {
    this._name = name;
}
ScriptFX.Reflection.ParameterInfo.prototype = {
    _name: null,
    
    get_name: function ScriptFX_Reflection_ParameterInfo$get_name() {
        return this._name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.FieldInfo

ScriptFX.Reflection.FieldInfo = function ScriptFX_Reflection_FieldInfo(name, fieldType, isStatic) {
    ScriptFX.Reflection.FieldInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Field, name, fieldType, isStatic ]);
}
ScriptFX.Reflection.FieldInfo.prototype = {
    _value$1: null,
    
    get_value: function ScriptFX_Reflection_FieldInfo$get_value() {
        return this._value$1;
    },
    
    _initialize: function ScriptFX_Reflection_FieldInfo$_initialize(value) {
        this._value$1 = value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.Reflector

ScriptFX.Reflection.Reflector = function ScriptFX_Reflection_Reflector() {
}
ScriptFX.Reflection.Reflector.getGlobalTypes = function ScriptFX_Reflection_Reflector$getGlobalTypes() {
    if (!ScriptFX.Reflection.Reflector._globalTypes) {
        var globalTypes = [];
        var classTypes = [ Object, Boolean, Number, String, Date, Array, Function, RegExp, StringBuilder, EventArgs ];
        var interfaceTypes = [ IDisposable, IEnumerable, IEnumerator, IArray ];
        var $enum1 = classTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var type = $enum1.get_current();
            var typeInfo = new ScriptFX.Reflection.TypeInfo(null, ScriptFX.Reflection.TypeInfoType.Class, type.get_name());
            typeInfo._initialize(type);
            globalTypes.add(typeInfo);
        }
        var $enum2 = interfaceTypes.getEnumerator();
        while ($enum2.moveNext()) {
            var type = $enum2.get_current();
            var typeInfo = new ScriptFX.Reflection.TypeInfo(null, ScriptFX.Reflection.TypeInfoType.Interface, type.get_name());
            typeInfo._initialize(type);
            globalTypes.add(typeInfo);
        }
        ScriptFX.Reflection.Reflector._globalTypes = globalTypes;
    }
    return ScriptFX.Reflection.Reflector._globalTypes;
}
ScriptFX.Reflection.Reflector.getNamespaces = function ScriptFX_Reflection_Reflector$getNamespaces() {
    if (!ScriptFX.Reflection.Reflector._namespaces) {
        var namespaceTable = window.__namespaces;
        ScriptFX.Reflection.Reflector._namespaces = [];
        var $dict1 = namespaceTable;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            ScriptFX.Reflection.Reflector._namespaces.add(new ScriptFX.Reflection.NamespaceInfo(entry.key, entry.value));
        }
    }
    return ScriptFX.Reflection.Reflector._namespaces;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.PropertyInfo

ScriptFX.Reflection.PropertyInfo = function ScriptFX_Reflection_PropertyInfo(name, propertyType, isStatic) {
    ScriptFX.Reflection.PropertyInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Property, name, propertyType, isStatic ]);
}
ScriptFX.Reflection.PropertyInfo.prototype = {
    _getAccessor$1: null,
    _setAccessor$1: null,
    
    get_getAccessor: function ScriptFX_Reflection_PropertyInfo$get_getAccessor() {
        return this._getAccessor$1;
    },
    
    get_isReadOnly: function ScriptFX_Reflection_PropertyInfo$get_isReadOnly() {
        return (!this._setAccessor$1);
    },
    
    get_setAccessor: function ScriptFX_Reflection_PropertyInfo$get_setAccessor() {
        return this._setAccessor$1;
    },
    
    _initialize: function ScriptFX_Reflection_PropertyInfo$_initialize(getAccessor, setAccessor) {
        this._getAccessor$1 = getAccessor;
        this._setAccessor$1 = setAccessor;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.EventInfo

ScriptFX.Reflection.EventInfo = function ScriptFX_Reflection_EventInfo(name, argsType, isStatic) {
    ScriptFX.Reflection.EventInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Event, name, argsType, isStatic ]);
}
ScriptFX.Reflection.EventInfo.prototype = {
    _addAccessor$1: null,
    _removeAccessor$1: null,
    
    get_addAccessor: function ScriptFX_Reflection_EventInfo$get_addAccessor() {
        return this._addAccessor$1;
    },
    
    get_removeAccessor: function ScriptFX_Reflection_EventInfo$get_removeAccessor() {
        return this._removeAccessor$1;
    },
    
    _initialialize: function ScriptFX_Reflection_EventInfo$_initialialize(addAccessor, removeAccessor) {
        this._addAccessor$1 = addAccessor;
        this._removeAccessor$1 = removeAccessor;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MethodInfo

ScriptFX.Reflection.MethodInfo = function ScriptFX_Reflection_MethodInfo(name, returnType, isStatic) {
    ScriptFX.Reflection.MethodInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Method, name, returnType, isStatic ]);
}
ScriptFX.Reflection.MethodInfo.prototype = {
    _isConstructor$1: false,
    _method$1: null,
    _parameters$1: null,
    
    get_constructor: function ScriptFX_Reflection_MethodInfo$get_constructor() {
        return this._isConstructor$1;
    },
    
    get_method: function ScriptFX_Reflection_MethodInfo$get_method() {
        return this._method$1;
    },
    
    get_parameters: function ScriptFX_Reflection_MethodInfo$get_parameters() {
        return this._parameters$1;
    },
    
    _initialize: function ScriptFX_Reflection_MethodInfo$_initialize(isConstructor, method) {
        this._isConstructor$1 = isConstructor;
        this._method$1 = method;
        var sourceCode = method.toString();
        var indexOpenParen = sourceCode.indexOf('(');
        var indexCloseParen = sourceCode.indexOf(')');
        var signature = sourceCode.substring(indexOpenParen + 1, indexCloseParen).trim();
        var parameters = [];
        if (signature.length) {
            var paramNames = signature.split(',');
            for (var i = 0; i < paramNames.length; i++) {
                parameters[i] = new ScriptFX.Reflection.ParameterInfo(paramNames[i].trim());
            }
        }
        this._parameters$1 = parameters;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MemberInfo

ScriptFX.Reflection.MemberInfo = function ScriptFX_Reflection_MemberInfo(memberType, name, type, isStatic) {
    this._memberType = memberType;
    this._name = name;
    this._type = type;
    this._isStatic = isStatic;
}
ScriptFX.Reflection.MemberInfo.prototype = {
    _memberType: 0,
    _name: null,
    _type: null,
    _isStatic: false,
    
    get_associatedType: function ScriptFX_Reflection_MemberInfo$get_associatedType() {
        return this._type;
    },
    
    get_isPublic: function ScriptFX_Reflection_MemberInfo$get_isPublic() {
        return (!this._name.startsWith('_')) && (!this._name.startsWith('$'));
    },
    
    get_isStatic: function ScriptFX_Reflection_MemberInfo$get_isStatic() {
        return this._isStatic;
    },
    
    get_memberType: function ScriptFX_Reflection_MemberInfo$get_memberType() {
        return this._memberType;
    },
    
    get_name: function ScriptFX_Reflection_MemberInfo$get_name() {
        return this._name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.NamespaceInfo

ScriptFX.Reflection.NamespaceInfo = function ScriptFX_Reflection_NamespaceInfo(name, typeTable) {
    this._name = name;
    this._typeTable = typeTable;
}
ScriptFX.Reflection.NamespaceInfo.prototype = {
    _name: null,
    _typeTable: null,
    _types: null,
    
    get_name: function ScriptFX_Reflection_NamespaceInfo$get_name() {
        return this._name;
    },
    
    getTypes: function ScriptFX_Reflection_NamespaceInfo$getTypes() {
        if (!this._types) {
            this._types = [];
            var $dict1 = this._typeTable;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var typeInfo = null;
                var type = entry.value;
                if (Type.isClass(type)) {
                    typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Class, entry.key);
                }
                else if (Type.isInterface(type)) {
                    typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Interface, entry.key);
                }
                else if (Type.isEnum(type)) {
                    if (Type.isFlagsEnum(type)) {
                        typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.FlagsEnumeration, entry.key);
                    }
                    else {
                        typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Enumeration, entry.key);
                    }
                }
                if (typeInfo) {
                    typeInfo._initialize(type);
                    this._types.add(typeInfo);
                }
            }
        }
        return this._types;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.TypeInfo

ScriptFX.Reflection.TypeInfo = function ScriptFX_Reflection_TypeInfo(parent, typeType, name) {
    this._parent = parent;
    this._typeType = typeType;
    this._name = name;
}
ScriptFX.Reflection.TypeInfo.prototype = {
    _parent: null,
    _typeType: 0,
    _type: null,
    _name: null,
    
    get_baseType: function ScriptFX_Reflection_TypeInfo$get_baseType() {
        return null;
    },
    
    get_fullName: function ScriptFX_Reflection_TypeInfo$get_fullName() {
        if (this._parent) {
            return this._parent.get_name() + '.' + this.get_name();
        }
        return this.get_name();
    },
    
    get_interfaces: function ScriptFX_Reflection_TypeInfo$get_interfaces() {
        return null;
    },
    
    get_isGlobal: function ScriptFX_Reflection_TypeInfo$get_isGlobal() {
        return (!this._parent);
    },
    
    get_isPublic: function ScriptFX_Reflection_TypeInfo$get_isPublic() {
        return (!this._name.startsWith('_')) && (!this._name.startsWith('$'));
    },
    
    get_name: function ScriptFX_Reflection_TypeInfo$get_name() {
        return this._name;
    },
    
    get_typeType: function ScriptFX_Reflection_TypeInfo$get_typeType() {
        return this._typeType;
    },
    
    _initialize: function ScriptFX_Reflection_TypeInfo$_initialize(type) {
        this._type = type;
    }
}


ScriptFX.Reflection.ParameterInfo.createClass('ScriptFX.Reflection.ParameterInfo');
ScriptFX.Reflection.MemberInfo.createClass('ScriptFX.Reflection.MemberInfo');
ScriptFX.Reflection.FieldInfo.createClass('ScriptFX.Reflection.FieldInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.Reflector.createClass('ScriptFX.Reflection.Reflector');
ScriptFX.Reflection.PropertyInfo.createClass('ScriptFX.Reflection.PropertyInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.EventInfo.createClass('ScriptFX.Reflection.EventInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.MethodInfo.createClass('ScriptFX.Reflection.MethodInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.NamespaceInfo.createClass('ScriptFX.Reflection.NamespaceInfo');
ScriptFX.Reflection.TypeInfo.createClass('ScriptFX.Reflection.TypeInfo');
ScriptFX.Reflection.Reflector._globalTypes = null;
ScriptFX.Reflection.Reflector._namespaces = null;

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.UI');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteOptions

ScriptFX.UI.$create_AutoCompleteOptions = function ScriptFX_UI_AutoCompleteOptions(service) {
    var $o = { };
    Debug.assert(!String.isNullOrEmpty(service), 'service parameter must not be empty.');
    $o.service = service;
    $o.id = null;
    $o.itemCount = 10;
    $o.itemLookupDelay = 500;
    $o.minimumPrefixLength = 3;
    $o.cssClass = 'autoComplete';
    $o.itemCSSClass = 'autoCompleteItem';
    $o.selectedItemCSSClass = 'autoCompleteSelectedItem';
    $o.xOffset = 0;
    $o.yOffset = 0;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.EnterKeyOptions

ScriptFX.UI.$create_EnterKeyOptions = function ScriptFX_UI_EnterKeyOptions(clickTarget) {
    var $o = { };
    Debug.assert(clickTarget);
    $o.clickTarget = clickTarget;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.WatermarkOptions

ScriptFX.UI.$create_WatermarkOptions = function ScriptFX_UI_WatermarkOptions(watermarkText, watermarkCssClass) {
    var $o = { };
    $o.watermarkText = watermarkText;
    $o.watermarkCssClass = watermarkCssClass;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteBehavior

ScriptFX.UI.AutoCompleteBehavior = function ScriptFX_UI_AutoCompleteBehavior(domElement, options) {
    ScriptFX.UI.AutoCompleteBehavior.constructBase(this, [ domElement, options.id ]);
    this._options$1 = options;
    this._selectedItemIndex$1 = -1;
    domElement.autocomplete = 'off';
    var events = this.get_domEvents();
    events.attach('onfocus', Delegate.create(this, this._onTextBoxFocus$1));
    events.attach('onblur', Delegate.create(this, this._onTextBoxBlur$1));
    events.attach('onkeydown', Delegate.create(this, this._onTextBoxKeyDown$1));
}
ScriptFX.UI.AutoCompleteBehavior.prototype = {
    _options$1: null,
    _arguments$1: null,
    _dropDown$1: null,
    _dropDownPopup$1: null,
    _dropDownEvents$1: null,
    _dropDownVisible$1: false,
    _selectedItemIndex$1: 0,
    _itemCache$1: null,
    _timerID$1: 0,
    _currentPrefix$1: null,
    _itemRequest$1: null,
    
    get_arguments: function ScriptFX_UI_AutoCompleteBehavior$get_arguments() {
        if (!this._arguments$1) {
            this._arguments$1 = {};
        }
        return this._arguments$1;
    },
    
    add_itemDisplay: function ScriptFX_UI_AutoCompleteBehavior$add_itemDisplay(value) {
        this.get_events().addHandler('itemDisplay', value);
    },
    remove_itemDisplay: function ScriptFX_UI_AutoCompleteBehavior$remove_itemDisplay(value) {
        this.get_events().removeHandler('itemDisplay', value);
    },
    
    add_itemSelected: function ScriptFX_UI_AutoCompleteBehavior$add_itemSelected(value) {
        this.get_events().addHandler('itemSelected', value);
    },
    remove_itemSelected: function ScriptFX_UI_AutoCompleteBehavior$remove_itemSelected(value) {
        this.get_events().removeHandler('itemSelected', value);
    },
    
    add_requestingItems: function ScriptFX_UI_AutoCompleteBehavior$add_requestingItems(value) {
        this.get_events().addHandler('requestingItems', value);
    },
    remove_requestingItems: function ScriptFX_UI_AutoCompleteBehavior$remove_requestingItems(value) {
        this.get_events().removeHandler('requestingItems', value);
    },
    
    _abortRequest$1: function ScriptFX_UI_AutoCompleteBehavior$_abortRequest$1() {
        if (this._itemRequest$1) {
            this._itemRequest$1.abort();
            this._itemRequest$1 = null;
        }
    },
    
    clearCache: function ScriptFX_UI_AutoCompleteBehavior$clearCache() {
        this._itemCache$1 = null;
    },
    
    _createDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_createDropDown$1() {
        Debug.assert(!this._dropDown$1);
        this._dropDown$1 = document.createElement('DIV');
        if (this._options$1.cssClass) {
            this._dropDown$1.className = this._options$1.cssClass;
        }
        this._dropDown$1.unselectable = 'unselectable';
        document.body.appendChild(this._dropDown$1);
        this._dropDownEvents$1 = new ScriptFX.UI.DOMEventList(this._dropDown$1);
        this._dropDownEvents$1.attach('onmousedown', Delegate.create(this, this._onDropDownMouseDown$1));
        this._dropDownEvents$1.attach('onmouseup', Delegate.create(this, this._onDropDownMouseUp$1));
        this._dropDownEvents$1.attach('onmouseover', Delegate.create(this, this._onDropDownMouseOver$1));
        var options = ScriptFX.UI.$create_PopupOptions(this.get_domElement(), ScriptFX.UI.PopupMode.anchorBottomLeft);
        options.xOffset = this._options$1.xOffset;
        options.yOffset = -1 + this._options$1.yOffset;
        this._dropDownPopup$1 = new ScriptFX.UI.PopupBehavior(this._dropDown$1, options);
    },
    
    dispose: function ScriptFX_UI_AutoCompleteBehavior$dispose() {
        this._stopTimer$1();
        this._abortRequest$1();
        if (this._dropDown$1) {
            this._dropDownEvents$1.dispose();
            this._dropDownEvents$1 = null;
            this._dropDownPopup$1.dispose();
            this._dropDownPopup$1 = null;
            document.body.removeChild(this._dropDown$1);
            this._dropDown$1 = null;
            this._dropDownVisible$1 = false;
        }
        ScriptFX.UI.AutoCompleteBehavior.callBase(this, 'dispose');
    },
    
    _getDropDownItem$1: function ScriptFX_UI_AutoCompleteBehavior$_getDropDownItem$1(element) {
        while ((element) && (element !== this._dropDown$1)) {
            if (!isUndefined(element.__item)) {
                return element;
            }
            element = element.parentNode;
        }
        return null;
    },
    
    _hideDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_hideDropDown$1() {
        if (this._dropDownVisible$1) {
            this._dropDownVisible$1 = false;
            this._dropDownPopup$1.hide();
            this._selectedItemIndex$1 = -1;
        }
    },
    
    _highlightDropDownItem$1: function ScriptFX_UI_AutoCompleteBehavior$_highlightDropDownItem$1(itemElement) {
        if (this._options$1.selectedItemCSSClass) {
            ScriptFX.UI.Element.addCSSClass(itemElement, this._options$1.selectedItemCSSClass);
        }
    },
    
    _onDropDownMouseDown$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseDown$1() {
        var element = this._getDropDownItem$1(window.event.srcElement);
        if (element) {
            var item = element.__item;
            var index = element.__index;
            this._updateTextBox$1(item, index);
        }
    },
    
    _onDropDownMouseUp$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseUp$1() {
        this.get_domElement().focus();
    },
    
    _onDropDownMouseOver$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseOver$1() {
        var element = this._getDropDownItem$1(window.event.srcElement);
        if (this._selectedItemIndex$1 !== -1) {
            this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
            this._selectedItemIndex$1 = -1;
        }
        if (element) {
            var selectedItemIndex = element.__index;
            if (!isUndefined(this._selectedItemIndex$1)) {
                this._selectedItemIndex$1 = selectedItemIndex;
                this._highlightDropDownItem$1(element);
                return;
            }
        }
    },
    
    _onRequestComplete$1: function ScriptFX_UI_AutoCompleteBehavior$_onRequestComplete$1(request, context) {
        if ((request !== this._itemRequest$1) || (request.get_state() !== ScriptFX.Net.HTTPRequestState.completed) || (request.get_response().get_statusCode() !== ScriptFX.Net.HTTPStatusCode.OK)) {
            return;
        }
        var parameters = context;
        var prefixText = parameters['prefix'];
        var cacheKey = prefixText;
        if (this.get_events().getHandler('requestingItems')) {
            delete parameters.prefix;
            delete parameters.count;
            cacheKey += ScriptFX.JSON.serialize(parameters);
        }
        var items = request.get_response().getObject();
        this._updateDropDown$1(prefixText, items, cacheKey);
    },
    
    _onTextBoxBlur$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxBlur$1() {
        this._stopTimer$1();
        this._abortRequest$1();
        this._hideDropDown$1();
    },
    
    _onTextBoxFocus$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxFocus$1() {
        this._startTimer$1();
    },
    
    _onTextBoxKeyDown$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxKeyDown$1() {
        this._stopTimer$1();
        var e = window.event;
        if (this._dropDownVisible$1) {
            switch (e.keyCode) {
                case ScriptFX.UI.Key.escape:
                    this._hideDropDown$1();
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.up:
                    if (this._selectedItemIndex$1 > 0) {
                        this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                        this._selectedItemIndex$1--;
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    else if (this._selectedItemIndex$1 === -1) {
                        this._selectedItemIndex$1 = this._dropDown$1.childNodes.length - 1;
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.down:
                    if (this._selectedItemIndex$1 < (this._dropDown$1.childNodes.length - 1)) {
                        if (this._selectedItemIndex$1 === -1) {
                            this._selectedItemIndex$1 = 0;
                        }
                        else {
                            this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                            this._selectedItemIndex$1++;
                        }
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.enter:
                    if (this._selectedItemIndex$1 !== -1) {
                        var item = this._dropDown$1.childNodes[this._selectedItemIndex$1].__item;
                        var index = this._dropDown$1.childNodes[this._selectedItemIndex$1].__index;
                        this._updateTextBox$1(item, index);
                    }
                    e.returnValue = false;
                    break;
            }
        }
        if (e.keyCode !== ScriptFX.UI.Key.tab) {
            this._startTimer$1();
        }
    },
    
    _onTimerTick$1: function ScriptFX_UI_AutoCompleteBehavior$_onTimerTick$1() {
        this._timerID$1 = 0;
        this._abortRequest$1();
        var text = (this.get_domElement()).value;
        if (text === this._currentPrefix$1) {
            return;
        }
        if (text.trim().length < this._options$1.minimumPrefixLength) {
            this._updateDropDown$1(null, null, null);
            return;
        }
        this._currentPrefix$1 = text;
        var requestHandler = this.get_events().getHandler('requestingItems');
        if (requestHandler) {
            var e = new ScriptFX.UI.AutoCompleteRequestEventArgs(text);
            requestHandler.invoke(this, e);
            var items = e.get__items();
            if (items) {
                this._updateDropDown$1(text, items, null);
                return;
            }
        }
        if (this._itemCache$1) {
            var cacheKey = text;
            if (this._arguments$1) {
                delete this._arguments$1.prefix;
                delete this._arguments$1.count;
                cacheKey += ScriptFX.JSON.serialize(this._arguments$1);
            }
            var items = this._itemCache$1[cacheKey];
            if (items) {
                this._updateDropDown$1(text, items, null);
                return;
            }
        }
        var parameters;
        if (this._arguments$1) {
            parameters = this._arguments$1;
        }
        else {
            parameters = {};
        }
        parameters['prefix'] = text;
        parameters['count'] = this._options$1.itemCount;
        this._itemRequest$1 = ScriptFX.Net.HTTPRequest.createRequest(ScriptFX.Net.HTTPRequest.createURI(this._options$1.service, parameters), ScriptFX.Net.HTTPVerb.GET);
        this._itemRequest$1.invoke(Delegate.create(this, this._onRequestComplete$1), parameters);
    },
    
    _showDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_showDropDown$1() {
        if (!this._dropDownVisible$1) {
            this._dropDownVisible$1 = true;
            this._dropDown$1.style.width = (this.get_domElement().offsetWidth - 2) + 'px';
            this._dropDownPopup$1.show();
        }
    },
    
    _startTimer$1: function ScriptFX_UI_AutoCompleteBehavior$_startTimer$1() {
        if (!this._timerID$1) {
            this._timerID$1 = window.setTimeout(Delegate.create(this, this._onTimerTick$1), this._options$1.itemLookupDelay);
        }
    },
    
    _stopTimer$1: function ScriptFX_UI_AutoCompleteBehavior$_stopTimer$1() {
        if (this._timerID$1) {
            window.clearTimeout(this._timerID$1);
            this._timerID$1 = 0;
        }
    },
    
    _unhighlightItem$1: function ScriptFX_UI_AutoCompleteBehavior$_unhighlightItem$1(itemElement) {
        if (this._options$1.selectedItemCSSClass) {
            ScriptFX.UI.Element.removeCSSClass(itemElement, this._options$1.selectedItemCSSClass);
        }
    },
    
    _updateDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_updateDropDown$1(prefixText, items, cacheKey) {
        var itemCount = 0;
        if (items) {
            itemCount = items.length;
        }
        if ((cacheKey) && (itemCount)) {
            if (!this._itemCache$1) {
                this._itemCache$1 = {};
            }
            this._itemCache$1[cacheKey] = items;
        }
        if (!this._dropDown$1) {
            this._createDropDown$1();
        }
        this._dropDown$1.innerHTML = '';
        this._selectedItemIndex$1 = -1;
        if (itemCount) {
            for (var i = 0; i < itemCount; i++) {
                var itemElement = document.createElement('DIV');
                if (this._options$1.itemCSSClass) {
                    itemElement.className = this._options$1.itemCSSClass;
                }
                var item = items[i];
                var text = item;
                var displayHandler = this.get_events().getHandler('itemDisplay');
                if (displayHandler) {
                    var e = new ScriptFX.UI.AutoCompleteItemEventArgs(item, i);
                    displayHandler.invoke(this, e);
                    text = e.get_text();
                    if (!text) {
                        text = item;
                    }
                }
                itemElement.innerHTML = text;
                itemElement.__index = i;
                itemElement.__item = items[i];
                this._dropDown$1.appendChild(itemElement);
            }
            this._showDropDown$1();
        }
        else {
            this._hideDropDown$1();
        }
    },
    
    _updateTextBox$1: function ScriptFX_UI_AutoCompleteBehavior$_updateTextBox$1(item, index) {
        this._stopTimer$1();
        this._hideDropDown$1();
        var text = null;
        var selectedHandler = this.get_events().getHandler('itemSelected');
        if (selectedHandler) {
            var e = new ScriptFX.UI.AutoCompleteItemEventArgs(item, index);
            selectedHandler.invoke(this, e);
            text = e.get_text();
        }
        if (!text) {
            text = item;
        }
        this._currentPrefix$1 = text;
        (this.get_domElement()).value = text;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteItemEventArgs

ScriptFX.UI.AutoCompleteItemEventArgs = function ScriptFX_UI_AutoCompleteItemEventArgs(item, index) {
    ScriptFX.UI.AutoCompleteItemEventArgs.constructBase(this);
    this._item$1 = item;
    this._index$1 = index;
}
ScriptFX.UI.AutoCompleteItemEventArgs.prototype = {
    _item$1: null,
    _index$1: 0,
    _text$1: null,
    
    get_index: function ScriptFX_UI_AutoCompleteItemEventArgs$get_index() {
        return this._index$1;
    },
    
    get_item: function ScriptFX_UI_AutoCompleteItemEventArgs$get_item() {
        return this._item$1;
    },
    
    get_text: function ScriptFX_UI_AutoCompleteItemEventArgs$get_text() {
        return this._text$1;
    },
    set_text: function ScriptFX_UI_AutoCompleteItemEventArgs$set_text(value) {
        this._text$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteRequestEventArgs

ScriptFX.UI.AutoCompleteRequestEventArgs = function ScriptFX_UI_AutoCompleteRequestEventArgs(prefixText) {
    ScriptFX.UI.AutoCompleteRequestEventArgs.constructBase(this);
    this._prefixText$1 = prefixText;
}
ScriptFX.UI.AutoCompleteRequestEventArgs.prototype = {
    _prefixText$1: null,
    _items$1: null,
    
    get__items: function ScriptFX_UI_AutoCompleteRequestEventArgs$get__items() {
        return this._items$1;
    },
    
    get_prefixText: function ScriptFX_UI_AutoCompleteRequestEventArgs$get_prefixText() {
        return this._prefixText$1;
    },
    
    setItems: function ScriptFX_UI_AutoCompleteRequestEventArgs$setItems(items) {
        this._items$1 = items;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Button

ScriptFX.UI.Button = function ScriptFX_UI_Button(domElement) {
    ScriptFX.UI.Button.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, this._onClick$2));
}
ScriptFX.UI.Button.prototype = {
    _actionArgument$2: null,
    _actionName$2: null,
    
    get_actionArgument: function ScriptFX_UI_Button$get_actionArgument() {
        return this._actionArgument$2;
    },
    set_actionArgument: function ScriptFX_UI_Button$set_actionArgument(value) {
        this._actionArgument$2 = value;
        return value;
    },
    
    get_actionName: function ScriptFX_UI_Button$get_actionName() {
        return this._actionName$2;
    },
    set_actionName: function ScriptFX_UI_Button$set_actionName(value) {
        this._actionName$2 = value;
        return value;
    },
    
    add_action: function ScriptFX_UI_Button$add_action(value) {
        this.get_events().addHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    remove_action: function ScriptFX_UI_Button$remove_action(value) {
        this.get_events().removeHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    
    add_click: function ScriptFX_UI_Button$add_click(value) {
        this.get_events().addHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    remove_click: function ScriptFX_UI_Button$remove_click(value) {
        this.get_events().removeHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    
    _onClick$2: function ScriptFX_UI_Button$_onClick$2() {
        var clickHandler = this.get_events().getHandler(ScriptFX.UI.Button._clickEventKey$2);
        if (clickHandler) {
            clickHandler.invoke(this, EventArgs.Empty);
        }
    },
    
    performClick: function ScriptFX_UI_Button$performClick() {
        this._onClick$2();
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.CheckBox

ScriptFX.UI.CheckBox = function ScriptFX_UI_CheckBox(domElement) {
    ScriptFX.UI.CheckBox.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, this._onClick$2));
}
ScriptFX.UI.CheckBox.prototype = {
    
    get_checked: function ScriptFX_UI_CheckBox$get_checked() {
        return (this.get_domElement()).checked;
    },
    set_checked: function ScriptFX_UI_CheckBox$set_checked(value) {
        (this.get_domElement()).checked = value;
        return value;
    },
    
    add_checkedChanged: function ScriptFX_UI_CheckBox$add_checkedChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2, value);
    },
    remove_checkedChanged: function ScriptFX_UI_CheckBox$remove_checkedChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2, value);
    },
    
    _onClick$2: function ScriptFX_UI_CheckBox$_onClick$2() {
        var checkChangedHandler = this.get_events().getHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2);
        if (checkChangedHandler) {
            checkChangedHandler.invoke(this, EventArgs.Empty);
        }
        this.raisePropertyChanged('Checked');
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.EnterKeyBehavior

ScriptFX.UI.EnterKeyBehavior = function ScriptFX_UI_EnterKeyBehavior(element, options) {
    ScriptFX.UI.EnterKeyBehavior.constructBase(this, [ element, null ]);
    this._clickTarget$1 = options.clickTarget;
    this.get_domEvents().attach('onkeypress', Delegate.create(this, this._onElementKeyPress$1));
}
ScriptFX.UI.EnterKeyBehavior.prototype = {
    _clickTarget$1: null,
    
    _onElementKeyPress$1: function ScriptFX_UI_EnterKeyBehavior$_onElementKeyPress$1() {
        if ((window.event.keyCode === ScriptFX.UI.Key.enter) && (!this._clickTarget$1.disabled)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            this._clickTarget$1.click();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Label

ScriptFX.UI.Label = function ScriptFX_UI_Label(domElement) {
    ScriptFX.UI.Label.constructBase(this, [ domElement ]);
}
ScriptFX.UI.Label.prototype = {
    
    get_text: function ScriptFX_UI_Label$get_text() {
        return this.get_domElement().innerText;
    },
    set_text: function ScriptFX_UI_Label$set_text(value) {
        this.get_domElement().innerText = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.TextBox

ScriptFX.UI.TextBox = function ScriptFX_UI_TextBox(domElement) {
    ScriptFX.UI.TextBox.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onchange', Delegate.create(this, this._onValueChanged$2));
}
ScriptFX.UI.TextBox.prototype = {
    
    get_text: function ScriptFX_UI_TextBox$get_text() {
        var watermark = ScriptFX.UI.Behavior.getBehavior(this.get_domElement(), ScriptFX.UI.WatermarkBehavior);
        if ((watermark) && watermark.get_isWatermarked()) {
            return String.Empty;
        }
        return (this.get_domElement()).value;
    },
    set_text: function ScriptFX_UI_TextBox$set_text(value) {
        (this.get_domElement()).value = value;
        this._onValueChanged$2();
        return value;
    },
    
    add_textChanged: function ScriptFX_UI_TextBox$add_textChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.TextBox._textChangedEventKey$2, value);
    },
    remove_textChanged: function ScriptFX_UI_TextBox$remove_textChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.TextBox._textChangedEventKey$2, value);
    },
    
    _onValueChanged$2: function ScriptFX_UI_TextBox$_onValueChanged$2() {
        var textChangedHandler = this.get_events().getHandler(ScriptFX.UI.TextBox._textChangedEventKey$2);
        if (textChangedHandler) {
            textChangedHandler.invoke(this, EventArgs.Empty);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.WatermarkBehavior

ScriptFX.UI.WatermarkBehavior = function ScriptFX_UI_WatermarkBehavior(element, options) {
    ScriptFX.UI.WatermarkBehavior.constructBase(this, [ element, null ]);
    this._options$1 = options;
    this.get_domEvents().attach('onfocus', Delegate.create(this, this._onElementFocus$1));
    this.get_domEvents().attach('onblur', Delegate.create(this, this._onElementBlur$1));
    this.update();
}
ScriptFX.UI.WatermarkBehavior.prototype = {
    _options$1: null,
    _maxLength$1: 0,
    
    get_isWatermarked: function ScriptFX_UI_WatermarkBehavior$get_isWatermarked() {
        return ScriptFX.UI.Element.containsCSSClass(this.get_domElement(), this._options$1.watermarkCssClass);
    },
    
    _applyWatermark$1: function ScriptFX_UI_WatermarkBehavior$_applyWatermark$1() {
        var element = this.get_domElement();
        if (!element.value.length) {
            this._maxLength$1 = element.maxLength;
            element.maxLength = this._options$1.watermarkText.length;
            ScriptFX.UI.Element.addCSSClass(element, this._options$1.watermarkCssClass);
            element.value = this._options$1.watermarkText;
        }
    },
    
    _clearWatermark$1: function ScriptFX_UI_WatermarkBehavior$_clearWatermark$1(focusing) {
        var element = this.get_domElement();
        if (ScriptFX.UI.Element.containsCSSClass(element, this._options$1.watermarkCssClass)) {
            element.maxLength = this._maxLength$1;
            ScriptFX.UI.Element.removeCSSClass(element, this._options$1.watermarkCssClass);
            if (focusing) {
                element.value = '';
            }
        }
    },
    
    dispose: function ScriptFX_UI_WatermarkBehavior$dispose() {
        if (!this.get_isDisposed()) {
            this._clearWatermark$1(false);
        }
        ScriptFX.UI.WatermarkBehavior.callBase(this, 'dispose');
    },
    
    _onElementFocus$1: function ScriptFX_UI_WatermarkBehavior$_onElementFocus$1() {
        this._clearWatermark$1(true);
    },
    
    _onElementBlur$1: function ScriptFX_UI_WatermarkBehavior$_onElementBlur$1() {
        this._applyWatermark$1();
    },
    
    update: function ScriptFX_UI_WatermarkBehavior$update() {
        var element = this.get_domElement();
        if (!element.value.length) {
            this._applyWatermark$1();
        }
        else {
            this._clearWatermark$1(false);
        }
    }
}


ScriptFX.UI.AutoCompleteBehavior.createClass('ScriptFX.UI.AutoCompleteBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.AutoCompleteItemEventArgs.createClass('ScriptFX.UI.AutoCompleteItemEventArgs', EventArgs);
ScriptFX.UI.AutoCompleteRequestEventArgs.createClass('ScriptFX.UI.AutoCompleteRequestEventArgs', EventArgs);
ScriptFX.UI.Button.createClass('ScriptFX.UI.Button', ScriptFX.UI.Control, ScriptFX.UI.IAction);
ScriptFX.UI.CheckBox.createClass('ScriptFX.UI.CheckBox', ScriptFX.UI.Control, ScriptFX.UI.IToggle);
ScriptFX.UI.EnterKeyBehavior.createClass('ScriptFX.UI.EnterKeyBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.Label.createClass('ScriptFX.UI.Label', ScriptFX.UI.Control, ScriptFX.UI.IStaticText);
ScriptFX.UI.TextBox.createClass('ScriptFX.UI.TextBox', ScriptFX.UI.Control, ScriptFX.UI.IEditableText);
ScriptFX.UI.WatermarkBehavior.createClass('ScriptFX.UI.WatermarkBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.Button._clickEventKey$2 = 'click';
ScriptFX.UI.CheckBox._checkChangedEventKey$2 = 'checkChanged';
ScriptFX.UI.TextBox._textChangedEventKey$2 = 'textChanged';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.Net');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._scriptResponse

ScriptFX.Net._scriptResponse = function ScriptFX_Net__scriptResponse(request, data) {
    this._timeStamp = new Date();
    this._request = request;
    this._data = data;
}
ScriptFX.Net._scriptResponse.prototype = {
    _request: null,
    _timeStamp: null,
    _data: null,
    _xml: null,
    
    get_contentLength: function ScriptFX_Net__scriptResponse$get_contentLength() {
        return 0;
    },
    
    get_contentType: function ScriptFX_Net__scriptResponse$get_contentType() {
        return 'text/javascript';
    },
    
    get_headers: function ScriptFX_Net__scriptResponse$get_headers() {
        return {};
    },
    
    get_request: function ScriptFX_Net__scriptResponse$get_request() {
        return this._request;
    },
    
    get_statusCode: function ScriptFX_Net__scriptResponse$get_statusCode() {
        return ScriptFX.Net.HTTPStatusCode.OK;
    },
    
    get_statusText: function ScriptFX_Net__scriptResponse$get_statusText() {
        return String.Empty;
    },
    
    get_timeStamp: function ScriptFX_Net__scriptResponse$get_timeStamp() {
        return this._timeStamp;
    },
    
    getHeader: function ScriptFX_Net__scriptResponse$getHeader(name) {
        return null;
    },
    
    getObject: function ScriptFX_Net__scriptResponse$getObject() {
        return this._data;
    },
    
    getText: function ScriptFX_Net__scriptResponse$getText() {
        return Type.safeCast(this._data, String);
    },
    
    getXML: function ScriptFX_Net__scriptResponse$getXML() {
        if (!this._xml) {
            var text = this.getText();
            if (text) {
                try {
                    this._xml = XMLDocumentParser.parse(text);
                }
                catch ($e1) {
                }
            }
        }
        return this._xml;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.ScriptTransport

ScriptFX.Net.ScriptTransport = function ScriptFX_Net_ScriptTransport(request) {
    ScriptFX.Net.ScriptTransport.constructBase(this, [ request ]);
}
ScriptFX.Net.ScriptTransport.prototype = {
    _scriptElement$1: null,
    _callbackExport$1: null,
    
    abort: function ScriptFX_Net_ScriptTransport$abort() {
        if (this._callbackExport$1) {
            Delegate.clearExport(this._callbackExport$1);
            this._callbackExport$1 = null;
        }
        if (this._scriptElement$1) {
            document.body.removeChild(this._scriptElement$1);
            this._scriptElement$1 = null;
        }
    },
    
    dispose: function ScriptFX_Net_ScriptTransport$dispose() {
        this.abort();
    },
    
    invoke: function ScriptFX_Net_ScriptTransport$invoke() {
        Debug.assert(this.getMethod() === 'GET');
        Debug.assert(!this.get_request().get_hasHeaders());
        Debug.assert(!this.get_request().get_hasCredentials());
        var callbackParam = null;
        var parameters = this.get_parameters();
        if (parameters) {
            callbackParam = parameters['callbackParameterName'];
        }
        if (!callbackParam) {
            callbackParam = 'callback';
        }
        var callback = Delegate.create(this, this._onDataAvailable$1);
        this._callbackExport$1 = Delegate.createExport(callback);
        var callbackCode = callbackParam + '=Delegate.' + this._callbackExport$1;
        var url = this.get_request().get_URI();
        if (url.indexOf('?') >= 0) {
            url += '&' + callbackCode;
        }
        else {
            url += '?' + callbackCode;
        }
        this._scriptElement$1 = document.createElement('SCRIPT');
        this._scriptElement$1.type = 'text/javascript';
        this._scriptElement$1.src = url;
        document.body.appendChild(this._scriptElement$1);
    },
    
    _onDataAvailable$1: function ScriptFX_Net_ScriptTransport$_onDataAvailable$1(data) {
        if (this._scriptElement$1) {
            document.body.removeChild(this._scriptElement$1);
            this._scriptElement$1 = null;
            this._callbackExport$1 = null;
            this.onCompleted(new ScriptFX.Net._scriptResponse(this.get_request(), data));
        }
    }
}


ScriptFX.Net._scriptResponse.createClass('ScriptFX.Net._scriptResponse', null, ScriptFX.Net.IHTTPResponse);
ScriptFX.Net.ScriptTransport.createClass('ScriptFX.Net.ScriptTransport', ScriptFX.Net.HTTPTransport);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('Framework');

Framework.XMLUtils = function() {
}

Framework.XMLUtils.prototype = {
	_emptyContentDocument : null
}

Framework.XMLUtils.transformAndUpdateFirefox = function XMLUtils$transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	var xsltProcessor = new XSLTProcessor();
	for (var parameterName in parametersMap)
		if (parameterName != null && parametersMap[parameterName] != null)
			xsltProcessor.setParameter("", parameterName, parametersMap[parameterName]);
	xsltProcessor.importStylesheet(xsltDocument);
	var resultFragment = xsltProcessor.transformToFragment(contentDocument, document);
	var placeHolder = (domElement == null) ? $(domElementId) : domElement;

	if (placeHolder != null) {
	    // create garbage collector
	    var GCid = 'GarbageCollector';
	    if (document.getElementById(GCid) == null) {
	        var GC = document.createElement("div");
	        GC.setAttribute('id', GCid);
	        GC.style.display = 'none';
	        window.document.body.appendChild(GC);
	    }
	    var GC = document.getElementById(GCid);
	    // put new content into memory
	    var newContent = document.createElement("div");
	    GC.appendChild(newContent);
		newContent.appendChild(resultFragment);
		
		// execute in memory callback
		if(inMemoryProcessingCallback != null)
		    inMemoryProcessingCallback(newContent);
		
		// move old content away
		var oldContent = document.createElement("div");
		GC.appendChild(oldContent);
		while(placeHolder.childNodes.length)
			oldContent.appendChild(placeHolder.childNodes[0]);
		
		// add new content to screen
		while(newContent.childNodes.length)
			placeHolder.appendChild(newContent.childNodes[0]);
		
		// remove behaviors	from old content
		Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
		GC.innerHTML = '';
		oldContent = null;
		newContent = null;	
	}
}

Framework.XMLUtils.transformAndUpdateInternetExplorer = function XMLUtils$transformAndUpdateInternetExplorer(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {

    //Made a change here to use MSXML instead of the default version
    //This was done so that the <xslt:include> state works in IE. Otherwise it gives an access denied error
    
    var freeThreadedXsltDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument.6.0");
    freeThreadedXsltDocument.resolveExternals = true;
    freeThreadedXsltDocument.setProperty("AllowDocumentFunction", true);
    freeThreadedXsltDocument.setProperty("ProhibitDTD", false);
    
    xsltDocument.resolveExternals = true;
    xsltDocument.setProperty("AllowDocumentFunction", true);
    xsltDocument.setProperty("ProhibitDTD", false);
    
    freeThreadedXsltDocument.loadXML(xsltDocument.xml);
    var cache = new ActiveXObject("MSXML2.XSLTemplate.6.0");
    cache.stylesheet = freeThreadedXsltDocument;
    var processor = cache.createProcessor();
    for (var parameterName in parametersMap)
        if (parameterName != null && parametersMap[parameterName] != null)
        processor.addParameter(parameterName, parametersMap[parameterName]);
    processor.input = contentDocument;
    processor.transform();

    var placeHolder = (domElement == null) ? $(domElementId) : domElement;
    if (placeHolder != null) {
        // create garbage collector
        var GCid = 'GarbageCollector';
        if (document.getElementById(GCid) == null) {
            var GC = document.createElement("div");
            GC.setAttribute('id', GCid);
            GC.style.display = 'none';
            window.document.body.appendChild(GC);
        }
        var GC = document.getElementById(GCid);
        // put new content into memory
        var newContent = document.createElement("div");
        GC.appendChild(newContent);
        newContent.innerHTML = processor.output;

        // execute in memory callback
        if (inMemoryProcessingCallback != null)
            inMemoryProcessingCallback(newContent);

        // move old content to GC bin
        var oldContent = document.createElement("div");
        GC.appendChild(oldContent);
        while (placeHolder.childNodes.length)
            oldContent.appendChild(placeHolder.childNodes[0]);

        // add new content to screen
        while (newContent.childNodes.length)
            placeHolder.appendChild(newContent.childNodes[0]);

        // remove behaviors	
        Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
        GC.innerHTML = '';
        oldContent = null;
        newContent = null;
    }
}

Framework.XMLUtils.transformAndUpdateInternetExplorerWithXsltUrl = function XMLUtils$transformAndUpdateInternetExplorerWithXsltUrl(contentDocument, xsltDocument, parametersMap, domElementId, domElement, xsltUrl, inMemoryProcessingCallback) {

    //Made a change here to use MSXML instead of the default version
    //This was done so that the <xslt:include> state works in IE. Otherwise it gives an access denied error

    var freeThreadedXsltDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument.3.0");
    freeThreadedXsltDocument.resolveExternals = true;
    freeThreadedXsltDocument.setProperty("AllowDocumentFunction", true);
    freeThreadedXsltDocument.setProperty("ProhibitDTD", false);
    
    xsltDocument.resolveExternals = true;
    xsltDocument.setProperty("AllowDocumentFunction", true);
    xsltDocument.setProperty("ProhibitDTD", false);

    if (xsltDocument == null)
        freeThreadedXsltDocument.load(xsltUrl);
    else
        freeThreadedXsltDocument.loadXML(xsltDocument.xml);
    var cache = new ActiveXObject("MSXML2.XSLTemplate.3.0");
    cache.stylesheet = freeThreadedXsltDocument;
    var processor = cache.createProcessor();
    for (var parameterName in parametersMap)
        if (parameterName != null && parametersMap[parameterName] != null)
        processor.addParameter(parameterName, parametersMap[parameterName]);
    processor.input = contentDocument;
    processor.transform();

    var placeHolder = (domElement == null) ? $(domElementId) : domElement;
    if (placeHolder != null) {
        // put new content into memory
        var newContent = document.createElement("div");
        newContent.innerHTML = processor.output;

        // execute in memory callback
        if (inMemoryProcessingCallback != null)
            inMemoryProcessingCallback(newContent);

        // move old content to GC bin
        var oldContent = document.createElement("div");
        while (placeHolder.childNodes.length)
            oldContent.appendChild(placeHolder.childNodes[0]);

        // add new content to screen
        while (newContent.childNodes.length)
            placeHolder.appendChild(newContent.childNodes[0]);

        // remove behaviors	
        Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);

        oldContent = null;
        newContent = null;
    }
}

Framework.XMLUtils.transformAndUpdate = function XMLUtils$transformAndUpdate(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	if (document.implementation && document.implementation.createDocument)
		this.transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
	else
		this.transformAndUpdateInternetExplorer(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
}

Framework.XMLUtils.transformAndUpdateWithXsltUrl = function XMLUtils$transformAndUpdateWithXsltUrl(contentDocument, xsltDocument, parametersMap, domElementId, domElement, xsltUrl, inMemoryProcessingCallback) {
    if (document.implementation && document.implementation.createDocument)
        this.transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
    else
        this.transformAndUpdateInternetExplorerWithXsltUrl(contentDocument, xsltDocument, parametersMap, domElementId, domElement, xsltUrl, inMemoryProcessingCallback);
}


Framework.XMLUtils.get_emptyContentDocument = function XMLUtils$get_emptyContentDocument() {
	if (!this._emptyContentDocument)
		if (document.implementation && document.implementation.createDocument)
			this._emptyContentDocument = document.implementation.createDocument("", "no-content", null); 
		else {
			this._emptyContentDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
			this._emptyContentDocument.loadXML("<no-content />");
		}
	return this._emptyContentDocument;
}

//////////

Framework.HtmlUtils = function() {
}

Framework.HtmlUtils.prototype = {
	_emptyContentDocument : null
}

Framework.HtmlUtils.detachBehavioursAndClearHtmlElementContent = function HtmlUtils$detachBehavioursAndClearHtmlElementContent(domElementId){
	var domElement = document.getElementById(domElementId);
	
	if(domElement == null)
	    return;
	    
    Framework.DocumentBehaviors.purgeBehaviors(domElement, false, 0);
    domElement.innerHTML = "";
    domElement.parentNode.removeChild(domElement);
}


//////////
/*
    The global object JSON contains two methods.

    JSON.stringify(value) takes a JavaScript value and produces a JSON text.
    The value must not be cyclical.

    JSON.parse(text) takes a JSON text and produces a JavaScript value. It will
    return false if there is an error.
*/
var JSON1 = function () {
    var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        },
        s = {
            'boolean': function (x) {
                return String(x);
            },
            number: function (x) {
                return isFinite(x) ? String(x) : 'null';
            },
            string: function (x) {
                if (/["\\\x00-\x1f]/.test(x)) {
                    x = x.replace(/([\x00-\x1f\\"])/g, function(a, b) {
                        var c = m[b];
                        if (c) {
                            return c;
                        }
                        c = b.charCodeAt();
                        return '\\u00' +
                            Math.floor(c / 16).toString(16) +
                            (c % 16).toString(16);
                    });
                }
                return '"' + x + '"';
            },
            object: function (x) {
                if (x) {
                    var a = [], b, f, i, l, v;
                    if (x instanceof Array) {
                        a[0] = '[';
                        l = x.length;
                        for (i = 0; i < l; i += 1) {
                            v = x[i];
                            f = s[typeof v];
                            if (f) {
                                v = f(v);
                                if (typeof v == 'string') {
                                    if (b) {
                                        a[a.length] = ',';
                                    }
                                    a[a.length] = v;
                                    b = true;
                                }
                            }
                        }
                        a[a.length] = ']';
                    } else if (x instanceof Object) {
                        a[0] = '{';
                        for (i in x) {
                            v = x[i];
                            f = s[typeof v];
                            if (f) {
                                v = f(v);
                                if (typeof v == 'string') {
                                    if (b) {
                                        a[a.length] = ',';
                                    }
                                    a.push(s.string(i), ':', v);
                                    b = true;
                                }
                            }
                        }
                        a[a.length] = '}';
                    } else {
                        return;
                    }
                    return a.join('');
                }
                return 'null';
            }
        };
    return {
        copyright: '(c)2005 JSON.org',
        license: 'http://www.crockford.com/JSON/license.html',
/*
    Stringify a JavaScript value, producing a JSON text.
*/
        stringify: function (v) {
            var f = s[typeof v];
            if (f) {
                v = f(v);
                if (typeof v == 'string') {
                    return v;
                }
            }
            return null;
        },
/*
    Parse a JSON text, producing a JavaScript value.
    It returns false if there is a syntax error.
*/
        eval: function (text) {
            try {
                return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
                        text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
                    eval('(' + text + ')');
            } catch (e) {
                return false;
            }
        },

        parse: function (text) {
            var at = 0;
            var ch = ' ';

            function error(m) {
                throw {
                    name: 'JSONError',
                    message: m,
                    at: at - 1,
                    text: text
                };
            }

            function next() {
                ch = text.charAt(at);
                at += 1;
                return ch;
            }

            function white() {
                while (ch) {
                    if (ch <= ' ') {
                        next();
                    } else if (ch == '/') {
                        switch (next()) {
                            case '/':
                                while (next() && ch != '\n' && ch != '\r') {}
                                break;
                            case '*':
                                next();
                                for (;;) {
                                    if (ch) {
                                        if (ch == '*') {
                                            if (next() == '/') {
                                                next();
                                                break;
                                            }
                                        } else {
                                            next();
                                        }
                                    } else {
                                        error("Unterminated comment");
                                    }
                                }
                                break;
                            default:
                                error("Syntax error");
                        }
                    } else {
                        break;
                    }
                }
            }

            function string() {
                var i, s = '', t, u;

                if (ch == '"') {
    outer:          while (next()) {
                        if (ch == '"') {
                            next();
                            return s;
                        } else if (ch == '\\') {
                            switch (next()) {
                            case 'b':
                                s += '\b';
                                break;
                            case 'f':
                                s += '\f';
                                break;
                            case 'n':
                                s += '\n';
                                break;
                            case 'r':
                                s += '\r';
                                break;
                            case 't':
                                s += '\t';
                                break;
                            case 'u':
                                u = 0;
                                for (i = 0; i < 4; i += 1) {
                                    t = parseInt(next(), 16);
                                    if (!isFinite(t)) {
                                        break outer;
                                    }
                                    u = u * 16 + t;
                                }
                                s += String.fromCharCode(u);
                                break;
                            default:
                                s += ch;
                            }
                        } else {
                            s += ch;
                        }
                    }
                }
                error("Bad string");
            }

            function array() {
                var a = [];

                if (ch == '[') {
                    next();
                    white();
                    if (ch == ']') {
                        next();
                        return a;
                    }
                    while (ch) {
                        a.push(value());
                        white();
                        if (ch == ']') {
                            next();
                            return a;
                        } else if (ch != ',') {
                            break;
                        }
                        next();
                        white();
                    }
                }
                error("Bad array");
            }

            function object() {
                var k, o = {};

                if (ch == '{') {
                    next();
                    white();
                    if (ch == '}') {
                        next();
                        return o;
                    }
                    while (ch) {
                        k = string();
                        white();
                        if (ch != ':') {
                            break;
                        }
                        next();
                        o[k] = value();
                        white();
                        if (ch == '}') {
                            next();
                            return o;
                        } else if (ch != ',') {
                            break;
                        }
                        next();
                        white();
                    }
                }
                error("Bad object");
            }

            function number() {
                var n = '', v;
                if (ch == '-') {
                    n = '-';
                    next();
                }
                while (ch >= '0' && ch <= '9') {
                    n += ch;
                    next();
                }
                if (ch == '.') {
                    n += '.';
                    while (next() && ch >= '0' && ch <= '9') {
                        n += ch;
                    }
                }
                if (ch == 'e' || ch == 'E') {
                    n += 'e';
                    next();
                    if (ch == '-' || ch == '+') {
                        n += ch;
                        next();
                    }
                    while (ch >= '0' && ch <= '9') {
                        n += ch;
                        next();
                    }
                }
                v = +n;
                if (!isFinite(v)) {
                    ////error("Bad number");
                } else {
                    return v;
                }
            }

            function word() {
                switch (ch) {
                    case 't':
                        if (next() == 'r' && next() == 'u' && next() == 'e') {
                            next();
                            return true;
                        }
                        break;
                    case 'f':
                        if (next() == 'a' && next() == 'l' && next() == 's' &&
                                next() == 'e') {
                            next();
                            return false;
                        }
                        break;
                    case 'n':
                        if (next() == 'u' && next() == 'l' && next() == 'l') {
                            next();
                            return null;
                        }
                        break;
                }
                error("Syntax error");
            }

            function value() {
                white();
                switch (ch) {
                    case '{':
                        return object();
                    case '[':
                        return array();
                    case '"':
                        return string();
                    case '-':
                        return number();
                    default:
                        return ch >= '0' && ch <= '9' ? number() : word();
                }
            }

            return value();
        }
    };
}();

Framework.JsonUtil = function() {
}

Framework.JsonUtil.serialize = function serialize(value) {
	return JSON1.stringify(value);
}

Framework.JsonUtil.deserialize = function deserialize(text) {
	return JSON1.parse(text);
}

Framework.DocumentEvents = function() {
}

Framework.DocumentEvents.setOnMousemove = function(handler){
	document.onmousemove	= handler;
}

Framework.DocumentEvents.setOnMouseup = function(handler){
	document.onmouseup	= handler;
}

Framework.DocumentEvents.parse = function(handler) {
	return handler;
}

Framework.DocumentEvents.purgeEventsBeforeUpdate = function(d,ignoreRootElement, recursionCount) {
	if (recursionCount > 100)
		return;
		
	var index1;
	if(!ignoreRootElement)
	{
	    var behaviors = ScriptFX.UI.Behavior.getBehaviors(d, null);
	    if(behaviors)
	    {
	        for (index1 = 0; index1 < behaviors.length; index1++)
	        {
	            behaviors[index1].dispose();
            }
	    }
	}
		
	var i;
	if (!ignoreRootElement && d.attributes)
		for (i = 0; i < d.attributes.length; i++)
		try {
			if (typeof d[d.attributes[i].name] === 'function')
				d[d.attributes[i].name] = null;
		} catch(e){
			alert(e + 'Please contact customer support!');
		}
	var i;
	if (d.childNodes)
		for (i = 0; i < d.childNodes.length; i++)
			Framework.DocumentEvents.purgeEventsBeforeUpdate(d.childNodes[i], false, recursionCount + 1);
}

Framework.DocumentBehaviors = function() {
}

// Remove behaviors from all DOM elements recursively
Framework.DocumentBehaviors.purgeBehaviors = function(d,ignoreRootElement, recursionCount) {
	if (recursionCount > 100)
		return;
	
	var index1;
	if(!ignoreRootElement)
	{
	    var behaviors = ScriptFX.UI.Behavior.getBehaviors(d, null);
	    if(behaviors)
	    {
	        for (index1 = 0; index1 < behaviors.length; index1++)
	        {
	            behaviors[index1].dispose();
            }
	    }
	}
	
	var index2;
	if (d.childNodes)
	{
		for (index2 = 0; index2 < d.childNodes.length; index2++)
			Framework.DocumentBehaviors.purgeBehaviors(d.childNodes[index2], false, recursionCount + 1);
	}
}


Type.createNamespace('Framework.Behavior');

Framework.Behavior.ParametersObjectBuilder = function() {
}

Framework.Behavior.ParametersObjectBuilder.build = function(domElement, behaviorID) {
	if (domElement.attributes == null)
	    return null;
	
	var pattern = new RegExp("^behavior." + behaviorID + ".","i");
	var parameters = new Array();
	var i;
	for (i = 0; i < domElement.attributes.length; i++)
    {
        var attname = domElement.attributes[i].name;
        
        if(attname.search(pattern) == -1)
            continue;
        
        parameters[attname.replace(pattern,"")] = domElement.attributes[i].value;    
    }
    
    return parameters;
}


Type.createNamespace('Framework.Util');

Framework.Util.DebugInfoProvider = function() {
}

Framework.Util.DebugInfoProvider.delegateDebugInfo = function(parDelegate) {
    var result = "";
    
    if(parDelegate != null && 
        parDelegate._targets != null && 
        parDelegate._targets.length != null && 
        parDelegate._targets.length == 2)
    {
        if(parDelegate._targets[1] != null)
            result = parDelegate._targets[1].toString();
    }
    
    return result;
}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	WindowedControlsHider.js - Windowed Controls Hider v3.20
	aplus.co.yu/WindowedControlsHider/
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	(c) Copyright 2003 and on, Aleksandar Vacic, www.aplus.co.yu
		This work is licensed under the Creative Commons Attribution License.
		To view a copy of this license, visit http://creativecommons.org/licenses/by/3.0/ or
		send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
var WCH_Constructor = function() {
	//	exit point for anything but IE5.0+/Win
	if ( !(document.all && document.getElementById && !window.opera && navigator.userAgent.toLowerCase().indexOf("mac") == -1) ) {
		this.apply = function() {};
		this.discard = function() {};
		return;
	}

	//	private properties
	var _bIE55 = false;
	var _bIE6 = false;
	var _oRule = null;
	var _bSetup = true;
	var _oSelf = this;

	//	public: hides windowed controls
	this.apply = function(vLayer, vContainer, bResize) {
		if (_bSetup) _Setup();

		if ( _bIE55 && (oIframe = _Hider(vLayer, vContainer, bResize)) ) {
			oIframe.style.visibility = "visible";
		} else if(_oRule != null) {
			_oRule.style.visibility = "hidden";
		}

	};

	//	public: shows windowed controls
	this.discard = function(vLayer, vContainer) {
		if ( _bIE55 && (oIframe = _Hider(vLayer, vContainer, false)) ) {
			oIframe.style.visibility = "hidden";
		} else if(_oRule != null) {
			_oRule.style.visibility = "visible";
		}
	};

	//	private: returns iFrame reference for IE5.5+
	function _Hider(vLayer, vContainer, bResize) {
		var oLayer = _GetObj(vLayer);
		var oContainer = ( (oTmp = _GetObj(vContainer)) ? oTmp : document.getElementsByTagName("body")[0] );
		if (!oLayer || !oContainer) return;

		//	is it there already?
		//		1. first check does the layer has an ID at all. if not, assign one, using current timestamp, so we avoid duplicates
		if (oLayer.id == "")
			oLayer.id = "WCHid" + (new Date()).getTime();
		//		2. then try to locate the hiding iFrame
		var oIframe = document.getElementById("WCHhider" + oLayer.id);

		//	if not, create it
		if ( !oIframe ) {
			//	IE 6 has this property, IE 5 not. IE 5.5(even SP2) crashes when filter is applied, hence the check
			var sFilter = (_bIE6) ? "filter:progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0);" : "";
			//	get z-index of the object
			var zIndex = oLayer.style.zIndex;
			if ( zIndex == "" ) zIndex = oLayer.currentStyle.zIndex;
			zIndex = parseInt(zIndex);
			//	if no z-index, do nothing
			if ( isNaN(zIndex) ) return null;
			//	if z-index is below 2, do nothing (no room for Hider)
			if (zIndex < 2) return null;
			//	go one step below for Hider
			zIndex--;
			var sHiderID = "WCHhider" + oLayer.id;
			oContainer.insertAdjacentHTML("afterBegin", '<iframe class="WCHiframe" src="javascript:void(0);" id="' + sHiderID + '" scroll="no" frameborder="0" style="position:absolute;visibility:hidden;' + sFilter + 'border:0;top:0;left;0;width:0;height:0;background-color:#ccc;z-index:' + zIndex + ';"></iframe>');
			oIframe = document.getElementById(sHiderID);
			//	then do calculation
			_SetPos(oIframe, oLayer);
		} else if (bResize) {
			//	resize the iFrame if asked
			_SetPos(oIframe, oLayer);
		}
		return oIframe;
	};

	//	private: set size and position of the Hider
	function _SetPos(oIframe, oLayer) {
		//	fetch and set size
		oIframe.style.width = oLayer.offsetWidth + "px";
		oIframe.style.height = oLayer.offsetHeight + "px";
		//	move to specified position
		oIframe.style.left = oLayer.offsetLeft + "px";
		oIframe.style.top = oLayer.offsetTop + "px";
	};

	//	private: returns object reference
	function _GetObj(vObj) {
		var oObj = null;
		switch( typeof(vObj) ) {
			case "object":
				oObj = vObj;
				break;
			case "string":
				oObj = document.getElementById(vObj);
				break;
		}
		return oObj;
	};

	//	private: setup properties on first call to Apply
	function _Setup() {
		_bIE55 = (typeof(document.body.contentEditable) != "undefined");
		_bIE6 = (typeof(document.compatMode) != "undefined");

		if (!_bIE55) {
			if (document.styleSheets.length == 0)
				document.createStyleSheet();
			var oSheet = document.styleSheets[0];
			oSheet.addRule(".WCHhider", "visibility:visible");
			_oRule = oSheet.rules(oSheet.rules.length-1);
		}

		_bSetup = false;
	};
};
var WindowedControlsHider = new WCH_Constructor();

function getAllChildren(e) {
  // Returns all children of element. Workaround required for IE5/Windows. Ugh.
  return e.all ? e.all : e.getElementsByTagName('*');
}

document.getElementsBySelector = function(selector) {
  // Attempt to fail gracefully in lesser browsers
  if (!document.getElementsByTagName) {
    return new Array();
  }
  // Split selector in to tokens
  var tokens = selector.split(' ');
  var currentContext = new Array(document);
  for (var i = 0; i < tokens.length; i++) {
    token = tokens[i].replace(/^\s+/,'').replace(/\s+$/,'');;
    if (token.indexOf('#') > -1) {
      // Token is an ID selector
      var bits = token.split('#');
      var tagName = bits[0];
      var id = bits[1];
      var element = document.getElementById(id);
      if (tagName && element.nodeName.toLowerCase() != tagName) {
        // tag with that ID not found, return false
        return new Array();
      }
      // Set currentContext to contain just this element
      currentContext = new Array(element);
      continue; // Skip to next token
    }
    if (token.indexOf('.') > -1) {
      // Token contains a class selector
      var bits = token.split('.');
      var tagName = bits[0];
      var className = bits[1];
      if (!tagName) {
        tagName = '*';
      }
      // Get elements matching tag, filter them for class selector
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (found[k].className && found[k].className.match(new RegExp('\\b'+className+'\\b'))) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      continue; // Skip to next token
    }
    // Code to deal with attribute selectors
    if (token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/)) {
      var tagName = RegExp.$1;
      var attrName = RegExp.$2;
      var attrOperator = RegExp.$3;
      var attrValue = RegExp.$4;
      if (!tagName) {
        tagName = '*';
      }
      // Grab all of the tagName elements within current context
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      var checkFunction; // This function will be used to filter the elements
      switch (attrOperator) {
        case '=': // Equality
          checkFunction = function(e) { return (e.getAttribute(attrName) == attrValue); };
          break;
        case '~': // Match one of space seperated words 
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('\\b'+attrValue+'\\b'))); };
          break;
        case '|': // Match start with value followed by optional hyphen
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?'))); };
          break;
        case '^': // Match starts with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) == 0); };
          break;
        case '$': // Match ends with value - fails with "Warning" in Opera 7
          checkFunction = function(e) { return (e.getAttribute(attrName).lastIndexOf(attrValue) == e.getAttribute(attrName).length - attrValue.length); };
          break;
        case '*': // Match ends with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) > -1); };
          break;
        default :
          // Just test for existence of attribute
          checkFunction = function(e) { return e.getAttribute(attrName); };
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (checkFunction(found[k])) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      // alert('Attribute Selector: '+tagName+' '+attrName+' '+attrOperator+' '+attrValue);
      continue; // Skip to next token
    }
    // If we get here, token is JUST an element (not a class or ID selector)
    tagName = token;
    var found = new Array;
    var foundCount = 0;
    for (var h = 0; h < currentContext.length; h++) {
      var elements = currentContext[h].getElementsByTagName(tagName);
      for (var j = 0; j < elements.length; j++) {
        found[foundCount++] = elements[j];
      }
    }
    currentContext = found;
  }
  return currentContext;
}

Framework.DocumentFinder = function() {}

Framework.DocumentFinder.getElementsBySelector = function(css){return document.getElementsBySelector(css);}

function evSetFrameHeight (h) {
	var elements = Framework.DocumentFinder.getElementsBySelector('iframe');
	if (elements && elements.length > 0) {
		for (i = 0; i < elements.length; i++) {
			elements[i].height= h + 'px';
		}
	}
}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	ADxMenu.js - v4 (4.10)
	aplus.co.yu/adxmenu/
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	(c) Copyright 2003, Aleksandar Vacic, www.aplus.co.yu
		This work is licensed under the Creative Commons Attribution License.
		To view a copy of this license, visit http://creativecommons.org/licenses/by/2.0/ or
		send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
Framework.ADxMenu = function() {}

Framework.ADxMenu.ieSetup = function() {
	var aTmp2, i, j, oLI, aUL, aA;
	var aTmp = this.getElementsByClassName("adxm", document, "ul");
	for (i=0;i<aTmp.length;i++) {
		aTmp2 = aTmp[i].getElementsByTagName("li");
		for (j=0;j<aTmp2.length;j++) {
			oLI = aTmp2[j];
			aUL = oLI.getElementsByTagName("ul");
			//	if item has submenu, then make the item hoverable
			if (aUL && aUL.length) {
				oLI.UL = aUL[0];	//	direct submenu
				aA = oLI.getElementsByTagName("a");
				if (aA && aA.length)
					oLI.A = aA[0];	//	direct child link
				//	li:hover
				oLI.onmouseenter = function() {
					this.className += " adxmhover";
					this.UL.className += " adxmhoverUL";
					if (this.A) this.A.className += " adxmhoverA";
					if (WindowedControlsHider) WindowedControlsHider.apply( this.UL, this, true );
				};
				//	li:blur
				oLI.onmouseleave = function() {
					this.className = this.className.replace(/adxmhover/gi,"");
					this.UL.className = this.UL.className.replace(/adxmhoverUL/gi,"");
					if (this.A) this.A.className = this.A.className.replace(/adxmhoverA/gi,"");
					if (WindowedControlsHider) WindowedControlsHider.discard( this.UL, this );
				};
			}
		}	//for-li.submenu
	}	//for-ul.adxm
}

/*	getElementsByClassName()
	Returns an array of elements which are
	descendants of parentEle and have tagName and clsName.
	If parentEle is null or not present, document will be used.
	if tagName is null or not present, "*" will be used.
	credits: Mike Foster, cross-browser.com.
*/	
Framework.ADxMenu.getElementsByClassName = function(clsName, parentEle, tagName) {
	var elements = null;
	var found = new Array();
	var re = new RegExp('\\b'+clsName+'\\b');
	if (!parentEle) parentEle = document;
	if (!tagName) tagName = '*';
	if (parentEle.getElementsByTagName) {elements = parentEle.getElementsByTagName(tagName);}
	else if (document.all) {elements = document.all.tags(tagName);}
	if (elements) {
		for (var i = 0; i < elements.length; ++i) {
			if (elements[i].className.search(re) != -1) {
				found[found.length] = elements[i];
			}
		}
	}
	return found;
}

/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	fix IE6/7 problem: on mouse over, force showing help over "?" icon (on forms)
	uses getElementsByClassName from ADxMenu (above)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
Framework.FormHelp = function() {
}

Framework.FormHelp.ieSetup = function() {
	if (!document.all || window.opera) return;
	var aTmp = Framework.ADxMenu.getElementsByClassName("formhelp", document, "a");
	if (aTmp && aTmp.length) {
		for (var i=0;i<aTmp.length;i++) {
			aTmp[i].onmouseenter = function() {
				if (!(x = this.getElementsByTagName('span')[0])) return;
				x.style.visibility = 'visible';
			};
			aTmp[i].onmouseleave = function() {
				if (!(x = this.getElementsByTagName('span')[0])) return;
				x.style.visibility = 'hidden';
			};
		}
	}
}

Framework.WindowNameManager = function() {
}

Framework.WindowNameManager.getWindowName = function WindowNameManager$getWindowName() {
	
	try{
	    return window.top.name;
	    }
	    catch(e){
	    return window.name;
	    }
}

Framework.WindowNameManager.setWindowName = function WindowNameManager$setWindowName(name) {
	window.top.name = name;
}

Framework.XMLHttpRequestDecorator = function() {
}
Framework.XMLHttpRequestDecorator.prototype = {
	_body : null,
	_request : null,
	_requestHeaders : {},
	onreadystatechange : null,
	readyState : 0,
	responseText : null,
	responseXML : null,
	status : null,
	statusText : null,
	abort : function() {
		this._request.abort();
	},
	getAllResponseHeaders : function() {
		return this._request.getAllResponseHeaders();
	},
	getResponseHeader : function(name) {
		return this._request.getResponseHeader(name);
	},
	open : function(method, url, async, username, password) {
		var that = this;
		this._request = new XMLHttpRequest();
		this._request.onreadystatechange = function() {
			that.readyState = that._request.readyState;
			if (that._request.readyState === 4) {
				that.responseText = that._request.responseText;
				that.responseXML = that._request.responseXML;
				that.status = that._request.status;
				that.statusText = that._request.statusText;
				if (!that._request.getResponseHeader('Date') && ((that._request.status >= 200  && that._request.status <= 299) || that._request.status === 304)) {
					var lastModified = that._request.getResponseHeader('Last-Modified');
					//that._request.onreadystatechange = null;
					that._request = new XMLHttpRequest();
					that._request.onreadystatechange = function() {
						that.readyState = that._request.readyState;
						if (that._request.readyState === 4) {
							if (that._request.status >= 200 && that._request.status <= 299) {
								that.responseText = that._request.responseText;
								that.responseXML = that._request.responseXML;
							}
							that.status = that._request.status;
							that.statusText = that._request.statusText;
						}
						that.onreadystatechange();
						if (that._request.readyState === 4) {
							that.onreadystatechange = null;
							that._request = null;
						}
					}
					that._request.open(method, url, async, username, password);
					that._request.setRequestHeader('If-Modified-Since', lastModified || 'Thu, 01 Jan 1970 00:00:00 GMT');
					if (that._requestHeaders)
						for (var headerName in that._requestHeaders)
							that._request.setRequestHeader(headerName, that._requestHeaders[headerName]);
					that._request.send(that._body);
				} else {
					that.onreadystatechange();
					that.onreadystatechange = null;
					that_request = null;
				}
			} else
				that.onreadystatechange();
		}
		this._request.open(method, url, async, username, password);
	},
	send : function(body) {
		this._body = body;
		this._request.send(body);
	},
	setRequestHeader : function(name, value) {
		this._request.setRequestHeader(name, value);
		this._requestHeaders[name] = value;
	}
}

///////////////////////////////////////////////////////////////////////////////
// Change Current and Neutral CultureInfo to UK format

CultureInfo.Neutral = new CultureInfo('en-UK',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',

        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: '.',
        percentGroupSeparator: ',',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol: '£',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: '.',
        currencyGroupSeparator: ',',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: '.',
        numberGroupSeparator: ','
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, dd MMMM, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, dd MMMM, yyyy',
        shortDatePattern: 'd/M/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
        shortDayNames: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
        minimizedDayNames: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],

        monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', ''],
        shortMonthNames: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', '']
    });
CultureInfo.Current = CultureInfo.Neutral;

Framework.ADxMenu.createClass('Framework.ADxMenu');
Framework.DocumentEvents.createClass('Framework.DocumentEvents');
Framework.DocumentBehaviors.createClass('Framework.DocumentBehaviors');
Framework.Behavior.ParametersObjectBuilder.createClass('Framework.Behavior.ParametersObjectBuilder');
Framework.Util.DebugInfoProvider.createClass('Framework.Util.DebugInfoProvider');
Framework.DocumentFinder.createClass('Framework.DocumentFinder');
Framework.FormHelp.createClass('Framework.FormHelp');
Framework.JsonUtil.createClass('Framework.JsonUtil');
//Framework.WindowedControlsHider.createClass('Framework.WindowedControlsHider');
//Framework.WindowInstanceExt.createClass('Framework.WindowInstanceExt');
Framework.WindowNameManager.createClass('Framework.WindowNameManager');
Framework.XMLUtils.createClass('Framework.XMLUtils');
Framework.XMLHttpRequestDecorator.createClass('Framework.XMLHttpRequestDecorator');

Framework.ScriptSharpQuirks = function() {
}

Framework.ScriptSharpQuirks.isNumberNull = function ScriptSharpQuirks$isNumberNull(number) {
	return number == null;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ITopicChangedListener

Framework.ITopicChangedListener = function() { };
Framework.ITopicChangedListener.prototype = {
    onTopicChanged : null
}
Framework.ITopicChangedListener.createInterface('Framework.ITopicChangedListener');


////////////////////////////////////////////////////////////////////////////////
// Framework.IRpcTask

Framework.IRpcTask = function() { };
Framework.IRpcTask.prototype = {
    getRequestPayload : null,
    processResponse : null
}
Framework.IRpcTask.createInterface('Framework.IRpcTask');


////////////////////////////////////////////////////////////////////////////////
// Framework.IEnvironment

Framework.IEnvironment = function() { };
Framework.IEnvironment.prototype = {
    init : null,
    start : null,
    registerPageWillChangeListener : null,
    get_componentUpdateScheduler : null,
    getProtocol : null,
    getLanguage : null,
    getRegion : null,
    getPageArea : null,
    getInitialPageFilter : null,
    getDomElement : null,
    updateDomElement : null,
    updateDomElementDirect : null,
    transformAndUpdate : null,
    periodicalTransformAndUpdate : null,
    periodicalTransformAndUpdateWithContentUrlDelegate : null,
    clearPeriodicalTransformAndUpdate : null,
    invoke : null,
    invokeAsync : null,
    invokeAsyncUsingJsonp : null,
    storeState : null,
    getStoredState : null,
    get_debugInfo : null,
    getCookie : null,
    setCookie : null,
    setCookieWithDays : null,
    clearCookie : null,
    clearCookies : null,
    getBaselineUrl : null,
    changeLocation : null,
    changeRegion : null,
    changeLanguage : null,
    buildUrl : null,
    getHash : null,
    setHash : null,
    safelySetCssClass : null,
    safelyRemoveCssClass : null,
    safelySetAndUnsetCssClass : null,
    safelySetAndUnsetCssClassIf : null,
    containsCssClass : null,
    safelySetCssClassOnElement : null,
    safelyRemoveCssClassOnElement : null,
    safelySetAndUnsetCssClassOnElement : null,
    safelySetAndUnsetCssClassOnElementIf : null,
    containsCssClassOnElement : null
}
Framework.IEnvironment.createInterface('Framework.IEnvironment');


////////////////////////////////////////////////////////////////////////////////
// Framework.IPageWillChangeListener

Framework.IPageWillChangeListener = function() { };
Framework.IPageWillChangeListener.prototype = {
    onPageWillChange : null
}
Framework.IPageWillChangeListener.createInterface('Framework.IPageWillChangeListener');


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractComponent

Framework.AbstractComponent = function Framework_AbstractComponent() {
    this._log = Framework.Logger.getLog('AbstractComponent');
    this._children = new Array(0);
    this._componentLifeCycleManager = this.createComponentLifeCycleManager();
}
Framework.AbstractComponent.setFormEnabled = function Framework_AbstractComponent$setFormEnabled(domElementId, enabled) {
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('select'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('input'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('button'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('textarea'), enabled);
}
Framework.AbstractComponent._setCollectionEnabled = function Framework_AbstractComponent$_setCollectionEnabled(domElementCollection, enabled) {
    for (var i = 0; i < domElementCollection.length; i++) {
        domElementCollection[i].disabled = !enabled;
    }
}
Framework.AbstractComponent.prototype = {
    _environment: null,
    _componentInstanceName: null,
    _domElementId: null,
    _currentArea: 0,
    _area: null,
    _adminHtmlUrl: null,
    _cssClass: null,
    _childID: null,
    _parent: null,
    _siblingIndex: 0,
    _componentLifeCycleManager: null,
    
    get_componentLifeCycleManager: function Framework_AbstractComponent$get_componentLifeCycleManager() {
        return this._componentLifeCycleManager;
    },
    
    _visibleNavigationTypes: null,
    
    get_visibleNavigationTypes: function Framework_AbstractComponent$get_visibleNavigationTypes() {
        return this._visibleNavigationTypes;
    },
    
    get_cssClass: function Framework_AbstractComponent$get_cssClass() {
        return this._cssClass;
    },
    
    childrenUpdateComplete: function Framework_AbstractComponent$childrenUpdateComplete(eventArgs) {
    },
    
    childComponentUpdateComplete: function Framework_AbstractComponent$childComponentUpdateComplete(eventArgs) {
    },
    
    get__abstractEnvironment: function Framework_AbstractComponent$get__abstractEnvironment() {
        return this._environment;
    },
    
    update: function Framework_AbstractComponent$update(domElement, contentID, xsltUrl, xsltParameters, afterTransformationCallback, inMemoryTransformationCallback, xmlContent) {
        if (!afterTransformationCallback && !inMemoryTransformationCallback) {
            this.get__abstractEnvironment().transformAndUpdate(domElement.id, contentID, xsltUrl, xsltParameters, Delegate.create(this, this.repaintComplete), domElement, Delegate.create(this, this.transformationComplete), xmlContent);
        }
        else {
            this.get__abstractEnvironment().transformAndUpdate(domElement.id, contentID, xsltUrl, xsltParameters, afterTransformationCallback, domElement, inMemoryTransformationCallback, xmlContent);
        }
    },
    
    periodicalUpdate: function Framework_AbstractComponent$periodicalUpdate(domElementId, contentID, xsltUrl, xsltParameters, domain, autoRefreshPeriod, afterTransformationCallback, inMemoryTransformationCallback) {
        if (!afterTransformationCallback && !inMemoryTransformationCallback) {
            this.get__abstractEnvironment().periodicalTransformAndUpdate(domElementId, contentID, xsltUrl, xsltParameters, Delegate.create(this, this.repaintComplete), domain, autoRefreshPeriod, Delegate.create(this, this.transformationComplete));
        }
        else {
            this.get__abstractEnvironment().periodicalTransformAndUpdate(domElementId, contentID, xsltUrl, xsltParameters, afterTransformationCallback, domain, autoRefreshPeriod, inMemoryTransformationCallback);
        }
    },
    
    transformationComplete: function Framework_AbstractComponent$transformationComplete(inMemoryComponent) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(inMemoryComponent, (this));
    },
    
    repaintComplete: function Framework_AbstractComponent$repaintComplete() {
    },
    
    createComponentLifeCycleManager: function Framework_AbstractComponent$createComponentLifeCycleManager() {
        var tmpObject = this;
        return new Framework.Component.LifeCycleManagement.ComponentLifeCycleManager(tmpObject);
    },
    
    get_componentInstanceName: function Framework_AbstractComponent$get_componentInstanceName() {
        return this._componentInstanceName;
    },
    
    get_domElementId: function Framework_AbstractComponent$get_domElementId() {
        return this._domElementId;
    },
    set_domElementId: function Framework_AbstractComponent$set_domElementId(value) {
        this._domElementId = value;
        return value;
    },
    
    init: function Framework_AbstractComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log = Framework.Logger.getLog(domElementId);
        this._log.debug('Init');
        this._environment = environment;
        this._componentInstanceName = componentInstanceName;
        this._domElementId = domElementId;
        this._adminHtmlUrl = parameters['admin-html-url'];
        this._cssClass = parameters['css-class'];
        if (!String.isNullOrEmpty(parameters['visible-navigation-types'])) {
            this._visibleNavigationTypes = ScriptFX.JSON.deserialize((parameters['visible-navigation-types']));
        }
    },
    
    isNavigationTypesInAValidCombination: function Framework_AbstractComponent$isNavigationTypesInAValidCombination(currentNavTypes) {
        var navtypesToCheck = this.get_visibleNavigationTypes();
        if (!currentNavTypes) {
            return true;
        }
        if (!navtypesToCheck) {
            return true;
        }
        for (var count = 0; count < navtypesToCheck.length; count++) {
            if (navtypesToCheck[count].isMatch(currentNavTypes)) {
                return true;
            }
        }
        return false;
    },
    
    start: function Framework_AbstractComponent$start() {
        this._log.debug('Start');
        this.repaint();
    },
    
    repaintForAdmin: function Framework_AbstractComponent$repaintForAdmin() {
        var ajaxUpdater = new Framework.AjaxUpdater(this._domElementId, this._adminHtmlUrl, null, Delegate.create(this, function() {
            this._environment.updateDomElement(this._domElementId, this._domElementId);
        }));
        ajaxUpdater.update();
    },
    
    disableForAdmin: function Framework_AbstractComponent$disableForAdmin() {
        var anchors = this._environment.getDomElement(this._domElementId).getElementsByTagName('A');
        for (var i = 0; i < anchors.length; i++) {
            var anchor = anchors[i];
            anchor.setAttribute('href', '#');
            anchor.setAttribute('onclick', 'return false;');
        }
    },
    
    isVisible: function Framework_AbstractComponent$isVisible(visibleOn, notVisibleOn, action) {
        if (!visibleOn.length && !notVisibleOn.length) {
            return true;
        }
        if (visibleOn.length > 0) {
            return visibleOn.contains(action);
        }
        if (notVisibleOn.length > 0) {
            return !notVisibleOn.contains(action);
        }
        throw new Error('Parameters were not specified correctly.');
    },
    
    show: function Framework_AbstractComponent$show() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'block';
    },
    
    hide: function Framework_AbstractComponent$hide() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'none';
        this._environment.updateDomElement(this.get_domElementId(), String.Empty);
    },
    
    disable: function Framework_AbstractComponent$disable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'wait';
        Framework.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    enable: function Framework_AbstractComponent$enable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'default';
        Framework.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    getPrivateDomElement: function Framework_AbstractComponent$getPrivateDomElement(domElementNameSuffix) {
        return document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
    },
    
    updatePrivateDomElement: function Framework_AbstractComponent$updatePrivateDomElement(domElementNameSuffix, htmlContent) {
        this.updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, null, null);
    },
    
    updatePrivateDomElementWithCallback: function Framework_AbstractComponent$updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, successCallback, failureCallback) {
        try {
            var element = document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
            if (element) {
                this._environment.updateDomElementDirect(element, htmlContent);
                if (successCallback) {
                    successCallback.invoke();
                }
            }
            else {
                throw new Error(String.format('domElementNameSuffix [{0}] cannot be found!', domElementNameSuffix));
            }
        }
        catch (ex) {
            this._log.error('UpdatePrivateDomElement', ex);
            if (failureCallback) {
                failureCallback.invoke(ex);
            }
        }
    },
    
    activateArea: function Framework_AbstractComponent$activateArea(area, messages) {
        this._log.debug(String.format('ActivateArea area=[{0}] messages=[{1}]', area, messages));
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'none';
        this._currentArea = area;
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'block';
        if (messages) {
            for (var i = 0; i < messages.length; i++) {
                if (!String.isNullOrEmpty(messages[i])) {
                    this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea] + '-' + i).innerText = messages[i];
                }
            }
        }
    },
    
    getTranslation: function Framework_AbstractComponent$getTranslation(phrase) {
        return this.getPrivateDomElement(phrase).innerHTML;
    },
    
    get_parent: function Framework_AbstractComponent$get_parent() {
        return this._parent;
    },
    
    get_childID: function Framework_AbstractComponent$get_childID() {
        return this._childID;
    },
    set_childID: function Framework_AbstractComponent$set_childID(value) {
        this._childID = value;
        return value;
    },
    
    startChildren: function Framework_AbstractComponent$startChildren() {
        for (var index = 0; index < this._children.length; index++) {
            var newComponent = (this._children[index]);
            if (!isNullOrUndefined(newComponent.get_componentLifeCycleManager())) {
                newComponent.get_componentLifeCycleManager().start();
            }
            else {
                this._children[index].start();
            }
        }
    },
    
    addChild: function Framework_AbstractComponent$addChild(child) {
        var index = this._children.length;
        this._children[index] = child;
        child._parent = this;
        child._siblingIndex = index;
    },
    
    get_hasChildren: function Framework_AbstractComponent$get_hasChildren() {
        if (!this._children) {
            return false;
        }
        return this._children.length > 0;
    },
    
    get_children: function Framework_AbstractComponent$get_children() {
        return this._children;
    },
    
    getChildByID: function Framework_AbstractComponent$getChildByID(childID) {
        for (var count = 0; count < this._children.length; count++) {
            if (this._children[count].get_childID() === childID) {
                return this._children[count];
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractEnvironment

Framework.AbstractEnvironment = function Framework_AbstractEnvironment(components, dynamicComponentsConfiguration, services) {
    this._multiplexedRpcTasks = [];
    this._pageWillChangeListeners = [];
    this._transformAndUpdateQueue = [];
    Framework.AbstractEnvironment._log.debug('Creating AbstractEnvironment');
    this.components = components;
    this.dynamicComponentsConfiguration = dynamicComponentsConfiguration;
    this.services = services;
    this._componentUpdateScheduler = new Framework.Component.Updating.ComponentUpdateScheduler();
}
Framework.AbstractEnvironment.getInstance = function Framework_AbstractEnvironment$getInstance() {
    return Framework.AbstractEnvironment._singeltonAbstractEnvironment;
}
Framework.AbstractEnvironment.createInstance = function Framework_AbstractEnvironment$createInstance(components, dynamicComponents, services) {
    Framework.AbstractEnvironment._singeltonAbstractEnvironment = new Framework.AbstractEnvironment(components, dynamicComponents, services);
    return Framework.AbstractEnvironment.getInstance();
}
Framework.AbstractEnvironment.safeUpdateDomElement = function Framework_AbstractEnvironment$safeUpdateDomElement(domElementId, htmlContent) {
    var domElement = document.getElementById(domElementId);
    if (domElement) {
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.AbstractEnvironment._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
    }
}
Framework.AbstractEnvironment.safeUpdateDomElementDirect = function Framework_AbstractEnvironment$safeUpdateDomElementDirect(domElement, htmlContent) {
    if (!domElement) {
        return;
    }
    if (domElement.innerHTML === htmlContent) {
        Framework.AbstractEnvironment._log.debug(domElement.id + '.InnerHTML unchanged - not updated');
    }
    else {
        Framework.DocumentEvents.purgeEventsBeforeUpdate(domElement, true, 0);
        domElement.innerHTML = htmlContent;
    }
}
Framework.AbstractEnvironment.serializeToXml = function Framework_AbstractEnvironment$serializeToXml(instanceName, value, isKeyValue) {
    if ((!instanceName) || (!instanceName)) {
        return String.Empty;
    }
    var isArray = false;
    isArray = (value instanceof Array);;
    var type = '';
    type = (typeof value);;
    var isValue = (type === 'boolean') || (type === 'number') || (type === 'string');
    var isObject = (type === 'object');
    var isInstanceNameNumeric = false;
    isInstanceNameNumeric =  !isNaN(instanceName);
    var attributes = '';
    if (isKeyValue) {
        attributes = ' key=\"' + instanceName + '\"';
        instanceName = 'value';
    }
    if (isArray || isObject) {
        return String.format('<{0}{2}>{1}</{0}>', instanceName, Framework.AbstractEnvironment.serializeDictionaryToXml(value, isArray), attributes);
    }
    else if (isValue) {
        return String.format('<{0}>{1}</{0}>', instanceName, value);
    }
    return String.Empty;
}
Framework.AbstractEnvironment.serializeDictionaryToXml = function Framework_AbstractEnvironment$serializeDictionaryToXml(dictionary, isArray) {
    if (!dictionary) {
        return String.Empty;
    }
    var result = '';
    if (Object.getKeyCount(dictionary) > 0) {
        var $dict1 = dictionary;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.key) {
                result += Framework.AbstractEnvironment.serializeToXml(entry.key, entry.value, isArray);
            }
        }
    }
    return result;
}
Framework.AbstractEnvironment.prototype = {
    _componentUpdateScheduler: null,
    components: null,
    dynamicComponentsConfiguration: null,
    services: null,
    _state: null,
    _language: null,
    _region: null,
    _pageArea: null,
    _initialPageFilter: null,
    
    getProtocol: function Framework_AbstractEnvironment$getProtocol() {
        return window.location.protocol.split(':')[0];
    },
    
    getLanguage: function Framework_AbstractEnvironment$getLanguage() {
        return this._language;
    },
    
    getRegion: function Framework_AbstractEnvironment$getRegion() {
        return this._region;
    },
    
    getPageArea: function Framework_AbstractEnvironment$getPageArea() {
        return this._pageArea;
    },
    
    getInitialPageFilter: function Framework_AbstractEnvironment$getInitialPageFilter() {
        return this._initialPageFilter;
    },
    
    get_componentUpdateScheduler: function Framework_AbstractEnvironment$get_componentUpdateScheduler() {
        return this._componentUpdateScheduler;
    },
    
    init: function Framework_AbstractEnvironment$init(language, region, pageArea, pageFilter) {
        Framework.AbstractEnvironment._log.debug('Init');
        this._language = language;
        this._region = region;
        this._pageArea = pageArea;
        this._initialPageFilter = pageFilter;
        Framework.SDC.SDCManager.initializeSDCManager();
        if (!String.isNullOrEmpty(Framework.CustomCultureInfo.getRegionalCultureKey(this._region, this._language))) {
            this._setCurrentCulture(Framework.CustomCultureInfo.getRegionalCultureKey(this._region, this._language));
        }
        var windowNameStateKey = '_window.top.name';
        var windowNameCurrentDomainKey = '_windowNameCurrentDomain';
        var debugInfoKey = '_debugInfo';
        var stateString = Framework.WindowNameManager.getWindowName();
        if (!isNullOrUndefined(stateString) && !String.isNullOrEmpty(stateString)) {
            try {
                var state = Framework.JsonUtil.deserialize(Framework.WindowNameManager.getWindowName());
                if (state && Type.getInstanceType(state) === Object) {
                    if (Object.keyExists((state), windowNameCurrentDomainKey) && (state)[windowNameCurrentDomainKey].toString() === window.location.hostname) {
                        this._state = state;
                        Framework.WindowNameManager.setWindowName(this._state[windowNameStateKey]);
                        if (!String.isNullOrEmpty(this._state[debugInfoKey])) {
                            this._debugInfo = this._state[debugInfoKey];
                        }
                    }
                    else {
                        this._state = {};
                        Framework.WindowNameManager.setWindowName('');
                    }
                }
                else {
                    this._state = {};
                }
            }
            catch ($e1) {
                this._state = {};
            }
        }
        else {
            this._state = {};
        }
        window.attachEvent('onbeforeunload', Delegate.create(this, function() {
            this.firePageWillChangeEvent();
            this._state[windowNameStateKey] = Framework.WindowNameManager.getWindowName();
            this._state[windowNameCurrentDomainKey] = window.location.hostname;
            this._state[debugInfoKey] = this._debugInfo;
            Framework.WindowNameManager.setWindowName(Framework.JsonUtil.serialize(this._state));
        }));
    },
    
    start: function Framework_AbstractEnvironment$start() {
        Framework.AbstractEnvironment._log.debug('Start');
        this._transformAndUpdateScheduler(0);
        this.get_componentUpdateScheduler().runSchedulingRuntime(500);
        if (String.isNullOrEmpty(this._debugInfo)) {
            this._fetchDebugInfo();
        }
    },
    
    registerPageWillChangeListener: function Framework_AbstractEnvironment$registerPageWillChangeListener(pageWillChangeListener) {
        if (!this._pageWillChangeListeners.contains(pageWillChangeListener)) {
            this._pageWillChangeListeners.add(pageWillChangeListener);
        }
    },
    
    firePageWillChangeEvent: function Framework_AbstractEnvironment$firePageWillChangeEvent() {
        var $enum1 = this._pageWillChangeListeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            listener.onPageWillChange();
        }
    },
    
    createRealUrl: function Framework_AbstractEnvironment$createRealUrl(url) {
        return ((!url) ? null : url.replace('${region}', this._region).replace('${language}', this._language));
    },
    
    getDomElement: function Framework_AbstractEnvironment$getDomElement(domElementId) {
        return document.getElementById(domElementId);
    },
    
    updateDomElement: function Framework_AbstractEnvironment$updateDomElement(domElementId, htmlContent) {
        var domElement = document.getElementById(domElementId);
        if (domElement) {
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
        }
        else {
            Framework.AbstractEnvironment._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
        }
    },
    
    updateDomElementDirect: function Framework_AbstractEnvironment$updateDomElementDirect(domElement, htmlContent) {
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
    },
    
    transformAndUpdateInner: function Framework_AbstractEnvironment$transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, domElement, inMemoryProcessingCallback, xmlContent, contentUrlDelegate, useContentUrlDelegate) {
        var placeHolder = (!domElement) ? document.getElementById(domElementId) : domElement;
        if (placeHolder) {
            this.updateDomElementDirect(placeHolder, '<img src=\'/indicator.gif\' />');
            var transformAndUpdateTask = new Framework.TransformAndUpdateTask(domElementId, this.createRealUrl(contentId), xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, this, domElement, inMemoryProcessingCallback, (xmlContent) ? XMLDocumentParser.parse(xmlContent) : Framework.XMLUtils.get_emptyContentDocument(), (xmlContent) ? true : false, contentUrlDelegate, useContentUrlDelegate);
            transformAndUpdateTask.execute(true);
            return transformAndUpdateTask;
        }
        return null;
    },
    
    transformAndUpdate: function Framework_AbstractEnvironment$transformAndUpdate(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domElement, inMemoryProcessingCallback, xmlContent) {
        Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdate domElementId=[{0}] contentId=[{1}] xsltUrl=[{2}] xsltParameters=[{3}]', domElementId, contentId, xsltUrl, Framework.DictionaryUtil.dumpToString(xsltParameters)));
        this.transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, null, null, domElement, inMemoryProcessingCallback, xmlContent);
    },
    
    periodicalTransformAndUpdate: function Framework_AbstractEnvironment$periodicalTransformAndUpdate(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, inMemoryProcessingCallback, contentIdDelegate, useContentIdDelegate) {
        Framework.AbstractEnvironment._log.debug(String.format('ScheduledTransformAndUpdate domElementId=[{0}] contentId=[{1}] xsltUrl=[{2}] xsltParameters=[{3}] domain=[{4}] autoRefreshPeriod=[{5}]', domElementId, contentId, xsltUrl, Framework.DictionaryUtil.dumpToString(xsltParameters), domain, autoRefreshPeriod));
        var task = this.transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, null, inMemoryProcessingCallback, null, contentIdDelegate, useContentIdDelegate);
        if (task) {
            this._transformAndUpdateQueue.add(task);
        }
    },
    
    periodicalTransformAndUpdateWithContentUrlDelegate: function Framework_AbstractEnvironment$periodicalTransformAndUpdateWithContentUrlDelegate(domElementId, contentUrlDelegate, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod) {
        this.periodicalTransformAndUpdate(domElementId, null, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, null, contentUrlDelegate, true);
    },
    
    clearPeriodicalTransformAndUpdate: function Framework_AbstractEnvironment$clearPeriodicalTransformAndUpdate(domain) {
        Framework.AbstractEnvironment._log.debug(String.format('ClearScheduledTransformAndUpdate domain=[{0}]', domain));
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (domain !== (this._transformAndUpdateQueue[i]).get_domain()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    _transformAndUpdateScheduler: function Framework_AbstractEnvironment$_transformAndUpdateScheduler(startIndex) {
        var queue = this._transformAndUpdateQueue;
        Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdateScheduler woke up!, StartIndex=[{0}]', startIndex));
        if (queue && queue.length > 0) {
            startIndex = Math.min(startIndex, queue.length - 1);
            var i = startIndex;
            do {
                var currentTask = queue[i];
                Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdateScheduler processing task i=[{0}] LastExecuted=[{1}] AutoRefreshPeriod=[{2}]', i, currentTask.get_lastExecuted(), currentTask.get_autoRefreshPeriod()));
                i = (i + 1) % queue.length;
                if (currentTask.get_lastExecuted().getTime() + currentTask.get_autoRefreshPeriod() < Date.get_now().getTime()) {
                    currentTask.execute(true);
                    break;
                }
            } while (i !== startIndex);
            startIndex = i;
        }
        window.setTimeout(Delegate.create(this, function() {
            this._transformAndUpdateScheduler(startIndex);
        }), Framework.Parameters.transformAndUpdateSchedulerPeriod);
    },
    
    _getCallBrokerUrl: function Framework_AbstractEnvironment$_getCallBrokerUrl() {
        return '/CallBroker.ashx';
    },
    
    invoke: function Framework_AbstractEnvironment$invoke(serviceName, methodName, arguments) {
        Framework.AbstractEnvironment._log.debug('invoke serviceName = [' + serviceName + '] methodName = [' + methodName + '] arguments = [...]');
        var request = new XMLHttpRequest();
        request.open('POST', this._getCallBrokerUrl(), false);
        request.setRequestHeader('Content-Type', 'text/json');
        var requestPayload = {};
        requestPayload['serviceName'] = serviceName;
        requestPayload['methodName'] = methodName;
        requestPayload['arguments'] = arguments;
        var JSONrequestPayload = Framework.JsonUtil.serialize(requestPayload);
        request.send(JSONrequestPayload);
        var status = request.status;
        Framework.AbstractEnvironment._log.debug(String.format('Status = [{0}]', status));
        if (status === 200) {
            var response = Framework.JsonUtil.deserialize(request.responseText);
            return response['result'];
        }
        else if (status === 500) {
            try {
                var response = Framework.JsonUtil.deserialize(request.responseText);
                throw Framework.ExceptionUtil.createException(response['exceptionType'], response['message']);
            }
            catch (e) {
                Framework.AbstractEnvironment._log.error('Invoke failed', e);
                throw Framework.ExceptionUtil.createException('RemoteException', null);
            }
        }
        else {
            throw Framework.ExceptionUtil.createException('RemoteException', null);
        }
    },
    
    invokeAsync: function Framework_AbstractEnvironment$invokeAsync(serviceName, methodName, arguments, successCallback, failureCallback) {
        var rpcTask = new Framework.JsonRpcTask(serviceName, methodName, this.getLanguage(), arguments, successCallback, failureCallback);
        if (Framework.AbstractEnvironment._enableMultiplexing) {
            if (!this._multiplexedRpcTasks.length) {
                window.setTimeout(Delegate.create(this, function() {
                    var multiplexPayload = [];
                    var $enum1 = this._multiplexedRpcTasks.getEnumerator();
                    while ($enum1.moveNext()) {
                        var task = $enum1.get_current();
                        multiplexPayload.add(task.getPayloadAsDictionary());
                    }
                    var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(this._getCallBrokerUrl(), ScriptFX.Net.HTTPVerb.POST);
                    httpRequest.set_content(Framework.JsonUtil.serialize(multiplexPayload));
                    httpRequest.invoke(Delegate.create(this, function(request, context) {
                        var endTime = Date.get_now().getTime();
                        var multiplexedRpcTasks = context;
                        if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                            if (request.get_response().get_statusCode() === ScriptFX.Net.HTTPStatusCode.OK) {
                                var multiplexResponses = Framework.JsonUtil.deserialize(request.get_response().getText());
                                for (var i = 0; i < multiplexResponses.length; i++) {
                                    this._invokeSingleRpcCallback(multiplexedRpcTasks[i], multiplexResponses[i], false, Framework.SDC.SDCExceptionType.noException, endTime);
                                }
                            }
                            else {
                                var remoteExceptionResponse = { exceptionType: 'RemoteException' };
                                for (var i = 0; i < multiplexedRpcTasks.length; i++) {
                                    this._invokeSingleRpcCallback(multiplexedRpcTasks[i], remoteExceptionResponse, false, Framework.SDC.SDCExceptionType.operationalException, endTime);
                                }
                            }
                        }
                        else {
                            var remoteExceptionResponse = { exceptionType: 'RemoteException' };
                            for (var i = 0; i < multiplexedRpcTasks.length; i++) {
                                var sdcException = Framework.SDC.SDCExceptionType.noException;
                                var abortSDCLog = true;
                                if (request.get_state() === ScriptFX.Net.HTTPRequestState.timedOut) {
                                    abortSDCLog = false;
                                    sdcException = Framework.SDC.SDCExceptionType.infrastructuralException;
                                }
                                this._invokeSingleRpcCallback(multiplexedRpcTasks[i], remoteExceptionResponse, abortSDCLog, sdcException, endTime);
                            }
                        }
                    }), this._multiplexedRpcTasks);
                    this._multiplexedRpcTasks = [];
                }), 0);
            }
            this._multiplexedRpcTasks.add(rpcTask);
        }
        else {
            var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(this._getCallBrokerUrl(), ScriptFX.Net.HTTPVerb.POST);
            httpRequest.set_content(rpcTask.getRequestPayload());
            httpRequest.invoke(Delegate.create(this, function(request, context) {
                if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                    (context).processResponse(request.get_response());
                }
                else {
                    if (request.get_state() === ScriptFX.Net.HTTPRequestState.timedOut) {
                        Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog((context).getSDCToken(), '', Framework.SDC.SDCExceptionType.infrastructuralException);
                    }
                    else {
                        Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog((context).getSDCToken());
                    }
                    failureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
                }
            }), rpcTask);
        }
    },
    
    _invokeSingleRpcCallback: function Framework_AbstractEnvironment$_invokeSingleRpcCallback(jsonRpcTask, singleResponse, abortSDCLog, sdcException, endTime) {
        var exceptionType = singleResponse['exceptionType'];
        var sdcExceptionType = (sdcException === Framework.SDC.SDCExceptionType.noException && !String.isNullOrEmpty(exceptionType)) ? Framework.SDC.SDCExceptionType.callbrokerRPCException : sdcException;
        var serverToken = singleResponse['token'] || '';
        if (!abortSDCLog) {
            Framework.SDC.SDCManager.sdcManagerInstance().endMultiplexRPCLog(jsonRpcTask.getSDCToken(), serverToken, sdcExceptionType, endTime);
        }
        else {
            Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog(jsonRpcTask.getSDCToken());
        }
        window.setTimeout(Delegate.create(this, function() {
            if (String.isNullOrEmpty(exceptionType)) {
                jsonRpcTask.get_jsonRpcSuccessCallback().invoke(singleResponse['result']);
            }
            else {
                jsonRpcTask.get_jsonRpcFailureCallback().invoke(Framework.ExceptionUtil.createException(exceptionType, singleResponse['message']));
            }
        }), 0);
    },
    
    invokeAsyncUsingJsonp: function Framework_AbstractEnvironment$invokeAsyncUsingJsonp(serviceName, methodName, arguments, successCallback, failureCallback, isHttpsForced) {
        var rpcTask = new Framework.JsonRpcTask(serviceName, methodName, this.getLanguage(), arguments, successCallback, failureCallback);
        var callBrokerUrl = (isHttpsForced && String.compare(window.location.protocol, 'https:')) ? 'https://' + window.location.hostname + '/CallBroker.ashx' : '/CallBroker.ashx';
        var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(ScriptFX.Net.HTTPTransport.createURI(callBrokerUrl + '?payload=' + rpcTask.getRequestPayload(), ScriptFX.Net.ScriptTransport, null), ScriptFX.Net.HTTPVerb.GET);
        httpRequest.set_timeout(Framework.AbstractEnvironment._jsonpRequestTimeout);
        httpRequest.invoke(Delegate.create(this, function(request, context) {
            if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                (context).processResponse(request.get_response());
            }
            else {
                if (request.get_state() === ScriptFX.Net.HTTPRequestState.timedOut) {
                    Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog((context).getSDCToken(), '', Framework.SDC.SDCExceptionType.infrastructuralException);
                }
                else {
                    Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog((context).getSDCToken());
                }
                failureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
            }
        }), rpcTask);
    },
    
    storeState: function Framework_AbstractEnvironment$storeState(serviceName, state) {
        this._state[serviceName] = state;
    },
    
    getStoredState: function Framework_AbstractEnvironment$getStoredState(serviceName) {
        return this._state[serviceName];
    },
    
    _debugInfo: null,
    
    get_debugInfo: function Framework_AbstractEnvironment$get_debugInfo() {
        return this._debugInfo;
    },
    
    _fetchDebugInfo: function Framework_AbstractEnvironment$_fetchDebugInfo() {
        Framework.AbstractEnvironment._log.debug('FetchDebugInfo');
        this.invokeAsync('DebugService', 'GetDebugInfo', {}, Delegate.create(this, function(result) {
            this._debugInfo = result;
        }), Delegate.create(this, function(exception) {
        }));
    },
    
    getCookie: function Framework_AbstractEnvironment$getCookie(name) {
        return Framework.CookieUtil.getCookie(name);
    },
    
    setCookie: function Framework_AbstractEnvironment$setCookie(name, value) {
        Framework.CookieUtil.setCookie(name, value);
    },
    
    setCookieWithDays: function Framework_AbstractEnvironment$setCookieWithDays(name, value, numberOfDays) {
        Framework.CookieUtil.setCookieWithDays(name, value, numberOfDays);
    },
    
    clearCookie: function Framework_AbstractEnvironment$clearCookie(name) {
        Framework.CookieUtil.clearCookie(name);
    },
    
    clearCookies: function Framework_AbstractEnvironment$clearCookies() {
        Framework.CookieUtil.clearCookies();
    },
    
    _setCurrentCulture: function Framework_AbstractEnvironment$_setCurrentCulture(cultureKey) {
        var cultures = Framework.CustomCultureInfo.getCustomCultures();
        if (Object.keyExists(cultures, cultureKey) && Type.getInstanceType(cultures[cultureKey]) === CultureInfo) {
            CultureInfo.Current = cultures[cultureKey];
        }
    },
    
    getBaselineUrl: function Framework_AbstractEnvironment$getBaselineUrl(isSecure) {
        return window.location.href.substr(0, window.location.href.toUpperCase().indexOf('AREAS')).replace(new RegExp('^http[s]*:'), (isSecure) ? 'https:' : 'http:');
    },
    
    _calculateHash: function Framework_AbstractEnvironment$_calculateHash(pageFilter, putHashOnStart) {
        var result = (putHashOnStart) ? '#' : String.Empty;
        var current = 0;
        var $dict1 = pageFilter;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (!String.isNullOrEmpty(entry.key) && !String.isNullOrEmpty(entry.value)) {
                result += String.format('{0}{1}={2}', (!current++) ? String.Empty : '&', entry.key, entry.value);
            }
        }
        return result;
    },
    
    getHash: function Framework_AbstractEnvironment$getHash(pageFilter) {
        throw new Error('Not implemented');
    },
    
    setHash: function Framework_AbstractEnvironment$setHash(pageFilter) {
        var hash = this._calculateHash(pageFilter, false);
        if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
            try {
                var historyManager = ScriptFX.Application.current.get_history();
                if (historyManager) {
                    historyManager.addEntry(hash);
                }
            }
            catch ($e1) {
            }
        }
        window.location.hash = hash;
    },
    
    changeLocation: function Framework_AbstractEnvironment$changeLocation(pageArea, pageFilter, storeServicesStates, protocol) {
        this.firePageWillChangeEvent();
        var url = '/Areas/' + pageArea + '/Template_' + this._region + '_' + this._language + '/index.html';
        var hash = this._calculateHash(pageFilter, false);
        if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
            ScriptFX.Application.current.get_history().addEntry(hash);
        }
        var completeURL = '';
        if (!String.isNullOrEmpty(protocol)) {
            completeURL = String.format('{0}://{1}{2}{3}', protocol, window.location.hostname, ((window.location.port.toString() === '') || (window.location.port === 80) || (window.location.port === 443)) ? '' : (':' + window.location.port), url);
            window.navigate(completeURL + '#' + hash);
        }
        else {
            window.navigate(url + '#' + hash);
        }
    },
    
    buildUrl: function Framework_AbstractEnvironment$buildUrl(pageArea, pageFilter, protocol) {
        var url = '/Areas/' + pageArea + '/Template_' + this._region + '_' + this._language + '/index.html';
        var isFirst = true;
        var $dict1 = pageFilter;
        for (var $key2 in $dict1) {
            var dictionaryEntry = { key: $key2, value: $dict1[$key2] };
            if (dictionaryEntry.key && dictionaryEntry.value) {
                url += String.format('{0}{1}={2}', ((isFirst) ? '#' : '&'), dictionaryEntry.key, dictionaryEntry.value);
                isFirst = false;
            }
        }
        if (String.isNullOrEmpty(window.location.port.toString())) {
            url = String.format('{0}://{1}{2}', (String.isNullOrEmpty(protocol)) ? this.getProtocol() : protocol, window.location.hostname, url);
        }
        return url;
    },
    
    changeRegion: function Framework_AbstractEnvironment$changeRegion(region, pageArea, pageFilter) {
        this._region = region;
        this.changeLocation(pageArea, pageFilter, true, String.Empty);
    },
    
    changeLanguage: function Framework_AbstractEnvironment$changeLanguage(language, pageArea, pageFilter) {
        this._language = language;
        this.changeLocation(pageArea, pageFilter, true, String.Empty);
    },
    
    safelySetCssClass: function Framework_AbstractEnvironment$safelySetCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        this.safelySetCssClassOnElement(element, className);
    },
    
    safelyRemoveCssClass: function Framework_AbstractEnvironment$safelyRemoveCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        this.safelyRemoveCssClassOnElement(element, className);
    },
    
    safelySetAndUnsetCssClass: function Framework_AbstractEnvironment$safelySetAndUnsetCssClass(domElementId, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(domElementId) || String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        var element = document.getElementById(domElementId);
        this.safelySetAndUnsetCssClassOnElement(element, classNameToSet, classNameToUnset);
    },
    
    safelySetAndUnsetCssClassIf: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassIf(value, domElementId, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(domElementId) || String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        var element = document.getElementById(domElementId);
        this.safelySetAndUnsetCssClassOnElementIf(value, element, classNameToSet, classNameToUnset);
    },
    
    containsCssClass: function Framework_AbstractEnvironment$containsCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        return this.containsCssClassOnElement(element, className);
    },
    
    safelySetCssClassOnElement: function Framework_AbstractEnvironment$safelySetCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            ScriptFX.UI.Element.addCSSClass(domElement, className);
        }
    },
    
    safelyRemoveCssClassOnElement: function Framework_AbstractEnvironment$safelyRemoveCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            ScriptFX.UI.Element.removeCSSClass(domElement, className);
        }
    },
    
    safelySetAndUnsetCssClassOnElement: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassOnElement(domElement, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        if (domElement) {
            ScriptFX.UI.Element.addCSSClass(domElement, classNameToSet);
            ScriptFX.UI.Element.removeCSSClass(domElement, classNameToUnset);
        }
    },
    
    safelySetAndUnsetCssClassOnElementIf: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassOnElementIf(value, domElement, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        if (domElement) {
            if (value) {
                ScriptFX.UI.Element.addCSSClass(domElement, classNameToSet);
                ScriptFX.UI.Element.removeCSSClass(domElement, classNameToUnset);
            }
            else {
                ScriptFX.UI.Element.addCSSClass(domElement, classNameToUnset);
                ScriptFX.UI.Element.removeCSSClass(domElement, classNameToSet);
            }
        }
    },
    
    containsCssClassOnElement: function Framework_AbstractEnvironment$containsCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            return ScriptFX.UI.Element.containsCSSClass(domElement, className);
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractService

Framework.AbstractService = function Framework_AbstractService() {
}
Framework.AbstractService.prototype = {
    _environment: null,
    _parameters: null,
    
    init: function Framework_AbstractService$init(environment, parameters) {
        this._environment = environment;
        this._parameters = parameters;
    },
    
    hello: function Framework_AbstractService$hello(name) {
        var arguments = {};
        arguments['name'] = name;
        return this._environment.invoke(Type.getInstanceType(this).get_name(), 'Hello', arguments);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ComponentInfo

Framework.ComponentInfo = function Framework_ComponentInfo(positionName, componentName, componentNameOri) {
    this.positionName = positionName;
    this.componentName = componentName;
    this.componentNameOri = componentNameOri;
}
Framework.ComponentInfo.prototype = {
    positionName: null,
    componentName: null,
    componentNameOri: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.PagerCall

Framework.PagerCall = function Framework_PagerCall(action, pagenumber, args) {
    this.action = action;
    this.pagenumber = pagenumber;
    this.args = args;
}
Framework.PagerCall.prototype = {
    action: null,
    pagenumber: 0,
    args: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.MessageIndicators

Framework.MessageIndicators = function Framework_MessageIndicators() {
}
Framework.MessageIndicators.getIndicator = function Framework_MessageIndicators$getIndicator(key, prefix) {
    if (isNullOrUndefined(prefix)) {
        prefix = 'messageIndicator_';
    }
    var indicatorCtl = document.getElementById(prefix + key);
    if (isNullOrUndefined(indicatorCtl)) {
        return 'false';
    }
    return indicatorCtl.value;
}
Framework.MessageIndicators.isIndicatorTrue = function Framework_MessageIndicators$isIndicatorTrue(key, prefix) {
    return Framework.MessageIndicators.getIndicator(key, prefix) === Framework.MessageIndicators.trueVal;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Pager

Framework.Pager = function Framework_Pager() {
}
Framework.Pager.getPage = function Framework_Pager$getPage(containerId, action, pagenumber, args, onCompleteDelegate) {
    var container = document.getElementById(containerId);
    if (!container) {
        return;
    }
    Framework.AbstractEnvironment.safeUpdateDomElementDirect(container, '<span class=\'waiting\'>&nbsp;</span>Loading, please wait...');
    Framework.PagerLastCall.setLastCall(containerId + '|' + action, new Framework.PagerCall(action, pagenumber, args));
    if (!onCompleteDelegate) {
        onCompleteDelegate = Framework.Pager.defaultCallBack;
    }
    var url = String.format('{0}.rails?pagenumber={1}', action, pagenumber);
    var $dict1 = args;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        url += String.format('&{0}={1}', entry.key, entry.value);
    }
    var ajax = new Framework.AjaxUpdater(containerId, url, onCompleteDelegate, null);
    ajax.evalScripts = true;
    ajax.update();
}
Framework.Pager.getPageAgain = function Framework_Pager$getPageAgain(containerId, action, defaultargs, onCompleteDelegate) {
    var lastCall = Framework.PagerLastCall.getLastCall(containerId + '|' + action);
    if (lastCall) {
        Framework.Pager.getPage(containerId, lastCall.action, lastCall.pagenumber, lastCall.args, onCompleteDelegate);
    }
    else {
        Framework.Pager.getPage(containerId, action, 1, defaultargs, onCompleteDelegate);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.PagerLastCall

Framework.PagerLastCall = function Framework_PagerLastCall() {
}
Framework.PagerLastCall.setLastCall = function Framework_PagerLastCall$setLastCall(key, args) {
    Framework.PagerLastCall._callsByContainerId[key] = args;
}
Framework.PagerLastCall.getLastCall = function Framework_PagerLastCall$getLastCall(key) {
    var o = Framework.PagerLastCall._callsByContainerId[key];
    return ((!o) ? null : o);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.BubblingEvent

Framework.BubblingEvent = function Framework_BubblingEvent() {
}
Framework.BubblingEvent.parse = function Framework_BubblingEvent$parse(evt) {
    return ((evt));
}
Framework.BubblingEvent.prototype = {
    
    stopPropagation: function Framework_BubblingEvent$stopPropagation() {
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminClassNames

Framework.AdminClassNames = function Framework_AdminClassNames() {
}
Framework.AdminClassNames.prototype = {
    placeHolder: null,
    component: null,
    placeHolderHover: null,
    placeHolderSelected: null,
    parameter: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminUrls

Framework.AdminUrls = function Framework_AdminUrls() {
}
Framework.AdminUrls.prototype = {
    showParams: null,
    removeComponent: null,
    storeParams: null,
    save: null,
    revert: null,
    back: null,
    findComponents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminPageIds

Framework.AdminPageIds = function Framework_AdminPageIds() {
}
Framework.AdminPageIds.prototype = {
    componentToolboxId: null,
    pageAreaToolboxId: null,
    adminMessageToolboxId: null,
    propertiesToolboxId: null,
    areaname: null,
    componentPropertiesId: null,
    messageBoxId: null,
    componentListId: null,
    savebuttonId: null,
    revertButtonId: null,
    backbuttonId: null,
    componentNameFilterId: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminUtil

Framework.AdminUtil = function Framework_AdminUtil() {
}
Framework.AdminUtil.prototype = {
    wiring: null,
    showMessage: null,
    currentComponentConfiguration: null,
    showComponentProperties: null,
    getElementsBySelector: null,
    cancelEdit: null,
    parseIndicators: null,
    
    isElementVisible: function Framework_AdminUtil$isElementVisible(id) {
        var element = document.getElementById(id);
        if (element && element.style.display.toLowerCase() !== 'none') {
            return true;
        }
        return false;
    },
    
    setVisibilityById: function Framework_AdminUtil$setVisibilityById(elementId, visible) {
        this.setVisibility(document.getElementById(elementId), visible);
    },
    
    setVisibility: function Framework_AdminUtil$setVisibility(element, visible) {
        if (element) {
            element.style.display = ((visible) ? '' : 'none');
        }
    },
    
    isToolboxElement: function Framework_AdminUtil$isToolboxElement(element) {
        if (element && element.tagName === 'SPAN' && element.parentNode.tagName === 'LI') {
            return true;
        }
        else {
            return false;
        }
    },
    
    setToolBoxVisibility: function Framework_AdminUtil$setToolBoxVisibility(visible, ids) {
        this.setVisibilityById(ids.componentToolboxId, visible);
        this.setVisibilityById(ids.pageAreaToolboxId, visible);
        this.setVisibilityById(ids.adminMessageToolboxId, visible);
    },
    
    confirmation: function Framework_AdminUtil$confirmation(componentName, positionName, action) {
        var c = confirm(String.format('Are you sure you want to {0} {1} in {2}?', action, componentName, positionName));
        if (c) {
            return true;
        }
        else {
            return false;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminDragController

Framework.AdminDragController = function Framework_AdminDragController(dragArgs, util, ids) {
    this._dragstartLocation = new Framework.Position(0, 0);
    this._args = dragArgs;
    this._ids = ids;
    this._util = util;
}
Framework.AdminDragController.prototype = {
    _ids: null,
    _args: null,
    _util: null,
    _isDragging: false,
    _currentDrop: null,
    
    isDragging: function Framework_AdminDragController$isDragging() {
        return this._isDragging;
    },
    
    getCurrentDrop: function Framework_AdminDragController$getCurrentDrop() {
        return this._currentDrop;
    },
    
    onDragComponentStart: function Framework_AdminDragController$onDragComponentStart(e) {
        this._isDragging = true;
        var pos = Framework.DragController.getAbsolutePosition(e.srcElement);
        Framework.Droppables.setOffset(pos.x, pos.y);
        return false;
    },
    
    onDragComponentEnd: function Framework_AdminDragController$onDragComponentEnd(obj, x, y) {
        this._isDragging = false;
        this._util.cancelEdit.invoke();
        if (!obj) {
            return;
        }
        this._args.dragsRefresh.invoke();
        var drop = Framework.Droppables.getDroppable(x, y);
        if (!drop) {
            return;
        }
        this._util.currentComponentConfiguration = null;
        this._util.showComponentProperties.invoke(drop.id, obj.id);
        this._util.setToolBoxVisibility(false, this._ids);
    },
    
    onDrag: function Framework_AdminDragController$onDrag(obj, x, y) {
        var drop = Framework.Droppables.getDroppable(x, y);
        if (!drop || drop !== this._currentDrop) {
            if (this._currentDrop) {
                this._currentDrop.className = this._args.dropClassName;
            }
            if (drop) {
                drop.className = this._args.dropHoverClassName;
            }
            this._currentDrop = drop;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminController

Framework.AdminController = function Framework_AdminController(util, classNames, urls, ids) {
    this._ids = ids;
    this._util = util;
    if (isNullOrUndefined(util.parseIndicators)) {
        util.parseIndicators = Delegate.create(this, this.parseIndicators);
    }
    if (isNullOrUndefined(util.showComponentProperties)) {
        util.showComponentProperties = Delegate.create(this, this.showComponentProperties);
    }
    if (isNullOrUndefined(util.showMessage)) {
        util.showMessage = Delegate.create(this, this.showMessage);
    }
    if (isNullOrUndefined(util.cancelEdit)) {
        util.cancelEdit = Delegate.create(this, this.cancelComponentEditing);
    }
    var dragArgs = new Framework.DragArgs();
    dragArgs.dragsRefresh = Delegate.create(this, this.refreshComponents);
    dragArgs.dropClassName = classNames.placeHolder;
    dragArgs.dropHoverClassName = classNames.placeHolderHover;
    dragArgs.dragClassName = classNames.component;
    this._dragController = new Framework.AdminDragController(dragArgs, util, ids);
    this._classNames = classNames;
    this._urls = urls;
    this.componentOnClickHandler = Delegate.create(this, this.componentOnClickHandle);
    var ctl = document.getElementById(this._ids.backbuttonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.goBack));
    }
    ctl = document.getElementById(this._ids.savebuttonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.saveArea));
    }
    ctl = document.getElementById(this._ids.revertButtonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.revertArea));
    }
    ctl = document.getElementById(this._ids.componentNameFilterId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onkeyup', Delegate.create(this, this.findComponentsHandler));
    }
    this.findComponents('');
    this.buildIndexMaps();
}
Framework.AdminController.prototype = {
    _ids: null,
    _urls: null,
    _util: null,
    _dragController: null,
    _classNames: null,
    _editingComponent: null,
    _currentComponentConfiguration: null,
    _storedComponentInfo: null,
    _ComponentIndexMap: null,
    _PlaceHolderNextIndexMap: null,
    
    buildIndexMaps: function Framework_AdminController$buildIndexMaps() {
        this._ComponentIndexMap = {};
        this._PlaceHolderNextIndexMap = {};
        var positions = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolder);
        if (!isNullOrUndefined(positions)) {
            for (var i = 0; i < positions.length; i++) {
                var components = positions[i].childNodes;
                var nextIndex = 0;
                if (!isNullOrUndefined(components)) {
                    for (var j = 0; j < components.length; j++) {
                        if (!isNullOrUndefined(components[j].id)) {
                            this._ComponentIndexMap[components[j].id] = nextIndex;
                            nextIndex++;
                        }
                    }
                }
                this._PlaceHolderNextIndexMap[positions[i].id] = nextIndex;
            }
        }
    },
    
    getComponentIndex: function Framework_AdminController$getComponentIndex(componentName) {
        return this._ComponentIndexMap[componentName];
    },
    
    setComponentIndex: function Framework_AdminController$setComponentIndex(componentName, index) {
        this._ComponentIndexMap[componentName] = index;
    },
    
    getNextComponentIndex: function Framework_AdminController$getNextComponentIndex(placeholderName) {
        var next = this._PlaceHolderNextIndexMap[placeholderName];
        if (isNullOrUndefined(next)) {
            next = 0;
        }
        this._PlaceHolderNextIndexMap[placeholderName] = next + 1;
        return next;
    },
    
    setUpDraggables: function Framework_AdminController$setUpDraggables() {
        var containers = this._util.getElementsBySelector.invoke('.' + this._classNames.component);
        for (var i = 0; i < containers.length; i++) {
            var d = containers[i];
            if (d && this._util.isToolboxElement(d)) {
                var dctl = new Framework.DragController(d, null, null, null, null, null, false, false, null, null);
                d.onDragEnd = Delegate.create(this._dragController, this._dragController.onDragComponentEnd);
                d.onDrag = Delegate.create(this._dragController, this._dragController.onDrag);
                d.onDragStart = Delegate.create(this._dragController, this._dragController.onDragComponentStart);
            }
        }
    },
    
    showMessage: function Framework_AdminController$showMessage(message) {
        var e = document.getElementById(this._ids.messageBoxId);
        if (!isNullOrUndefined(e)) {
            this._util.setVisibility(e.parentNode, true);
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(e, '<span class=\'waiting\'>&nbsp;</span>' + message);
        }
    },
    
    setUpDroppables: function Framework_AdminController$setUpDroppables() {
        var positions = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolder);
        for (var i = 0; i < positions.length; i++) {
            positions[i].innerHTML = positions[i].innerHTML + '&nbsp;';
            Framework.Droppables.add(positions[i]);
        }
    },
    
    setUpClickables: function Framework_AdminController$setUpClickables() {
        var allComponents = this._util.getElementsBySelector.invoke('.' + this._classNames.component);
        for (var i = 0; i < allComponents.length; i++) {
            if (allComponents[i] && !this._util.isToolboxElement(allComponents[i])) {
                this.setComponentClick(allComponents[i]);
            }
        }
    },
    
    setComponentClick: function Framework_AdminController$setComponentClick(element) {
        try {
            if (isNullOrUndefined(element)) {
                return;
            }
            if (isNullOrUndefined(element.tagName)) {
                return;
            }
            if (element.tagName.toUpperCase() === 'A') {
                element.setAttribute('href', '#');
                element.setAttribute('onclick', 'return false;');
            }
            if (element.tagName.toUpperCase() === 'INPUT') {
                element.setAttribute('onclick', 'return false;');
            }
            element.attachEvent('onclick', this.componentOnClickHandler);
            var childNodes = element.childNodes;
            if (!childNodes) {
                return;
            }
            for (var i = 0; i < childNodes.length; i++) {
                this.setComponentClick(childNodes[i]);
            }
        }
        catch ($e1) {
        }
    },
    
    getElementForClassNames: function Framework_AdminController$getElementForClassNames(element, classNames) {
        var $enum1 = classNames.getEnumerator();
        while ($enum1.moveNext()) {
            var className = $enum1.get_current();
            if (element.className === className) {
                return element;
            }
        }
        var parent = element.parentNode;
        if (parent) {
            return this.getElementForClassNames(parent, classNames);
        }
        return null;
    },
    
    getPlaceHolder: function Framework_AdminController$getPlaceHolder(element) {
        return this.getElementForClassNames(element, [ this._classNames.placeHolder, this._classNames.placeHolderHover ]);
    },
    
    getComponent: function Framework_AdminController$getComponent(element) {
        return this.getElementForClassNames(element, [ this._classNames.component ]);
    },
    
    componentOnClick: function Framework_AdminController$componentOnClick(evt) {
        var placeHolder = this.getPlaceHolder(evt.srcElement);
        var component = this.getComponent(evt.srcElement);
        if (placeHolder && component) {
            window.event.cancelBubble = true;
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
                window.event.cancelBubble = true;
            }
            else {
                Framework.BubblingEvent.parse(evt).stopPropagation();
            }
            this.editPositionComponent(component.id, placeHolder.id);
        }
    },
    
    checkComponentProperties: function Framework_AdminController$checkComponentProperties() {
        var hasUnfilledParams = document.getElementById('hasUnfilledParams');
        if (!this._editingComponent && hasUnfilledParams && hasUnfilledParams.value === 'False') {
            this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
            var positionName = document.getElementById('positionName');
            var componentName = document.getElementById('componentName');
            var componentIndex = document.getElementById('componentIndex');
            if (!isNullOrUndefined(positionName) && !isNullOrUndefined(componentName) && !isNullOrUndefined(componentIndex)) {
                this.saveParameters(positionName.value, componentName.value, Number.parse(componentIndex.value));
            }
        }
    },
    
    showComponentProperties: function Framework_AdminController$showComponentProperties(positionName, componentName) {
        var propertiesToolbox = document.getElementById(this._ids.propertiesToolboxId);
        if (isNullOrUndefined(propertiesToolbox)) {
            return;
        }
        var propertiesContainer = document.getElementById(this._ids.componentPropertiesId);
        if (isNullOrUndefined(propertiesContainer)) {
            return;
        }
        var index = this.getComponentIndex(componentName);
        if (isNullOrUndefined(index)) {
            index = this.getNextComponentIndex(positionName);
        }
        this._util.setVisibility(propertiesToolbox, true);
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(propertiesContainer, '<span class=\'waiting\'>&nbsp;</span>Loading, please wait...');
        var url = String.format('{0}.rails?areaname={1}&positionName={2}&componentName={3}&componentIndex={4}', this._urls.showParams, this._ids.areaname, positionName, componentName, index);
        var ajax = new Framework.AjaxUpdater(this._ids.componentPropertiesId, url, Delegate.create(this, this.checkComponentProperties), null);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    clearSelections: function Framework_AdminController$clearSelections() {
        var allComponents = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolderSelected);
        for (var i = 0; i < allComponents.length; i++) {
            allComponents[i].className = this._classNames.component;
        }
    },
    
    editPositionComponent: function Framework_AdminController$editPositionComponent(componentName, positionName) {
        if (this.isAddingComponent()) {
            return;
        }
        this.clearSelections();
        this._editingComponent = document.getElementById(componentName);
        this._currentComponentConfiguration = this._util.wiring.getComponentConfiguration(componentName);
        this.showComponentProperties(positionName, componentName);
    },
    
    cancelAddComponent: function Framework_AdminController$cancelAddComponent(positionName, componentName, index) {
        this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
        this._util.setVisibilityById(this._ids.adminMessageToolboxId, false);
        this._util.setVisibilityById(this._ids.componentToolboxId, true);
        var position = document.getElementById(positionName);
        if (position) {
            position.className = this._classNames.placeHolder;
        }
        this._editingComponent = null;
    },
    
    isAddingComponent: function Framework_AdminController$isAddingComponent() {
        if (this._dragController.isDragging()) {
            return true;
        }
        document.getElementById(this._ids.componentToolboxId);
        return !this._util.isElementVisible(this._ids.componentToolboxId);
    },
    
    removeComponent: function Framework_AdminController$removeComponent(positionName, componentName, index) {
        var args = String.format('areaname={0}&positionName={1}&componentName={2}&componentIndex={3}', this._ids.areaname, positionName, componentName, index);
        this._util.showMessage.invoke('Removing component parameter values, please wait...');
        var url = String.format('{0}.rails?{1}', this._urls.removeComponent, args);
        var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    saveParameters: function Framework_AdminController$saveParameters(positionName, componentName, index) {
        var args = String.format('areaname={0}&positionName={1}&componentName={2}&componentIndex={3}', this._ids.areaname, positionName, componentName, index);
        if (!this._currentComponentConfiguration) {
            this._currentComponentConfiguration = new Framework.ComponentConfiguration(componentName + '.' + componentName, null, new Array(0), {}, null, {});
        }
        this.setComponentIndex(componentName, index);
        var nextIndex = this._PlaceHolderNextIndexMap[positionName];
        if (index >= nextIndex) {
            this._PlaceHolderNextIndexMap[positionName] = index + 1;
        }
        var allParameters = this._util.getElementsBySelector.invoke('.' + this._classNames.parameter);
        for (var i = 0; i < allParameters.length; i++) {
            var node = allParameters[i];
            args += '&' + node.id + '=';
            if (node.type.toLowerCase() === 'checkbox') {
                this._currentComponentConfiguration.parameters[node.id] = (node).checked;
                args += (node).checked;
            }
            else {
                this._currentComponentConfiguration.parameters[node.id] = node.value;
                args += node.value;
            }
        }
        this._util.showMessage.invoke('Storing component parameter values, please wait...');
        var url = String.format('{0}.rails?{1}', this._urls.storeParams, args);
        var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
        var componentNameOri = componentName;
        var componentNameOriElement = document.getElementById('componentNameOri');
        if (!isNullOrUndefined(componentNameOriElement)) {
            componentNameOri = componentNameOriElement.value;
        }
        this._storedComponentInfo = new Framework.ComponentInfo(positionName, componentNameOri, componentNameOri);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    ensureComponent: function Framework_AdminController$ensureComponent(positionName, componentName) {
        if (this._editingComponent) {
            this._util.wiring.updateComponent(this._storedComponentInfo.componentNameOri, this._currentComponentConfiguration);
        }
        else {
            this._util.wiring.addComponent(this._storedComponentInfo.componentNameOri, this._currentComponentConfiguration, positionName);
        }
        this._currentComponentConfiguration = null;
    },
    
    saveArea: function Framework_AdminController$saveArea() {
        if (this._util.confirmation('all changes', this._ids.areaname, 'save')) {
            this._util.showMessage.invoke('Saving all stored values, please wait...');
            var url = String.format('{0}.rails?areaname={1}', this._urls.save, this._ids.areaname);
            var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
            ajax.evalScripts = true;
            ajax.update();
        }
    },
    
    revertArea: function Framework_AdminController$revertArea() {
        if (this._util.confirmation('all unsaved changes', this._ids.areaname, 'undo')) {
            this._util.showMessage.invoke('Undoing all stored values, please wait...');
            var url = String.format('{0}.rails?areaname={1}', this._urls.revert, this._ids.areaname);
            var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
            ajax.evalScripts = true;
            ajax.update();
        }
    },
    
    findComponentsHandler: function Framework_AdminController$findComponentsHandler() {
        var evt = this._getWindowEvent();
        var ctl = evt.srcElement;
        var findString = '';
        if (!isNullOrUndefined(ctl)) {
            findString = ctl.value;
        }
        this.findComponents(findString);
    },
    
    findComponents: function Framework_AdminController$findComponents(findString) {
        Framework.Pager.getPage(this._ids.componentListId, this._urls.findComponents, 1, { nameContains: findString }, null);
    },
    
    refreshComponents: function Framework_AdminController$refreshComponents() {
        Framework.Pager.getPageAgain(this._ids.componentListId, this._urls.findComponents, { nameContains: '' }, null);
    },
    
    goBack: function Framework_AdminController$goBack() {
        window.navigate(this._urls.back);
    },
    
    componentOnClickHandle: function Framework_AdminController$componentOnClickHandle() {
        this.componentOnClick(this._getWindowEvent());
    },
    
    componentOnClickHandler: null,
    
    _getWindowEvent: function Framework_AdminController$_getWindowEvent() {
        return window.event;
    },
    
    parseIndicators: function Framework_AdminController$parseIndicators() {
        var runForAdmin = false;
        if (Framework.MessageIndicators.isIndicatorTrue('RemoveComponent', null)) {
            if (this._editingComponent) {
                runForAdmin = true;
                this._util.wiring.removeComponent(this._editingComponent.id);
                this._currentComponentConfiguration = null;
            }
        }
        if (Framework.MessageIndicators.isIndicatorTrue('ShowComponents', null)) {
            this._util.setVisibilityById(this._ids.componentToolboxId, true);
            this._util.setVisibilityById(this._ids.pageAreaToolboxId, true);
            var currentDrop = this._dragController.getCurrentDrop();
            if (!isNullOrUndefined(currentDrop)) {
                currentDrop.className = this._classNames.placeHolder;
                currentDrop = null;
            }
            if (!isNullOrUndefined(this._storedComponentInfo)) {
                runForAdmin = true;
                this.ensureComponent(this._storedComponentInfo.positionName, this._storedComponentInfo.componentName);
            }
            this._storedComponentInfo = null;
        }
        if (Framework.MessageIndicators.isIndicatorTrue('HideParameters', null)) {
            this.cancelComponentEditing();
        }
        if (Framework.MessageIndicators.isIndicatorTrue('RevertAll', null)) {
            eval('window.location.reload();');
        }
        if (runForAdmin) {
            this._util.wiring.runForAdmin();
            window.setTimeout(Delegate.create(this, this.setUpClickables), 1000);
            window.setTimeout(Delegate.create(this, this.buildIndexMaps), 1000);
        }
    },
    
    cancelComponentEditing: function Framework_AdminController$cancelComponentEditing() {
        if (!isNullOrUndefined(this._editingComponent)) {
            this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
            this.clearSelections();
            this._editingComponent = null;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AutoWiring

Framework.AutoWiring = function Framework_AutoWiring() {
    this._services = {};
    this._components = {};
    this._dynamicComponents = {};
}
Framework.AutoWiring.prototype = {
    _serviceConfiguration: null,
    _componentConfiguration: null,
    _componentPlacementMap: null,
    _environment: null,
    
    getComponents: function Framework_AutoWiring$getComponents() {
        return this._components;
    },
    
    getServices: function Framework_AutoWiring$getServices() {
        return this._services;
    },
    
    init: function Framework_AutoWiring$init(servicesConfigurations, componentsConfiguration, dynamicComponentsConfiguration, componentsPlacementMap, encodedXsltDocumentsMap) {
        this._serviceConfiguration = servicesConfigurations;
        this._componentConfiguration = componentsConfiguration;
        this._dynamicComponents = dynamicComponentsConfiguration;
        this._componentPlacementMap = componentsPlacementMap;
        var $dict1 = encodedXsltDocumentsMap;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var document = XMLDocumentParser.parse(entry.value);
            Framework.Component.Updating.UpdateXsltBasedComponentTask.storeXsltDocument(entry.key, document);
            Framework.TransformAndUpdateTask.storeXsltDocument(entry.key, document);
        }
    },
    
    _initDebuggingLayer: function Framework_AutoWiring$_initDebuggingLayer() {
        var div1 = document.createElement('div');
        div1.setAttribute('class', 'debug-layer');
        var img = document.createElement('img');
        img.setAttribute('alt', 'debug');
        img.setAttribute('src', '../../../bug.png');
        img.setAttribute('onclick', 'if ($(\'debug-area\').style.display == \'none\') $(\'debug-area\').style.display = \'block\'; else $(\'debug-area\').style.display = \'none\';');
        div1.appendChild(img);
        var div2 = document.createElement('div');
        div2.setAttribute('id', 'debug-area');
        div2.setAttribute('class', 'debug-area');
        div2.setAttribute('style', 'display : none');
        div1.appendChild(div2);
        var input1 = document.createElement('input');
        input1.setAttribute('type', 'button');
        input1.setAttribute('value', 'Clear Debug');
        input1.setAttribute('onclick', '$(\'debug\').innerHTML=\'\';');
        div2.appendChild(input1);
        var input2 = document.createElement('input');
        input2.setAttribute('type', 'button');
        input2.setAttribute('value', 'Switch');
        input2.setAttribute('onclick', 'Framework._log.switchLogging();');
        div2.appendChild(input2);
        var br = document.createElement('br');
        div2.appendChild(br);
        var div3 = document.createElement('div');
        div3.setAttribute('id', 'debug');
        div3.setAttribute('class', 'debug');
        div2.appendChild(div3);
        document.getElementsByTagName('body')[0].insertBefore(div1, document.getElementsByTagName('body')[0].childNodes[0]);
    },
    
    _initEnvironment: function Framework_AutoWiring$_initEnvironment() {
        Framework.AutoWiring._log.debug('InitEnvironment');
        var initialPageFilter = {};
        var parts = (new RegExp('/([^/]*)/[Tt][Ee][Mm][Pp][Ll][Aa][Tt][Ee]_([^_]*)_([^/]*)/')).exec(window.location.toString());
        var initialPageArea = parts[1];
        Framework.AutoWiring._log.debug('Extracted initial page area ' + initialPageArea);
        var initialRegion = parts[2];
        Framework.AutoWiring._log.debug('Extracted initial region ' + initialRegion);
        var initialLanguage = parts[3];
        Framework.AutoWiring._log.debug('Extracted initial language ' + initialLanguage);
        var searchTokens = ((window.location.search.startsWith('?')) ? window.location.search.substr(1) : window.location.search).split(new RegExp('\\&|='));
        var debug = false;
        for (var i = 0; i < searchTokens.length; i += 2) {
            var name = searchTokens[i];
            var value = (i + 1 < searchTokens.length) ? searchTokens[i + 1] : null;
            if (String.equals('debug', name, true)) {
                this._initDebuggingLayer();
                Framework.Logger.switchLogging();
                debug = true;
            }
            else if (String.equals('maxlogsize', name, true)) {
                Framework.Logger.setMaximumLogSize(Number.parse(value));
            }
            else {
                initialPageFilter[name] = value;
            }
        }
        var hashTokens = ((window.location.hash.startsWith('#')) ? window.location.hash.substr(1) : window.location.hash).split(new RegExp('\\&|='));
        for (var i = 0; i < hashTokens.length; i += 2) {
            var name = hashTokens[i];
            var value = (i + 1 < hashTokens.length) ? hashTokens[i + 1] : null;
            Framework.AutoWiring._log.debug(String.format('Processing hash tokens [{0}] [{1}]', name, value));
            if (value) {
                initialPageFilter[name] = value;
            }
        }
        Framework.AbstractEnvironment._debugMode = debug;
        this._environment = Framework.AbstractEnvironment.createInstance(this._components, this._dynamicComponents, this._services);
        this._environment.init(initialLanguage, initialRegion, initialPageArea, initialPageFilter);
    },
    
    _initServices: function Framework_AutoWiring$_initServices() {
        Framework.AutoWiring._log.debug('InitServices');
        var $dict1 = this._serviceConfiguration;
        for (var $key2 in $dict1) {
            var serviceConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var serviceName = serviceConfigurationDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Processing {0}', serviceName));
            var serviceConfiguration = serviceConfigurationDictionaryEntry.value;
            var serviceType = Type.getType(serviceConfiguration.className);
            var service = new serviceType();
            this._services[serviceName] = service;
            service.init(this._environment, serviceConfiguration.parameters);
        }
        var $dict3 = this._services;
        for (var $key4 in $dict3) {
            var serviceDictionaryEntry = { key: $key4, value: $dict3[$key4] };
            var serviceName = serviceDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Connecting services to {0}', serviceName));
            var service = serviceDictionaryEntry.value;
            var serviceConfiguration = this._serviceConfiguration[serviceName];
            var $enum5 = serviceConfiguration.requiredServices.getEnumerator();
            while ($enum5.moveNext()) {
                var requiredServiceName = $enum5.get_current();
                Framework.AutoWiring._log.debug(String.format('Injecting [{0}] into [{1}]', requiredServiceName, serviceDictionaryEntry.key));
                var requiredService = this._services[requiredServiceName];
                service['set' + Type.getInstanceType(requiredService).get_name()](requiredService);
            }
            Framework.AutoWiring._log.debug(String.format('Subscribing to events {0}', serviceName));
            var $dict6 = serviceConfiguration.connectEvents;
            for (var $key7 in $dict6) {
                var connectedEventsDictionaryEntry = { key: $key7, value: $dict6[$key7] };
                var serviceToConnectTo = this._services[connectedEventsDictionaryEntry.key];
                var events = connectedEventsDictionaryEntry.value;
                if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
                }
                else {
                    var $enum8 = events.getEnumerator();
                    while ($enum8.moveNext()) {
                        var eventName = $enum8.get_current();
                        serviceToConnectTo['register' + eventName + 'Listener'](service);
                    }
                }
            }
        }
    },
    
    getComponentName: function Framework_AutoWiring$getComponentName(placeHolderId, componentClassName) {
        var componentNames = this._componentPlacementMap[placeHolderId];
        var $enum1 = componentNames.getEnumerator();
        while ($enum1.moveNext()) {
            var componentName = $enum1.get_current();
            var config = this.getComponentConfiguration(componentName);
            if (config.className === componentClassName) {
                return componentName;
            }
        }
        return null;
    },
    
    _getComponentPlaceholderId: function Framework_AutoWiring$_getComponentPlaceholderId(componentPlacementMap, componentName) {
        var $dict1 = componentPlacementMap;
        for (var $key2 in $dict1) {
            var placeholderComps = { key: $key2, value: $dict1[$key2] };
            var componentNames = placeholderComps.value;
            var $enum3 = componentNames.getEnumerator();
            while ($enum3.moveNext()) {
                var componentNameItem = $enum3.get_current();
                if (componentNameItem === componentName) {
                    return placeholderComps.key;
                }
            }
        }
        return null;
    },
    
    _initComponents: function Framework_AutoWiring$_initComponents() {
        Framework.AutoWiring._log.debug('InitComponents');
        var $dict1 = this._componentConfiguration;
        for (var $key2 in $dict1) {
            var componentConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var componentName = componentConfigurationDictionaryEntry.key;
            this._components[componentName] = Framework.Component.ComponentFactory.create(componentName, componentConfigurationDictionaryEntry.value, this._getComponentPlaceholderId(this._componentPlacementMap, componentName), this._environment);
        }
        var $dict3 = this._components;
        for (var $key4 in $dict3) {
            var componentDictionaryEntry = { key: $key4, value: $dict3[$key4] };
            var componentName = componentDictionaryEntry.key;
            var component = componentDictionaryEntry.value;
            var componentConfigurationItem = this._componentConfiguration[componentName];
            Framework.Component.ComponentFactory.initialize(componentName, component, componentConfigurationItem, this._services, this._components);
        }
    },
    
    _startEnvironment: function Framework_AutoWiring$_startEnvironment() {
        Framework.AutoWiring._log.debug('StartEnvironment');
        this._environment.start();
    },
    
    _startServices: function Framework_AutoWiring$_startServices() {
        Framework.AutoWiring._log.debug('StartServices');
        var $dict1 = this._services;
        for (var $key2 in $dict1) {
            var serviceDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var service = serviceDictionaryEntry.value;
            service.start();
        }
    },
    
    _startTopLevelComponents: function Framework_AutoWiring$_startTopLevelComponents() {
        Framework.AutoWiring._log.debug('StartComponents');
        var $dict1 = this._components;
        for (var $key2 in $dict1) {
            var componentDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var component = componentDictionaryEntry.value;
            if (!component.get_parent()) {
                component.get_componentLifeCycleManager().start();
            }
        }
    },
    
    _startCompleted: false,
    _eventTimeout: 0,
    _safetyTimeout: 0,
    
    run: function Framework_AutoWiring$run() {
        Framework.AutoWiring._log.debug('run');
        this._initEnvironment();
        this._initServices();
        this._initComponents();
        if (ScriptFX.Application.current && !eval('ScriptFX.Application.current._history')) {
            this.runStart();
            return;
        }
        if (ScriptFX.Application.current && ScriptFX.Application.current.get_history().get_isEnabled()) {
            ScriptFX.Application.current.add_load(Delegate.create(this, this.timeOutToRunStart));
            this._safetyTimeout = window.setTimeout(Delegate.create(this, this.runStart), 10 * 1000);
        }
        else {
            this.runStart();
        }
    },
    
    timeOutToRunStart: function Framework_AutoWiring$timeOutToRunStart(sender, args) {
        this._eventTimeout = window.setTimeout(Delegate.create(this, this.runStart), 1);
    },
    
    runStart: function Framework_AutoWiring$runStart() {
        if (!this._startCompleted) {
            window.clearTimeout(this._eventTimeout);
            window.clearTimeout(this._safetyTimeout);
            this._startCompleted = true;
            this._startEnvironment();
            this._startServices();
            this._startTopLevelComponents();
        }
    },
    
    _counter: 0,
    
    addComponent: function Framework_AutoWiring$addComponent(componentNameBase, newComponentConfiguration, placeholderId) {
        if (isNullOrUndefined(this._counter) || !this._counter) {
            this._counter = Object.getKeyCount(this._components) + 1;
        }
        var componentName = String.format('{0}{1}', componentNameBase, this._counter++);
        this._componentConfiguration[componentName] = newComponentConfiguration;
        var componentsForPlaceHolder = this._componentPlacementMap[placeholderId];
        if (!componentsForPlaceHolder) {
            componentsForPlaceHolder = new Array(0);
        }
        var componentsForPlaceHolderAdded = new Array(componentsForPlaceHolder.length + 1);
        for (var i = 0; i < componentsForPlaceHolder.length; i++) {
            componentsForPlaceHolderAdded[i] = componentsForPlaceHolder[i];
        }
        componentsForPlaceHolderAdded[componentsForPlaceHolder.length] = componentName;
        this._componentPlacementMap[placeholderId] = componentsForPlaceHolderAdded;
    },
    
    removeComponent: function Framework_AutoWiring$removeComponent(componentName) {
        var element = this._environment.getDomElement(componentName);
        if (element && element.parentNode) {
            element.parentNode.removeChild(element);
        }
        var placeholderId = this._getComponentPlaceholderId(this._componentPlacementMap, componentName);
        var componentsForPlaceHolder = this._componentPlacementMap[placeholderId];
        var componentsForPlaceHolderArr = [];
        for (var i = 0; i < componentsForPlaceHolder.length; i++) {
            if (componentsForPlaceHolder[i] !== componentName) {
                componentsForPlaceHolderArr.add(componentsForPlaceHolder[i]);
            }
        }
        componentsForPlaceHolder = new Array(componentsForPlaceHolderArr.length);
        for (var i = 0; i < componentsForPlaceHolderArr.length; i++) {
            componentsForPlaceHolder[i] = componentsForPlaceHolderArr[i];
        }
        this._componentPlacementMap[placeholderId] = componentsForPlaceHolder;
        delete this._componentConfiguration[componentName];
        if (!componentsForPlaceHolder.length) {
            this._environment.updateDomElement(placeholderId, '&nbsp;');
        }
    },
    
    updateComponent: function Framework_AutoWiring$updateComponent(componentName, newComponentConfiguration) {
        this._componentConfiguration[componentName] = newComponentConfiguration;
    },
    
    getComponentConfiguration: function Framework_AutoWiring$getComponentConfiguration(componentName) {
        return this._componentConfiguration[componentName];
    },
    
    runForAdmin: function Framework_AutoWiring$runForAdmin() {
        Framework.AutoWiring._log.debug('RunForAdmin');
        this._initEnvironment();
        this._components = {};
        var $dict1 = this._componentConfiguration;
        for (var $key2 in $dict1) {
            var componentConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var componentName = componentConfigurationDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Processing {0}', componentName));
            var componentConfigurationItem = componentConfigurationDictionaryEntry.value;
            var component = eval('new ' + componentConfigurationItem.className + '();');
            this._components[componentName] = component;
            var placeholderId = this._getComponentPlaceholderId(this._componentPlacementMap, componentName);
            if (!this._environment.getDomElement(componentName)) {
                var componentDocumentElement = document.createElement('div');
                componentDocumentElement.className = 'component';
                componentDocumentElement.id = componentName;
                document.getElementById(placeholderId).appendChild(componentDocumentElement);
            }
            component.init(this._environment, String.format('autoWiring.getComponents()[\'{0}\']', componentName), componentName, componentConfigurationItem.parameters);
            component.repaintForAdmin();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ComponentConfiguration

Framework.ComponentConfiguration = function Framework_ComponentConfiguration(className, childID, requiredServices, parameters, childComponents, connectEvents) {
    this.className = className;
    this.requiredServices = requiredServices;
    this.childID = childID;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
    this.childComponents = childComponents;
}
Framework.ComponentConfiguration.prototype = {
    className: null,
    requiredServices: null,
    childComponents: null,
    childID: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CommonComponentParameters

Framework.CommonComponentParameters = function Framework_CommonComponentParameters(parameters) {
    this._visibleOn = [];
    this._notVisibleOn = [];
    if (!String.isNullOrEmpty(parameters['visible-on'])) {
        this._visibleOn = (parameters['visible-on']).split(',');
    }
    if (!String.isNullOrEmpty(parameters['not-visible-on'])) {
        this._notVisibleOn = (parameters['not-visible-on']).split(',');
    }
    var $enum1 = this._visibleOn.getEnumerator();
    while ($enum1.moveNext()) {
        var i = $enum1.get_current();
        var $enum2 = this._notVisibleOn.getEnumerator();
        while ($enum2.moveNext()) {
            var j = $enum2.get_current();
            if (i === j) {
                throw new Error(String.format('visible-on and not-visible-on cannot contain the same action(s) [{0}]', i));
            }
        }
    }
    this._xsltUrl = parameters['xslt-url'];
    Framework.CommonComponentParameters._log.debug('xsltUrl = [' + this._xsltUrl + ']');
    this._contentUrl = parameters['content-url'];
    Framework.CommonComponentParameters._log.debug('contentUrl = [' + this._contentUrl + ']');
}
Framework.CommonComponentParameters.prototype = {
    
    get_visibleOn: function Framework_CommonComponentParameters$get_visibleOn() {
        return this._visibleOn;
    },
    
    get_notVisibleOn: function Framework_CommonComponentParameters$get_notVisibleOn() {
        return this._notVisibleOn;
    },
    
    _contentUrl: null,
    
    get_contentUrl: function Framework_CommonComponentParameters$get_contentUrl() {
        return this._contentUrl;
    },
    
    _xsltUrl: null,
    
    get_xsltUrl: function Framework_CommonComponentParameters$get_xsltUrl() {
        return this._xsltUrl;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CookieUtil

Framework.CookieUtil = function Framework_CookieUtil() {
}
Framework.CookieUtil.getCookie = function Framework_CookieUtil$getCookie(name) {
    var cookieName = name + '=';
    var documentCookie = document.cookie.split(';');
    for (var i = 0; i < documentCookie.length; i++) {
        var index = documentCookie[i];
        while (index.charAt(0) === ' ') {
            index = index.substring(1, index.length);
        }
        if (!index.indexOf(cookieName)) {
            return unescape(index.substring(cookieName.length, index.length));
        }
    }
    return null;
}
Framework.CookieUtil.setCookie = function Framework_CookieUtil$setCookie(name, value) {
    document.cookie = String.format('{0}={1}; expires={2}; path=/', name, escape(value), Framework.CookieUtil.getDateTime(365));
}
Framework.CookieUtil.setCookieWithDays = function Framework_CookieUtil$setCookieWithDays(name, value, numberOfDays) {
    document.cookie = String.format('{0}={1}; expires={2}; path=/', name, escape(value), Framework.CookieUtil.getDateTime(numberOfDays));
}
Framework.CookieUtil.clearCookie = function Framework_CookieUtil$clearCookie(name) {
    Framework.CookieUtil.setCookieWithDays(name, '', -1);
}
Framework.CookieUtil.clearCookies = function Framework_CookieUtil$clearCookies() {
    var allCookies = document.cookie.split(';');
    for (var i = 0; i < allCookies.length; i++) {
        var currentCookie = allCookies[i].split('=');
        if (currentCookie[0]) {
            Framework.CookieUtil.setCookieWithDays(currentCookie[0], '', -1);
        }
    }
}
Framework.CookieUtil.getDateTime = function Framework_CookieUtil$getDateTime(numberOfDays) {
    var dt = new Date();
    dt.setTime(dt.getTime() + numberOfDays * 86400000);
    return dt.toUTCString();
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AjaxUpdater

Framework.AjaxUpdater = function Framework_AjaxUpdater(domElementId, url, afterUpdateCallback, afterErrorCallback) {
    this._domElementId = domElementId;
    this._url = url;
    this._afterUpdateCallback = afterUpdateCallback;
    this._afterErrorCallback = afterErrorCallback;
}
Framework.AjaxUpdater.prototype = {
    _domElementId: null,
    _url: null,
    _request: null,
    _afterUpdateCallback: null,
    _afterErrorCallback: null,
    evalScripts: false,
    _scripts: null,
    
    _extractScripts: function Framework_AjaxUpdater$_extractScripts(responseText) {
        var regex = new RegExp(Framework.AjaxUpdater._scriptregex, 'img');
        var regexInner = new RegExp(Framework.AjaxUpdater._scriptregex, 'im');
        var scriptBlocks = responseText.match(regex);
        if (!scriptBlocks) {
            return new Array(0);
        }
        var scripts = new Array(scriptBlocks.length);
        for (var i = 0; i < scriptBlocks.length; i++) {
            var scriptBlockParts = scriptBlocks[i].match(regexInner);
            if (!scriptBlockParts || !scriptBlockParts.length) {
                scripts[i] = '';
            }
            else {
                scripts[i] = scriptBlockParts[scriptBlockParts.length - 1];
            }
        }
        return scripts;
    },
    
    executeScripts: function Framework_AjaxUpdater$executeScripts() {
        var $enum1 = this._scripts.getEnumerator();
        while ($enum1.moveNext()) {
            var script = $enum1.get_current();
            if (!String.isNullOrEmpty(script)) {
                eval(script);
            }
        }
    },
    
    update: function Framework_AjaxUpdater$update() {
        if (!this._url && this._afterErrorCallback) {
            this._afterErrorCallback.invoke();
            return;
        }
        this._request = new Framework.XMLHttpRequestDecorator();
        this._request.onreadystatechange = Delegate.create(this, function() {
            if (this._request.readyState === 4) {
                if (this._request.status === 200 || this._request.status === 304) {
                    Framework.AbstractEnvironment.safeUpdateDomElement(this._domElementId, this._request.responseText);
                    if (this.evalScripts) {
                        this._scripts = this._extractScripts(this._request.responseText);
                        window.setTimeout(Delegate.create(this, this.executeScripts), 10);
                        this.executeScripts();
                    }
                    if (this._afterUpdateCallback) {
                        this._afterUpdateCallback.invoke();
                    }
                }
                else if (this._afterErrorCallback) {
                    this._afterErrorCallback.invoke();
                }
            }
        });
        this._request.open('GET', this._url, true);
        this._request.send(null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractMessagingService

Framework.AbstractMessagingService = function Framework_AbstractMessagingService() {
    this._topics$1 = {};
    this._topicChangedListeners$1 = {};
    Framework.AbstractMessagingService.constructBase(this);
}
Framework.AbstractMessagingService.prototype = {
    
    registerTopicChangedListener: function Framework_AbstractMessagingService$registerTopicChangedListener(topicChangedListener, topic) {
        Framework.AbstractMessagingService._log$1.debug(String.format('RegisterTopicChangedListener topic=[{0}]', topic));
        if (!Object.keyExists(this._topicChangedListeners$1, topic)) {
            this._topicChangedListeners$1[topic] = [];
        }
        if (!(this._topicChangedListeners$1[topic]).contains(topicChangedListener)) {
            (this._topicChangedListeners$1[topic]).add(topicChangedListener);
        }
    },
    
    _fireTopicChangedEvent$1: function Framework_AbstractMessagingService$_fireTopicChangedEvent$1(listeners) {
        Framework.AbstractMessagingService._log$1.debug('FireTopicChangedEvent');
        var $enum1 = listeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onTopicChanged(this);
            }
            catch (e) {
                Framework.AbstractMessagingService._log$1.error('FireTopicChangedEvent OnTopicChanged', e);
            }
        }
    },
    
    getAllTopics: function Framework_AbstractMessagingService$getAllTopics() {
        var result = {};
        var $dict1 = this._topics$1;
        for (var $key2 in $dict1) {
            var de = { key: $key2, value: $dict1[$key2] };
            result[de.key] = de.value;
        }
        return result;
    },
    
    setAllTopics: function Framework_AbstractMessagingService$setAllTopics(topics) {
        var changedTopics = [];
        var $dict1 = this._topics$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (!Object.keyExists(topics, entry.key) || topics[entry.key] !== entry.value) {
                changedTopics.add(entry.key);
            }
        }
        var $dict3 = topics;
        for (var $key4 in $dict3) {
            var entry = { key: $key4, value: $dict3[$key4] };
            if (!changedTopics.contains(entry.key) && (!Object.keyExists(this._topics$1, entry.key) || this._topics$1[entry.key] !== entry.value)) {
                changedTopics.add(entry.key);
            }
        }
        var listeners = [];
        for (var i = 0; i < changedTopics.length; i++) {
            var topicListeners = [];
            if (Object.keyExists(this._topicChangedListeners$1, changedTopics[i])) {
                topicListeners = this._topicChangedListeners$1[changedTopics[i]];
            }
            for (var j = 0; j < topicListeners.length; j++) {
                if (!listeners.contains(topicListeners[j])) {
                    listeners.add(topicListeners[j]);
                }
            }
        }
        if (changedTopics.length > 0) {
            this._topics$1 = topics;
            this._fireTopicChangedEvent$1(listeners);
        }
    },
    
    getTopic: function Framework_AbstractMessagingService$getTopic(topic) {
        return this._topics$1[topic];
    },
    
    setTopic: function Framework_AbstractMessagingService$setTopic(topic, value) {
        if (String.compare(value, this._topics$1[topic])) {
            this._topics$1[topic] = value;
            var listeners = this._topicChangedListeners$1[topic];
            if (listeners) {
                this._fireTopicChangedEvent$1(listeners);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CustomCultureInfo

Framework.CustomCultureInfo = function Framework_CustomCultureInfo() {
}
Framework.CustomCultureInfo.add = function Framework_CustomCultureInfo$add(cultureKey, customCultureInfo) {
    Framework.CustomCultureInfo._customCultures[cultureKey] = customCultureInfo;
}
Framework.CustomCultureInfo.getCustomCultures = function Framework_CustomCultureInfo$getCustomCultures() {
    return Framework.CustomCultureInfo._customCultures;
}
Framework.CustomCultureInfo.addRegionDefaultCulture = function Framework_CustomCultureInfo$addRegionDefaultCulture(region, cultureKey) {
    Framework.CustomCultureInfo._regionalDefaultCulture[region + '_'] = cultureKey;
}
Framework.CustomCultureInfo.addLanguageDefaultCulture = function Framework_CustomCultureInfo$addLanguageDefaultCulture(language, cultureKey) {
    Framework.CustomCultureInfo._regionalDefaultCulture['_' + language] = cultureKey;
}
Framework.CustomCultureInfo.addRegionLanguageDefaultCulture = function Framework_CustomCultureInfo$addRegionLanguageDefaultCulture(region, language, cultureKey) {
    Framework.CustomCultureInfo._regionalDefaultCulture[region + '_' + language] = cultureKey;
}
Framework.CustomCultureInfo.getRegionalCultureKey = function Framework_CustomCultureInfo$getRegionalCultureKey(region, language) {
    if (Object.keyExists(Framework.CustomCultureInfo._regionalDefaultCulture, region + '_' + language)) {
        return Framework.CustomCultureInfo._regionalDefaultCulture[region + '_' + language];
    }
    else if (Object.keyExists(Framework.CustomCultureInfo._regionalDefaultCulture, '_' + language)) {
        return Framework.CustomCultureInfo._regionalDefaultCulture['_' + language];
    }
    else if (Object.keyExists(Framework.CustomCultureInfo._regionalDefaultCulture, region + '_')) {
        return Framework.CustomCultureInfo._regionalDefaultCulture[region + '_'];
    }
    else {
        return '';
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DynamicComponentConfiguration

Framework.DynamicComponentConfiguration = function Framework_DynamicComponentConfiguration(requiredServices, parameters, connectEvents) {
    this.requiredServices = requiredServices;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
}
Framework.DynamicComponentConfiguration.prototype = {
    requiredServices: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.NavigationTypeGroup

Framework.NavigationTypeGroup = function Framework_NavigationTypeGroup(matchingGroup) {
    this.matchingGroup = matchingGroup;
}
Framework.NavigationTypeGroup.prototype = {
    matchingGroup: null,
    
    isMatch: function Framework_NavigationTypeGroup$isMatch(navigationTypes) {
        if (!navigationTypes) {
            return false;
        }
        if (!this.matchingGroup) {
            return false;
        }
        if (navigationTypes.length !== this.matchingGroup.length) {
            return false;
        }
        for (var count = 0; count < navigationTypes.length; count++) {
            if (!navigationTypes.contains(this.matchingGroup[count])) {
                return false;
            }
        }
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ListenerInvoker

Framework.ListenerInvoker = function Framework_ListenerInvoker(isAsync) {
    this._listeners = [];
    this._isAsync = isAsync;
}
Framework.ListenerInvoker.prototype = {
    _isAsync: true,
    
    registerListener: function Framework_ListenerInvoker$registerListener(listener) {
        if (!this._listeners.contains(listener)) {
            this._listeners.add(listener);
        }
    },
    
    unregisterListener: function Framework_ListenerInvoker$unregisterListener(listener) {
        this._listeners.remove(listener);
    },
    
    _createDelegate: function Framework_ListenerInvoker$_createDelegate(listenerCallback, i) {
        return Delegate.create(this, function() {
            listenerCallback.invoke(this._listeners[i]);
        });
    },
    
    fireUpdateEvent: function Framework_ListenerInvoker$fireUpdateEvent(listenerCallback) {
        for (var i = 0; i < this._listeners.length; i++) {
            if (this._isAsync) {
                window.setTimeout(this._createDelegate(listenerCallback, i), 0);
            }
            else {
                try {
                    listenerCallback.invoke(this._listeners[i]);
                }
                catch (ex) {
                    Framework.ListenerInvoker._log.error('FireUpdateEvent', ex);
                }
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Parameters

Framework.Parameters = function Framework_Parameters() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragEventArgs

Framework.DragEventArgs = function Framework_DragEventArgs() {
}
Framework.DragEventArgs.prototype = {
    offsetX: null,
    offsetY: null,
    layerX: null,
    layerY: null,
    clientX: null,
    clientY: null,
    srcElement: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragObjectPosition

Framework.DragObjectPosition = function Framework_DragObjectPosition(position, zIndex, clientLeft, clientTop) {
    this.position = position;
    this.zIndex = zIndex;
    this.clientLeft = clientLeft;
    this.clientTop = clientTop;
}
Framework.DragObjectPosition.prototype = {
    position: null,
    zIndex: 0,
    clientLeft: null,
    clientTop: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragArgs

Framework.DragArgs = function Framework_DragArgs() {
}
Framework.DragArgs.prototype = {
    dragsRefresh: null,
    dropClassName: null,
    dragClassName: null,
    dropHoverClassName: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Droppables

Framework.Droppables = function Framework_Droppables() {
}
Framework.Droppables.add = function Framework_Droppables$add(element) {
    Framework.Droppables.drops.add(element);
}
Framework.Droppables.getDroppable = function Framework_Droppables$getDroppable(x, y) {
    x += Framework.Droppables.offsetLocation.left;
    y += Framework.Droppables.offsetLocation.top;
    var $enum1 = Framework.Droppables.drops.getEnumerator();
    while ($enum1.moveNext()) {
        var drop = $enum1.get_current();
        var bounds = ScriptFX.UI.Element.getBounds(drop);
        if (drop.style && drop.style.position === 'relative') {
            drop.style.position = 'absolute';
            bounds = ScriptFX.UI.Element.getBounds(drop);
            drop.style.position = 'relative';
        }
        if (y >= bounds.top && y <= (bounds.top + bounds.height)) {
            if (x >= bounds.left && x <= (bounds.left + bounds.width)) {
                return drop;
            }
        }
    }
    return null;
}
Framework.Droppables.setOffset = function Framework_Droppables$setOffset(x, y) {
    Framework.Droppables.offsetLocation.top = y;
    Framework.Droppables.offsetLocation.left = x;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DraggableStartLocations

Framework.DraggableStartLocations = function Framework_DraggableStartLocations() {
}
Framework.DraggableStartLocations.add = function Framework_DraggableStartLocations$add(element) {
    Framework.DraggableStartLocations._dictionary[element.id] = ScriptFX.UI.Element.getLocation(element);
}
Framework.DraggableStartLocations.get = function Framework_DraggableStartLocations$get(element) {
    var key = element.id;
    if (Object.keyExists(Framework.DraggableStartLocations._dictionary, key)) {
        return Framework.DraggableStartLocations._dictionary[key];
    }
    return null;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragableControl

Framework.DragableControl = function Framework_DragableControl() {
    Framework.DragableControl.constructBase(this);
}
Framework.DragableControl.resetLocation = function Framework_DragableControl$resetLocation(element) {
    var location = Framework.DraggableStartLocations.get(element);
    if (location) {
        ScriptFX.UI.Element.setLocation(element, location);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Position

Framework.Position = function Framework_Position(x, y) {
    this.x = x;
    this.y = y;
}
Framework.Position.prototype = {
    x: 0,
    y: 0,
    scrollX: 0,
    scrollY: 0,
    
    prepare: function Framework_Position$prepare() {
        if (!isNullOrUndefined(document.documentElement.scrollLeft) && document.documentElement.scrollLeft) {
            this.scrollX = document.documentElement.scrollLeft;
        }
        else if (!isNullOrUndefined(document.body.scrollLeft) && document.body.scrollLeft) {
            this.scrollX = document.documentElement.scrollLeft;
        }
        if (!isNullOrUndefined(document.documentElement.scrollLeft) && document.documentElement.scrollTop) {
            this.scrollY = document.documentElement.scrollTop;
        }
        else if (!isNullOrUndefined(document.body.scrollLeft) && document.body.scrollTop) {
            this.scrollY = document.documentElement.scrollTop;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragController

Framework.DragController = function Framework_DragController(o, oRoot, minX, maxX, minY, maxY, bSwapHorzRef, bSwapVertRef, fXMapper, fYMapper) {
    this.obj = o;
    o.onmousedown = Delegate.create(this, this.start);
    o.hmode = (bSwapHorzRef) ? false : true;
    o.vmode = (bSwapVertRef) ? false : true;
    o.minX = (isNaN(minX)) ? null : minX;
    o.minY = (isNaN(minY)) ? null : minY;
    o.maxX = (isNaN(maxX)) ? null : maxX;
    o.maxY = (isNaN(maxY)) ? null : maxY;
    o.xMapper = fXMapper;
    o.yMapper = fYMapper;
    o.root = (oRoot) ? oRoot : o;
    if (o.hmode && isNaN(parseInt(o.root.style.left))) {
        o.root.style.left = '0px';
    }
    if (o.vmode && isNaN(parseInt(o.root.style.top))) {
        o.root.style.top = '0px';
    }
    if (!o.hmode && isNaN(parseInt(o.root.style.right))) {
        o.root.style.right = '0px';
    }
    if (!o.vmode && isNaN(parseInt(o.root.style.bottom))) {
        o.root.style.bottom = '0px';
    }
    o.root.style.zIndex = 9999;
    o.root.onDragStart = Delegate.create(this, function(e) {
        return false;
    });
    o.root.onDragEnd = Delegate.create(this, function(obj, x, y) {
    });
    o.root.onDrag = Delegate.create(this, function(obj, x, y) {
    });
    this.dragHandler = Framework.DocumentEvents.parse(Delegate.create(this, this.dragHandle));
    this.endHandler = Framework.DocumentEvents.parse(Delegate.create(this, this.endHandle));
}
Framework.DragController.getAbsolutePosition = function Framework_DragController$getAbsolutePosition(element) {
    var pos = new Framework.Position(element.offsetLeft, element.offsetTop);
    if (element.offsetParent) {
        var parentPos = Framework.DragController.getAbsolutePosition(element.offsetParent);
        pos.x += parentPos.x;
        pos.y += parentPos.y;
    }
    return pos;
}
Framework.DragController.absolutize = function Framework_DragController$absolutize(element) {
    if (element.style.position === 'absolute') {
        return;
    }
    var pos = Framework.DragController.getAbsolutePosition(element);
    element.style.position = 'absolute';
    element.style.left = (pos.x - element.clientLeft) + 'px';
    element.style.top = (pos.y - element.clientTop) + 'px';
}
Framework.DragController.prototype = {
    obj: null,
    _initialPosition: null,
    
    startHandle: function Framework_DragController$startHandle() {
        this.start(this._getWindowEvent());
    },
    
    start: function Framework_DragController$start(e) {
        e = this.fixE(e);
        var o = this.obj;
        this._initialPosition = new Framework.DragObjectPosition(o.style.position, o.style.zIndex, o.clientLeft, o.clientTop);
        var y = parseInt((o.vmode) ? o.root.style.top : o.root.style.bottom);
        var x = parseInt((o.hmode) ? o.root.style.left : o.root.style.right);
        o.lastMouseX = e.clientX;
        o.lastMouseY = e.clientY;
        o.offsetX = e.clientX;
        o.offsetY = e.clientY;
        o.root.onDragStart.invoke(e);
        if (o.hmode) {
            if (o.minX) {
                o.minMouseX = e.clientX - x + o.minX;
            }
            if (o.maxX) {
                o.maxMouseX = o.minMouseX + o.maxX - o.minX;
            }
        }
        else {
            if (o.minX) {
                o.maxMouseX = -o.minX + e.clientX + x;
            }
            if (o.maxX) {
                o.minMouseX = -o.maxX + e.clientX + x;
            }
        }
        if (o.vmode) {
            if (o.minY) {
                o.minMouseY = e.clientY - y + o.minY;
            }
            if (o.maxY) {
                o.maxMouseY = o.minMouseY + o.maxY - o.minY;
            }
        }
        else {
            if (o.minY) {
                o.maxMouseY = -o.minY + e.clientY + y;
            }
            if (o.maxY) {
                o.minMouseY = -o.maxY + e.clientY + y;
            }
        }
        Framework.DocumentEvents.setOnMousemove(null);
        Framework.DocumentEvents.setOnMouseup(null);
        document.attachEvent('onmousemove', this.dragHandler);
        document.attachEvent('onmouseup', this.endHandler);
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            window.event.cancelBubble = true;
        }
        else {
            Framework.BubblingEvent.parse(window.event).stopPropagation();
        }
        return false;
    },
    
    dragHandle: function Framework_DragController$dragHandle() {
        return this.drag(this._getWindowEvent());
    },
    
    drag: function Framework_DragController$drag(e) {
        e = this.fixE(e);
        var o = this.obj;
        var ey = e.clientY;
        var ex = e.clientX;
        var y = parseInt((o.vmode) ? o.root.style.top : o.root.style.bottom);
        var x = parseInt((o.hmode) ? o.root.style.left : o.root.style.right);
        var nx;
        var ny;
        if (o.minX) {
            ex = (o.hmode) ? Math.max(ex, o.minMouseX) : Math.min(ex, o.maxMouseX);
        }
        if (o.maxX) {
            ex = (o.hmode) ? Math.min(ex, o.maxMouseX) : Math.max(ex, o.minMouseX);
        }
        if (o.minY) {
            ey = (o.vmode) ? Math.max(ey, o.minMouseY) : Math.min(ey, o.maxMouseY);
        }
        if (o.maxY) {
            ey = (o.vmode) ? Math.min(ey, o.maxMouseY) : Math.max(ey, o.minMouseY);
        }
        nx = x + ((ex - o.lastMouseX) * ((o.hmode) ? 1 : -1));
        ny = y + ((ey - o.lastMouseY) * ((o.vmode) ? 1 : -1));
        if (o.xMapper) {
            nx = o.xMapper.invoke(x);
        }
        if (o.yMapper) {
            ny = o.yMapper.invoke(y);
        }
        if (o.hmode) {
            this.obj.root.style.left = nx + 'px';
        }
        else {
            this.obj.root.style.right = nx + 'px';
        }
        if (o.vmode) {
            this.obj.root.style.top = ny + 'px';
        }
        else {
            this.obj.root.style.bottom = ny + 'px';
        }
        this.obj.lastMouseX = ex;
        this.obj.lastMouseY = ey;
        this.obj.root.onDrag.invoke(this.obj, nx, ny);
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            window.event.cancelBubble = true;
        }
        else {
            Framework.BubblingEvent.parse(window.event).stopPropagation();
        }
        return false;
    },
    
    endHandle: function Framework_DragController$endHandle() {
        return this.end(this._getWindowEvent());
    },
    
    end: function Framework_DragController$end(e) {
        document.detachEvent('onmousemove', this.dragHandler);
        document.detachEvent('onmouseup', this.endHandler);
        var style = this.obj.root.style;
        var x = parseInt((this.obj.hmode) ? style.left : style.right);
        var y = parseInt((this.obj.vmode) ? style.top : style.bottom);
        this.obj.root.onDragEnd.invoke(this.obj, x, y);
        return false;
    },
    
    fixE: function Framework_DragController$fixE(evt) {
        if (!evt) {
            evt = this._getWindowEvent();
        }
        return evt;
    },
    
    dragHandler: null,
    endHandler: null,
    
    _getWindowEvent: function Framework_DragController$_getWindowEvent() {
        var o = window.event;
        return o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Logger

Framework.Logger = function Framework_Logger() {
}
Framework.Logger.isLoggingEnabled = function Framework_Logger$isLoggingEnabled() {
    return Framework.Logger._isLoggingEnabled;
}
Framework.Logger.switchLogging = function Framework_Logger$switchLogging() {
    Framework.Logger._isLoggingEnabled = !Framework.Logger._isLoggingEnabled;
}
Framework.Logger.getLog = function Framework_Logger$getLog(typeName) {
    return new Framework.Log(typeName);
}
Framework.Logger.setMaximumLogSize = function Framework_Logger$setMaximumLogSize(maximumLogSize) {
    Framework.Logger._maximumLogSize = maximumLogSize;
}
Framework.Logger.getMaximumLogSize = function Framework_Logger$getMaximumLogSize() {
    return Framework.Logger._maximumLogSize;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.JSONFormat

Framework.JSONFormat = function Framework_JSONFormat() {
}
Framework.JSONFormat.formatDateTime = function Framework_JSONFormat$formatDateTime(dateTime) {
    return ((!dateTime) ? null : String.format('{0}-{1}-{2} {3}-{4}-{5}', dateTime.getDate(), dateTime.getMonth() + 1, dateTime.getFullYear(), dateTime.getHours(), dateTime.getMinutes(), dateTime.getSeconds()));
}
Framework.JSONFormat.parseDateTime = function Framework_JSONFormat$parseDateTime(dateTime) {
    var dateTimeParts = dateTime.split(new RegExp('[- ]'));
    return new Date(Number.parse(dateTimeParts[2]), Number.parse(dateTimeParts[1]) - 1, Number.parse(dateTimeParts[0]), Number.parse(dateTimeParts[3]), Number.parse(dateTimeParts[4]), Number.parse(dateTimeParts[5]));
}


////////////////////////////////////////////////////////////////////////////////
// Framework.JsonRpcTask

Framework.JsonRpcTask = function Framework_JsonRpcTask(serviceName, methodName, IDMDLanguage, arguments, jsonRpcSuccessCallback, jsonRpcFailureCallback) {
    arguments['IDMDLanguage'] = IDMDLanguage;
    this._requestPayload = { serviceName: serviceName, methodName: methodName, arguments: arguments };
    this._jsonRpcSuccessCallback = jsonRpcSuccessCallback;
    this._jsonRpcFailureCallback = jsonRpcFailureCallback;
    this._sdcToken = Framework.SDC.SDCManager.sdcManagerInstance().startRPCLog(serviceName, methodName);
}
Framework.JsonRpcTask.prototype = {
    _requestPayload: null,
    _jsonRpcSuccessCallback: null,
    _jsonRpcFailureCallback: null,
    _sdcToken: null,
    
    get_jsonRpcSuccessCallback: function Framework_JsonRpcTask$get_jsonRpcSuccessCallback() {
        return this._jsonRpcSuccessCallback;
    },
    
    get_jsonRpcFailureCallback: function Framework_JsonRpcTask$get_jsonRpcFailureCallback() {
        return this._jsonRpcFailureCallback;
    },
    
    getRequestPayload: function Framework_JsonRpcTask$getRequestPayload() {
        return Framework.JsonUtil.serialize(this._requestPayload);
    },
    
    getPayloadAsDictionary: function Framework_JsonRpcTask$getPayloadAsDictionary() {
        return this._requestPayload;
    },
    
    getSDCToken: function Framework_JsonRpcTask$getSDCToken() {
        return this._sdcToken;
    },
    
    processResponse: function Framework_JsonRpcTask$processResponse(httpResponse) {
        if (httpResponse) {
            if (httpResponse.get_statusCode() === ScriptFX.Net.HTTPStatusCode.OK) {
                var response = Framework.JsonUtil.deserialize(httpResponse.getText());
                var exceptionType = null;
                var message = null;
                if (response['exceptionType']) {
                    exceptionType = response['exceptionType'];
                }
                if (response['message']) {
                    message = response['message'].toString();
                }
                Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog(this._sdcToken, response['token'], (String.isNullOrEmpty(exceptionType)) ? Framework.SDC.SDCExceptionType.noException : Framework.SDC.SDCExceptionType.callbrokerRPCException);
                if (!String.isNullOrEmpty(exceptionType)) {
                    this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException(exceptionType, message));
                }
                else {
                    this._jsonRpcSuccessCallback.invoke(response['result']);
                }
            }
            else if (httpResponse.get_statusCode() === ScriptFX.Net.HTTPStatusCode.internalServerError) {
                var response = Framework.JsonUtil.deserialize(httpResponse.getText());
                var exceptionType = null;
                var message = null;
                if (response['exceptionType']) {
                    exceptionType = response['exceptionType'];
                }
                if (response['message']) {
                    message = response['message'];
                }
                Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog(this._sdcToken, response['token'], Framework.SDC.SDCExceptionType.operationalException);
                this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException(exceptionType, message));
            }
            else {
                Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog(this._sdcToken, '', Framework.SDC.SDCExceptionType.operationalException);
                this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
            }
        }
        else {
            Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog(this._sdcToken);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionDetails

Framework.ExceptionDetails = function Framework_ExceptionDetails(exceptionType, message) {
    this._exceptionType = exceptionType;
    if (this._exceptionType === 'System.FormatException') {
        this._message = 'A required field is not filled in.';
    }
    else {
        this._message = message;
    }
    if (!this._message) {
        this._message = 'Please contact customer support';
    }
}
Framework.ExceptionDetails.prototype = {
    _exceptionType: null,
    
    get_exceptionType: function Framework_ExceptionDetails$get_exceptionType() {
        return this._exceptionType;
    },
    
    _message: null,
    
    get_message: function Framework_ExceptionDetails$get_message() {
        return this._message;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionTypes

Framework.ExceptionTypes = function Framework_ExceptionTypes() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionUtil

Framework.ExceptionUtil = function Framework_ExceptionUtil() {
}
Framework.ExceptionUtil.createException = function Framework_ExceptionUtil$createException(exceptionType, message) {
    return new Error(String.format('{0}{1}{2}', exceptionType, Framework.ExceptionUtil._separator, (String.isNullOrEmpty(message)) ? String.Empty : message));
}
Framework.ExceptionUtil.getExceptionDetails = function Framework_ExceptionUtil$getExceptionDetails(exception) {
    Framework.ExceptionUtil._log.debug(String.format('GetExceptionDetails exception=[{0}]', Framework.DictionaryUtil.dumpObjectToString(exception)));
    var messageTokens = exception.message.split(Framework.ExceptionUtil._separator);
    return new Framework.ExceptionDetails(messageTokens[0], messageTokens[1]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Log

Framework.Log = function Framework_Log(typeName) {
    this._typeName = typeName;
}
Framework.Log.prototype = {
    _typeName: null,
    
    _write: function Framework_Log$_write(message) {
        if (!Framework.Logger.isLoggingEnabled()) {
            return;
        }
        if (!Framework.Log._domElementName) {
            return;
        }
        var _domElement = document.getElementById(Framework.Log._domElementName);
        if (!_domElement) {
            return;
        }
        var maximumLogSize = Framework.Logger.getMaximumLogSize();
        if (maximumLogSize > 0 && _domElement.innerHTML.length > maximumLogSize) {
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(_domElement, '');
        }
        var newElement = document.createElement('span');
        newElement.innerText = this._prefixMessageWithTypeName(message);
        _domElement.appendChild(newElement);
    },
    
    _prefixMessageWithTypeName: function Framework_Log$_prefixMessageWithTypeName(message) {
        return String.format('{0}.{1}', this._typeName, message);
    },
    
    debug: function Framework_Log$debug(message) {
        this._write(message + '<br />\n');
    },
    
    error: function Framework_Log$error(message, exception) {
        this._write('<span style=\'color: red\'>' + this._prefixMessageWithTypeName(message) + ':' + Framework.ExceptionUtil.getExceptionDetails(exception).get_message() + '</span><br />\n');
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.RemoteException

Framework.RemoteException = function Framework_RemoteException() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ServiceConfiguration

Framework.ServiceConfiguration = function Framework_ServiceConfiguration(className, requiredServices, parameters, connectEvents) {
    this.className = className;
    this.requiredServices = requiredServices;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
}
Framework.ServiceConfiguration.prototype = {
    className: null,
    requiredServices: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.FormUtil

Framework.FormUtil = function Framework_FormUtil() {
}
Framework.FormUtil._purgePrefix = function Framework_FormUtil$_purgePrefix(id, idElementPrefix) {
    var oCharacters = [ 9, 10, 13, 32 ];
    var i = 0;
    var idReplaced;
    idReplaced = id;
    for (i = 0; i < oCharacters.length; i++) {
        idReplaced = idReplaced.replace(String.fromCharCode(oCharacters[i]), '');
    }
    return idReplaced.substr(idElementPrefix.length);
}
Framework.FormUtil.getFormAsDictionary = function Framework_FormUtil$getFormAsDictionary(formId, idElementPrefix) {
    var result = {};
    var formElement = document.getElementById(formId);
    var domElementCollection = formElement.getElementsByTagName('input');
    for (var i = 0; i < domElementCollection.length; i++) {
        var inputElement = domElementCollection[i];
        if (inputElement.id && inputElement.id.startsWith(idElementPrefix)) {
            if (!'radio'.compareTo(inputElement.type, true)) {
                if ((inputElement).checked && !String.isNullOrEmpty(inputElement.getAttribute('name'))) {
                    result[Framework.FormUtil._purgePrefix(inputElement.getAttribute('name'), idElementPrefix)] = inputElement.value;
                }
            }
            else if (!'checkbox'.compareTo(inputElement.type, true)) {
                result[Framework.FormUtil._purgePrefix(inputElement.id, idElementPrefix)] = (inputElement).checked;
            }
            else {
                result[Framework.FormUtil._purgePrefix(inputElement.id, idElementPrefix)] = inputElement.value;
            }
        }
    }
    domElementCollection = formElement.getElementsByTagName('select');
    for (var i = 0; i < domElementCollection.length; i++) {
        var selectElement = domElementCollection[i];
        if (selectElement.id && selectElement.id.startsWith(idElementPrefix)) {
            result[Framework.FormUtil._purgePrefix(selectElement.id, idElementPrefix)] = selectElement.value;
        }
    }
    domElementCollection = formElement.getElementsByTagName('textarea');
    for (var i = 0; i < domElementCollection.length; i++) {
        var textAreaElement = domElementCollection[i];
        if (textAreaElement.id && textAreaElement.id.startsWith(idElementPrefix)) {
            result[Framework.FormUtil._purgePrefix(textAreaElement.id, idElementPrefix)] = textAreaElement.value;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DictionaryUtil

Framework.DictionaryUtil = function Framework_DictionaryUtil() {
}
Framework.DictionaryUtil.equal = function Framework_DictionaryUtil$equal(first, second) {
    if (!first && !second) {
        return true;
    }
    if (!first && second) {
        return false;
    }
    if (first && !second) {
        return false;
    }
    if (Object.getKeyCount(first) !== Object.getKeyCount(second)) {
        return false;
    }
    var $dict1 = first;
    for (var $key2 in $dict1) {
        var de = { key: $key2, value: $dict1[$key2] };
        var key = de.key;
        if (!Object.keyExists(second, key)) {
            return false;
        }
        var firstval = de.value;
        var secondval = second[key];
        if (!firstval && !secondval) {
            continue;
        }
        if (!firstval && secondval) {
            return false;
        }
        if (firstval && !secondval) {
            return false;
        }
        if (firstval !== secondval) {
            return false;
        }
    }
    return true;
}
Framework.DictionaryUtil.dumpToString = function Framework_DictionaryUtil$dumpToString(dictionary) {
    var result = '{';
    var $dict1 = dictionary;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        if (entry.key) {
            result += String.format('{0}:{1}; ', entry.key, entry.value);
        }
    }
    return result + '}';
}
Framework.DictionaryUtil.dumpObjectToString = function Framework_DictionaryUtil$dumpObjectToString(obj) {
    return Framework.DictionaryUtil.dumpToString(obj);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ToolTipBehavior

Framework.ToolTipBehavior = function Framework_ToolTipBehavior(domElement, id) {
    Framework.ToolTipBehavior.constructBase(this, [ domElement, id ]);
    this.get_domEvents().attach('ommousemove', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var toolTips = document.getElementsByTagName('span');
        for (var i = 0; i < toolTips.length; i++) {
            if (toolTips[i].className === 'tip-info') {
                var ttleftOffset = 10;
                var tttopOffset = 15;
                var leftPos = window.event.offsetX;
                var topPos = window.event.offsetY;
                var absoluteLeftPos = 0;
                var absoluteTopPos = 0;
                var offsetParent = srcElement;
                while (offsetParent) {
                    absoluteLeftPos += offsetParent.offsetLeft;
                    absoluteTopPos += offsetParent.offsetTop;
                    offsetParent = offsetParent.offsetParent;
                }
                leftPos += absoluteLeftPos;
                topPos += absoluteTopPos;
                var screenWidth = window.document.body.offsetWidth;
                var screenHeight = window.document.body.offsetHeight;
                if ((screenWidth - absoluteLeftPos) < (150 + ttleftOffset)) {
                    var newLeftPos = leftPos;
                    newLeftPos -= 150;
                    toolTips[i].style.left = newLeftPos.toString() + 'px';
                }
                else {
                    leftPos += ttleftOffset;
                    toolTips[i].style.left = leftPos.toString() + 'px';
                }
                var newTopPos = topPos;
                newTopPos += tttopOffset;
                toolTips[i].style.top = newTopPos.toString() + 'px';
            }
        }
    }));
    this.get_domEvents().attach('onmouseover', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var ttText = srcElement.getAttribute('toolTipText');
        if ((srcElement.className.indexOf('toolTip') >= 0) && (ttText !== '')) {
            var ttWidth = 150;
            var ttleftOffset = 10;
            var tttopOffset = 15;
            if (srcElement.getAttribute('toolTipWidth')) {
                ttWidth = srcElement.getAttribute('toolTipWidth');
                if (ttWidth > 500) {
                    ttWidth = 500;
                }
            }
            var leftPos = window.event.offsetX;
            var topPos = window.event.offsetY;
            var absoluteLeftPos = 0;
            var absoluteTopPos = 0;
            var offsetParent = srcElement;
            while (offsetParent) {
                absoluteLeftPos += offsetParent.offsetLeft;
                absoluteTopPos += offsetParent.offsetTop;
                offsetParent = offsetParent.offsetParent;
            }
            leftPos += absoluteLeftPos;
            topPos += absoluteTopPos;
            var screenWidth = window.document.body.offsetWidth;
            var screenHeight = window.document.body.offsetHeight;
            var toolTip = document.createElement('span');
            toolTip.className = 'tip-info';
            toolTip.innerHTML = ttText;
            if ((screenWidth - absoluteLeftPos) < (ttWidth + ttleftOffset)) {
                var newLeftPos = leftPos;
                newLeftPos -= ttWidth;
                toolTip.style.left = newLeftPos.toString() + 'px';
            }
            else {
                leftPos += ttleftOffset;
                toolTip.style.left = leftPos.toString() + 'px';
            }
            var newTopPos = topPos;
            newTopPos += tttopOffset;
            toolTip.style.top = newTopPos.toString() + 'px';
            srcElement.appendChild(toolTip);
        }
    }));
    this.get_domEvents().attach('onmouseout', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var toolTips = document.getElementsByTagName('span');
        for (var i = 0; i < toolTips.length; i++) {
            if (toolTips[i].className === 'tip-info') {
                srcElement.removeChild(toolTips[i]);
            }
        }
    }));
}


////////////////////////////////////////////////////////////////////////////////
// Framework.TransformAndUpdateTask

Framework.TransformAndUpdateTask = function Framework_TransformAndUpdateTask(domElementId, contentUrl, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, environment, domElement, inMemoryProcessingCallback, contentXml, useSuppliedContentXml, contentUrlDelegate, useContentUrlDelegate) {
    this._domElementId = domElementId;
    this._contentUrl = contentUrl;
    this._xsltUrl = xsltUrl;
    this._xsltParameters = xsltParameters;
    this._afterTransformAndUpdateCallback = afterTransformAndUpdateCallback;
    this._domain = domain;
    this._environment = environment;
    this._autoRefreshPeriod = autoRefreshPeriod;
    this._domElement = domElement;
    this._inMemoryProcessingCallback = inMemoryProcessingCallback;
    this._useSuppliedContentXml = useSuppliedContentXml;
    if (this._useSuppliedContentXml) {
        this._contentXmlDocument = contentXml;
    }
    this._contentUrlDelegate = contentUrlDelegate;
    this._useContentUrlDelegate = useContentUrlDelegate;
    this._sdcToken = Framework.SDC.SDCManager.notLoggedInternalToken;
}
Framework.TransformAndUpdateTask._getStamp = function Framework_TransformAndUpdateTask$_getStamp(domElementId) {
    return Framework.TransformAndUpdateTask._domElementCounterMap[domElementId];
}
Framework.TransformAndUpdateTask._setStamp = function Framework_TransformAndUpdateTask$_setStamp(domElementId, value) {
    Framework.TransformAndUpdateTask._domElementCounterMap[domElementId] = value;
}
Framework.TransformAndUpdateTask.storeXsltDocument = function Framework_TransformAndUpdateTask$storeXsltDocument(url, document) {
    Framework.TransformAndUpdateTask._cachedXsltXmlDocument[url] = document;
}
Framework.TransformAndUpdateTask._onContentRequestsComplete = function Framework_TransformAndUpdateTask$_onContentRequestsComplete(contentUrl) {
    Framework.TransformAndUpdateTask._log.debug(String.format('OnContentRequestsComplete contentUrl=[{0}]', contentUrl));
    if (Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, contentUrl) && Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[contentUrl])) > 0) {
        var xmlCallBacksForUrl = Framework.TransformAndUpdateTask._xmlCallBacks[contentUrl];
        var $dict1 = xmlCallBacksForUrl;
        for (var $key2 in $dict1) {
            var callback = { key: $key2, value: $dict1[$key2] };
            Framework.TransformAndUpdateTask._log.debug(String.format('OnContentRequestsComplete callback key=[{0}] contentUrl=[{1}]', callback.key, contentUrl));
            (callback.value).invoke();
        }
    }
}
Framework.TransformAndUpdateTask.prototype = {
    _startingCounterValue: 0,
    _domElementId: null,
    _contentUrl: null,
    _contentUrlDelegate: null,
    _useContentUrlDelegate: false,
    _xsltUrl: null,
    _xsltParameters: null,
    _afterTransformAndUpdateCallback: null,
    _domain: null,
    
    get_domain: function Framework_TransformAndUpdateTask$get_domain() {
        return this._domain;
    },
    
    _autoRefreshPeriod: null,
    
    get_autoRefreshPeriod: function Framework_TransformAndUpdateTask$get_autoRefreshPeriod() {
        return this._autoRefreshPeriod;
    },
    
    _lastExecuted: null,
    
    get_lastExecuted: function Framework_TransformAndUpdateTask$get_lastExecuted() {
        return this._lastExecuted;
    },
    
    _contentRequest: null,
    _xsltRequest: null,
    _contentXmlDocument: null,
    _useSuppliedContentXml: false,
    _xsltXmlDocument: null,
    _environment: null,
    _inMemoryProcessingCallback: null,
    _domElement: null,
    _sdcToken: null,
    
    execute: function Framework_TransformAndUpdateTask$execute(appendTimestampToContentUrl) {
        this._lastExecuted = Date.get_now();
        this._startingCounterValue = Framework.TransformAndUpdateTask._requestCounter++;
        Framework.TransformAndUpdateTask._setStamp(this._domElementId, this._startingCounterValue);
        var newContentUrl = this._getContentUrl();
        if (this._contentUrl !== newContentUrl) {
            this._contentUrl = newContentUrl;
            this._contentXmlDocument = null;
        }
        if (!this._useSuppliedContentXml) {
            if (this._contentUrl) {
                var doCall = false;
                if (!Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, this._contentUrl) || !Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl]))) {
                    this._sdcToken = Framework.SDC.SDCManager.sdcManagerInstance().startRenderLog(this._domElementId);
                    doCall = true;
                    Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl] = {};
                }
                (Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl])[this._domElementId] = Delegate.create(this, this._onContentRequestComplete);
                if (doCall) {
                    this._contentXmlDocument = null;
                    this._contentRequest = new Framework.XMLHttpRequestDecorator();
                    this._contentRequest.onreadystatechange = Delegate.create(this, function() {
                        Framework.TransformAndUpdateTask._onContentRequestsComplete(this._contentUrl);
                    });
                    this._contentRequest.open('GET', this._contentUrl, true);
                    this._contentRequest.send(null);
                    Framework.TransformAndUpdateTask._contentRequests[this._contentUrl] = this._contentRequest;
                }
            }
            else {
                this._contentXmlDocument = Framework.XMLUtils.get_emptyContentDocument();
            }
        }
        if (!Object.keyExists(Framework.TransformAndUpdateTask._cachedXsltXmlDocument, this._xsltUrl)) {
            this._xsltRequest = new Framework.XMLHttpRequestDecorator();
            this._xsltRequest.onreadystatechange = Delegate.create(this, this._onXsltRequestComplete);
            this._xsltRequest.open('GET', this._xsltUrl, true);
            this._xsltRequest.send(null);
        }
        else {
            this._xsltXmlDocument = Framework.TransformAndUpdateTask._cachedXsltXmlDocument[this._xsltUrl];
        }
        this._tryTransform();
    },
    
    _tryTransform: function Framework_TransformAndUpdateTask$_tryTransform() {
        Framework.TransformAndUpdateTask._log.debug(String.format('TryTransform domElementId=[{0}] contentUrl=[{1}]', this._domElementId, this._contentUrl));
        if (this._contentXmlDocument && this._xsltXmlDocument && this._startingCounterValue === Framework.TransformAndUpdateTask._getStamp(this._domElementId)) {
            Framework.XMLUtils.transformAndUpdateWithXsltUrl(this._contentXmlDocument, this._xsltXmlDocument, this._xsltParameters, this._domElementId, this._domElement, this._getFullXsltUrl(this._xsltUrl), this._inMemoryProcessingCallback);
            if (this._afterTransformAndUpdateCallback) {
                window.setTimeout(this._afterTransformAndUpdateCallback, 0);
            }
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla) {
                var css = '#' + this._domElementId + ' .escapedHtml';
                var elements = Framework.DocumentFinder.getElementsBySelector(css);
                if (elements) {
                    for (var i = 0; i < elements.length; i++) {
                        elements[i].innerHTML = elements[i].innerText;
                    }
                }
            }
            Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.noException);
        }
    },
    
    _getFullXsltUrl: function Framework_TransformAndUpdateTask$_getFullXsltUrl(url) {
        return '/Areas/' + this._environment.getPageArea() + '/Template_' + this._environment.getRegion() + '_' + this._environment.getLanguage() + '/' + url;
    },
    
    _onContentRequestComplete: function Framework_TransformAndUpdateTask$_onContentRequestComplete() {
        if (!this._contentRequest) {
            this._contentRequest = Framework.TransformAndUpdateTask._contentRequests[this._contentUrl];
        }
        if (this._contentRequest) {
            if (this._contentRequest.readyState === 4) {
                if (this._contentRequest.status === 200 || this._contentRequest.status === 304) {
                    this._contentXmlDocument = this._contentRequest.responseXML;
                    this._tryTransform();
                }
                else {
                    Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                    this._environment.updateDomElement(this._domElementId, '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
                }
                if (Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, this._contentUrl) && Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl])) > 0) {
                    var xmlCallBack = Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl];
                    if (Object.keyExists(xmlCallBack, this._domElementId)) {
                        delete xmlCallBack[this._domElementId];
                    }
                    if (!Object.getKeyCount(xmlCallBack)) {
                        delete Framework.TransformAndUpdateTask._contentRequests[this._contentUrl];
                        this._contentRequest.onreadystatechange = null;
                    }
                }
            }
        }
    },
    
    _onXsltRequestComplete: function Framework_TransformAndUpdateTask$_onXsltRequestComplete() {
        if (this._xsltRequest.readyState === 4) {
            if (this._xsltRequest.status === 200 || this._xsltRequest.status === 304) {
                this._xsltXmlDocument = this._xsltRequest.responseXML;
                Framework.TransformAndUpdateTask._cachedXsltXmlDocument[this._xsltUrl] = this._xsltXmlDocument;
                this._tryTransform();
                if (this._xsltRequest) {
                    this._xsltRequest.onreadystatechange = null;
                }
            }
            else {
                Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                this._environment.updateDomElement(this._domElementId, '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
            }
        }
    },
    
    _getContentUrl: function Framework_TransformAndUpdateTask$_getContentUrl() {
        if (this._useContentUrlDelegate) {
            return this._environment.createRealUrl(this._contentUrlDelegate.invoke());
        }
        else {
            return this._contentUrl;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DOMParser

Framework.DOMParser = function Framework_DOMParser(parent) {
    this._index = {};
    this._parent = parent;
    this._createIndex(this._parent);
}
Framework.DOMParser.searchForElement = function Framework_DOMParser$searchForElement(domElement, ID) {
    if (!domElement) {
        return null;
    }
    if (domElement.id === ID) {
        return domElement;
    }
    for (var i = 0; i < domElement.childNodes.length; i++) {
        var el = Framework.DOMParser.searchForElement(domElement.childNodes[i], ID);
        if (el) {
            return el;
        }
    }
    return null;
}
Framework.DOMParser.prototype = {
    _parent: null,
    
    getElementByID: function Framework_DOMParser$getElementByID(id) {
        return this._index[id];
    },
    
    _createIndex: function Framework_DOMParser$_createIndex(domElement) {
        if (domElement.id !== '') {
            this._index[domElement.id] = domElement;
        }
        for (var i = 0; i < domElement.childNodes.length; i++) {
            this._createIndex(domElement.childNodes[i]);
        }
    },
    
    dispose: function Framework_DOMParser$dispose() {
        this._index = null;
    }
}


Type.createNamespace('Framework.Behavior.Binding');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.BehaviorBinder

Framework.Behavior.Binding.BehaviorBinder = function Framework_Behavior_Binding_BehaviorBinder() {
    this._tasks = {};
}
Framework.Behavior.Binding.BehaviorBinder.autoBind = function Framework_Behavior_Binding_BehaviorBinder$autoBind(domElement, component) {
    if (!component) {
        throw new Error('Component parameter can not be null');
    }
    if (!domElement) {
        throw new Error('DOMElement parameter can not be null');
    }
    Framework.Behavior.Binding.BehaviorBinder._searchAndBind(domElement, null, component);
}
Framework.Behavior.Binding.BehaviorBinder._searchAndBind = function Framework_Behavior_Binding_BehaviorBinder$_searchAndBind(startingPoint, tasks, component) {
    if (!isNullOrUndefined(startingPoint.attributes) && !isNullOrUndefined(startingPoint.getAttribute(Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE))) {
        var attValue = startingPoint.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE).value;
        if (attValue.indexOf('|') === -1) {
            Framework.Behavior.Binding.BehaviorBinder._bindBehavior(startingPoint, attValue, tasks, component);
        }
        else {
            var behaviors = attValue.split('|');
            for (var i = 0; i < behaviors.length; i++) {
                Framework.Behavior.Binding.BehaviorBinder._bindBehavior(startingPoint, behaviors[i], tasks, component);
            }
        }
    }
    for (var i = 0; i < startingPoint.childNodes.length; i++) {
        if (startingPoint.childNodes[i].nodeType === 1) {
            Framework.Behavior.Binding.BehaviorBinder._searchAndBind(startingPoint.childNodes[i], tasks, component);
        }
    }
    startingPoint = null;
}
Framework.Behavior.Binding.BehaviorBinder._bindBehavior = function Framework_Behavior_Binding_BehaviorBinder$_bindBehavior(domElement, behaviorName, tasks, component) {
    if (tasks) {
        Framework.Behavior.Binding.BehaviorBinder._manualBehaviorBind(domElement, behaviorName, tasks);
    }
    else {
        Framework.Behavior.Binding.BehaviorBinder._autoBehaviorBind(domElement, behaviorName, component);
    }
}
Framework.Behavior.Binding.BehaviorBinder._manualBehaviorBind = function Framework_Behavior_Binding_BehaviorBinder$_manualBehaviorBind(domElement, behaviorName, tasks) {
    if (Object.keyExists(tasks, behaviorName)) {
        var binding = tasks[behaviorName];
        binding.bind(domElement);
    }
}
Framework.Behavior.Binding.BehaviorBinder._autoBehaviorBind = function Framework_Behavior_Binding_BehaviorBinder$_autoBehaviorBind(domElement, behaviorName, component) {
    var eventIDAttribute = domElement.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE + '.' + behaviorName);
    if (!eventIDAttribute) {
        eventIDAttribute = domElement.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE + '.' + behaviorName.toLowerCase());
        if (!eventIDAttribute) {
            return;
        }
    }
    var behaviorEvent = Framework.Behavior.ElementBehavior.stringToBehaviorEvent(eventIDAttribute.value);
    var handler = Framework.Behavior.Binding.BehaviorBinder._findEventHandler(component, behaviorName);
    if (!handler) {
        return;
    }
    switch (behaviorEvent) {
        case Framework.Behavior.BehaviorEvent.onclick:
            (new Framework.Behavior.Binding.OnClickBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onload:
            (new Framework.Behavior.Binding.OnLoadBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onchange:
            (new Framework.Behavior.Binding.OnChangeBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onkeyup:
            (new Framework.Behavior.Binding.OnKeyUpBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onmouseover:
            (new Framework.Behavior.Binding.OnMouseOverBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onmouseout:
            (new Framework.Behavior.Binding.OnMouseOutBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onfocus:
            (new Framework.Behavior.Binding.OnFocusBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onblur:
            (new Framework.Behavior.Binding.OnBlurBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onsubmit:
            (new Framework.Behavior.Binding.OnSubmitBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onkeydown:
            (new Framework.Behavior.Binding.OnKeyDownBinding(behaviorName, handler)).bind(domElement);
            break;
    }
}
Framework.Behavior.Binding.BehaviorBinder._findEventHandler = function Framework_Behavior_Binding_BehaviorBinder$_findEventHandler(component, behaviorName) {
    var handlerName = behaviorName + Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_HANDLER_SUFFIX;
    handlerName = handlerName.charAt(0).toString().toLowerCase() + handlerName.substr(1);
    var handler = component[handlerName];
    if (typeof(handler) !== 'function') {
        return null;
    }
    return Delegate.create(component, handler);
}
Framework.Behavior.Binding.BehaviorBinder.prototype = {
    
    addBinding: function Framework_Behavior_Binding_BehaviorBinder$addBinding(binding) {
        this._tasks[binding.get_behaviorID()] = binding;
    },
    
    bind: function Framework_Behavior_Binding_BehaviorBinder$bind(startingPoint) {
        if (isNullOrUndefined(this._tasks) || !Object.getKeyCount(this._tasks)) {
            return;
        }
        Framework.Behavior.Binding.BehaviorBinder._searchAndBind(startingPoint, this._tasks, null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.AbstractBinding

Framework.Behavior.Binding.AbstractBinding = function Framework_Behavior_Binding_AbstractBinding(behaviorID, eventHandler) {
    this._behaviorID = behaviorID;
    this._eventHandler = eventHandler;
}
Framework.Behavior.Binding.AbstractBinding.prototype = {
    _behaviorID: null,
    
    get_behaviorID: function Framework_Behavior_Binding_AbstractBinding$get_behaviorID() {
        return this._behaviorID;
    },
    
    _eventHandler: null,
    
    get_eventHandler: function Framework_Behavior_Binding_AbstractBinding$get_eventHandler() {
        return this._eventHandler;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnKeyDownBinding

Framework.Behavior.Binding.OnKeyDownBinding = function Framework_Behavior_Binding_OnKeyDownBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnKeyDownBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnKeyDownBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnKeyDownBinding$bind(domElement) {
        new Framework.Behavior.OnKeyDownBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnSubmitBinding

Framework.Behavior.Binding.OnSubmitBinding = function Framework_Behavior_Binding_OnSubmitBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnSubmitBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnSubmitBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnSubmitBinding$bind(domElement) {
        new Framework.Behavior.OnSubmitBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnBlurBinding

Framework.Behavior.Binding.OnBlurBinding = function Framework_Behavior_Binding_OnBlurBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnBlurBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnBlurBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnBlurBinding$bind(domElement) {
        new Framework.Behavior.OnBlurBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnFocusBinding

Framework.Behavior.Binding.OnFocusBinding = function Framework_Behavior_Binding_OnFocusBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnFocusBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnFocusBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnFocusBinding$bind(domElement) {
        new Framework.Behavior.OnFocusBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnMouseOutBinding

Framework.Behavior.Binding.OnMouseOutBinding = function Framework_Behavior_Binding_OnMouseOutBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnMouseOutBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnMouseOutBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnMouseOutBinding$bind(domElement) {
        new Framework.Behavior.OnMouseOutBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnMouseOverBinding

Framework.Behavior.Binding.OnMouseOverBinding = function Framework_Behavior_Binding_OnMouseOverBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnMouseOverBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnMouseOverBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnMouseOverBinding$bind(domElement) {
        new Framework.Behavior.OnMouseOverBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnKeyUpBinding

Framework.Behavior.Binding.OnKeyUpBinding = function Framework_Behavior_Binding_OnKeyUpBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnKeyUpBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnKeyUpBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnKeyUpBinding$bind(domElement) {
        new Framework.Behavior.OnKeyUpBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnChangeBinding

Framework.Behavior.Binding.OnChangeBinding = function Framework_Behavior_Binding_OnChangeBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnChangeBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnChangeBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnChangeBinding$bind(domElement) {
        new Framework.Behavior.OnChangeBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnLoadBinding

Framework.Behavior.Binding.OnLoadBinding = function Framework_Behavior_Binding_OnLoadBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnLoadBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnLoadBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnLoadBinding$bind(domElement) {
        new Framework.Behavior.OnLoadBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnClickBinding

Framework.Behavior.Binding.OnClickBinding = function Framework_Behavior_Binding_OnClickBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnClickBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnClickBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnClickBinding$bind(domElement) {
        new Framework.Behavior.OnClickBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


Type.createNamespace('Framework.Behavior');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.BehaviorEvent

Framework.Behavior.BehaviorEvent = function() { };
Framework.Behavior.BehaviorEvent.prototype = {
    onclick: 0, 
    onload: 1, 
    onchange: 2, 
    onkeyup: 3, 
    onmouseover: 4, 
    onmouseout: 5, 
    onfocus: 6, 
    onblur: 7, 
    onsubmit: 8, 
    onkeydown: 9
}
Framework.Behavior.BehaviorEvent.createEnum('Framework.Behavior.BehaviorEvent', false);


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnKeyDownBehavior

Framework.Behavior.OnKeyDownBehavior = function Framework_Behavior_OnKeyDownBehavior(domElement, behaviorID, onKeyDownEventHandler) {
    Framework.Behavior.OnKeyDownBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onKeyDown(onKeyDownEventHandler);
}
Framework.Behavior.OnKeyDownBehavior.prototype = {
    _behaviorID$2: null,
    
    onKeyDownEventFired: function Framework_Behavior_OnKeyDownBehavior$onKeyDownEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyDownEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onKeyDownEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnSubmitBehavior

Framework.Behavior.OnSubmitBehavior = function Framework_Behavior_OnSubmitBehavior(domElement, behaviorID, onSubmitEventHandler) {
    Framework.Behavior.OnSubmitBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onSubmit(onSubmitEventHandler);
}
Framework.Behavior.OnSubmitBehavior.prototype = {
    _behaviorID$2: null,
    
    onSubmitEventFired: function Framework_Behavior_OnSubmitBehavior$onSubmitEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnSubmitEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onSubmitEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnBlurBehavior

Framework.Behavior.OnBlurBehavior = function Framework_Behavior_OnBlurBehavior(domElement, behaviorID, onBlurEventHandler) {
    Framework.Behavior.OnBlurBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onBlur(onBlurEventHandler);
}
Framework.Behavior.OnBlurBehavior.prototype = {
    _behaviorID$2: null,
    
    onBlurEventFired: function Framework_Behavior_OnBlurBehavior$onBlurEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnBlurEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onBlurEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnFocusBehavior

Framework.Behavior.OnFocusBehavior = function Framework_Behavior_OnFocusBehavior(domElement, behaviorID, onFocusEventHandler) {
    Framework.Behavior.OnFocusBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onFocus(onFocusEventHandler);
}
Framework.Behavior.OnFocusBehavior.prototype = {
    _behaviorID$2: null,
    
    onFocusEventFired: function Framework_Behavior_OnFocusBehavior$onFocusEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnFocusEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onFocusEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnMouseOutBehavior

Framework.Behavior.OnMouseOutBehavior = function Framework_Behavior_OnMouseOutBehavior(domElement, behaviorID, onMouseOutEventHandler) {
    Framework.Behavior.OnMouseOutBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onMouseOut(onMouseOutEventHandler);
}
Framework.Behavior.OnMouseOutBehavior.prototype = {
    _behaviorID$2: null,
    
    onMouseOutEventFired: function Framework_Behavior_OnMouseOutBehavior$onMouseOutEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOutEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onMouseOutEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnMouseOverBehavior

Framework.Behavior.OnMouseOverBehavior = function Framework_Behavior_OnMouseOverBehavior(domElement, behaviorID, onMouseOverEventHandler) {
    Framework.Behavior.OnMouseOverBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onMouseOver(onMouseOverEventHandler);
}
Framework.Behavior.OnMouseOverBehavior.prototype = {
    _behaviorID$2: null,
    
    onMouseOverEventFired: function Framework_Behavior_OnMouseOverBehavior$onMouseOverEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOverEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onMouseOverEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnKeyUpBehavior

Framework.Behavior.OnKeyUpBehavior = function Framework_Behavior_OnKeyUpBehavior(domElement, behaviorID, onKeyUpEventHandler) {
    Framework.Behavior.OnKeyUpBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onKeyUp(onKeyUpEventHandler);
}
Framework.Behavior.OnKeyUpBehavior.prototype = {
    _behaviorID$2: null,
    
    onKeyUpEventFired: function Framework_Behavior_OnKeyUpBehavior$onKeyUpEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyUpEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onKeyUpEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnChangeBehavior

Framework.Behavior.OnChangeBehavior = function Framework_Behavior_OnChangeBehavior(domElement, behaviorID, onChangeEventHandler) {
    Framework.Behavior.OnChangeBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onChange(onChangeEventHandler);
}
Framework.Behavior.OnChangeBehavior.prototype = {
    _behaviorID$2: null,
    
    onChangeEventFired: function Framework_Behavior_OnChangeBehavior$onChangeEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnChangeEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onChangeEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnLoadBehavior

Framework.Behavior.OnLoadBehavior = function Framework_Behavior_OnLoadBehavior(domElement, behaviorID, onLoadEventHandler) {
    var eventArgs = new Framework.Behavior.EventArgs.OnLoadEventArgs();
    eventArgs.domElement = domElement;
    eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(domElement, behaviorID));
    onLoadEventHandler.invoke(this, eventArgs);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnClickBehavior

Framework.Behavior.OnClickBehavior = function Framework_Behavior_OnClickBehavior(domElement, behaviorID, onClickEventHandler) {
    Framework.Behavior.OnClickBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onClick(onClickEventHandler);
}
Framework.Behavior.OnClickBehavior.prototype = {
    _behaviorID$2: null,
    
    onClickEventFired: function Framework_Behavior_OnClickBehavior$onClickEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnClickEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onClickEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.ElementBehavior

Framework.Behavior.ElementBehavior = function Framework_Behavior_ElementBehavior(domElement) {
    Framework.Behavior.ElementBehavior.constructBase(this, [ domElement, null ]);
}
Framework.Behavior.ElementBehavior.detachEvent = function Framework_Behavior_ElementBehavior$detachEvent(domElement, eventName) {
    var behaviors = 'ScriptFX.UI.Behavior'.getBehaviors(domElement, null);
    if (!behaviors) {
        return;
    }
    var $enum1 = behaviors.getEnumerator();
    while ($enum1.moveNext()) {
        var behavior = $enum1.get_current();
        switch (eventName) {
            case Framework.Behavior.BehaviorEvent.onclick:
                if (behavior.detachAllOnClick) {
                    (behavior).detachAllOnClick();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onchange:
                if (behavior.detachAllOnChange) {
                    (behavior).detachAllOnChange();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onkeyup:
                if (behavior.detachAllOnKeyUp) {
                    (behavior).detachAllOnKeyUp();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onmouseover:
                if (behavior.detachAllOnMouseOver) {
                    (behavior).detachAllOnMouseOver();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onmouseout:
                if (behavior.detachAllOnMouseOut) {
                    (behavior).detachAllOnMouseOut();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onfocus:
                if (behavior.detachAllOnFocus) {
                    (behavior).detachAllOnFocus();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onblur:
                if (behavior.detachAllOnBlur) {
                    (behavior).detachAllOnBlur();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onsubmit:
                if (behavior.detachAllOnSubmit) {
                    (behavior).detachAllOnSubmit();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onkeydown:
                if (behavior.detachAllOnKeyDown) {
                    (behavior).detachAllOnKeyDown();
                }
                break;
        }
    }
}
Framework.Behavior.ElementBehavior.behaviorEventToString = function Framework_Behavior_ElementBehavior$behaviorEventToString(eventName) {
    switch (eventName) {
        case Framework.Behavior.BehaviorEvent.onclick:
            return 'onclick';
        case Framework.Behavior.BehaviorEvent.onload:
            return 'onload';
        case Framework.Behavior.BehaviorEvent.onchange:
            return 'onchange';
        case Framework.Behavior.BehaviorEvent.onkeyup:
            return 'onkeyup';
        case Framework.Behavior.BehaviorEvent.onmouseover:
            return 'onmouseover';
        case Framework.Behavior.BehaviorEvent.onmouseout:
            return 'onmouseout';
        case Framework.Behavior.BehaviorEvent.onfocus:
            return 'onfocus';
        case Framework.Behavior.BehaviorEvent.onblur:
            return 'onblur';
        case Framework.Behavior.BehaviorEvent.onsubmit:
            return 'onsubmit';
        case Framework.Behavior.BehaviorEvent.onkeydown:
            return 'onkeydown';
        default:
            throw new Error('Behavior event name not recognized');
    }
}
Framework.Behavior.ElementBehavior.stringToBehaviorEvent = function Framework_Behavior_ElementBehavior$stringToBehaviorEvent(eventName) {
    switch (eventName) {
        case 'onclick':
            return Framework.Behavior.BehaviorEvent.onclick;
        case 'onload':
            return Framework.Behavior.BehaviorEvent.onload;
        case 'onchange':
            return Framework.Behavior.BehaviorEvent.onchange;
        case 'onkeyup':
            return Framework.Behavior.BehaviorEvent.onkeyup;
        case 'onmouseover':
            return Framework.Behavior.BehaviorEvent.onmouseover;
        case 'onmouseout':
            return Framework.Behavior.BehaviorEvent.onmouseout;
        case 'onfocus':
            return Framework.Behavior.BehaviorEvent.onfocus;
        case 'onblur':
            return Framework.Behavior.BehaviorEvent.onblur;
        case 'onsubmit':
            return Framework.Behavior.BehaviorEvent.onsubmit;
        case 'onkeydown':
            return Framework.Behavior.BehaviorEvent.onkeydown;
        default:
            throw new Error('Behavior event name not recognized');
    }
}
Framework.Behavior.ElementBehavior.prototype = {
    isBehaviorDisposed: false,
    _onClickEventHandler: null,
    
    add_onClick: function Framework_Behavior_ElementBehavior$add_onClick(value) {
        this._onClickEventHandler = Delegate.combine(this._onClickEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick), Delegate.create(this, this.onClickEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick, value);
        }
    },
    remove_onClick: function Framework_Behavior_ElementBehavior$remove_onClick(value) {
        this._onClickEventHandler = Delegate.remove(this._onClickEventHandler, value);
        if (!this._onClickEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick);
        }
    },
    
    detachAllOnClick: function Framework_Behavior_ElementBehavior$detachAllOnClick() {
        this._onClickEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick);
    },
    
    onClickEventFired: function Framework_Behavior_ElementBehavior$onClickEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnClickEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onClickEventHandler.invoke(this, eventArgs);
    },
    
    _onChangeEventHandler: null,
    
    add_onChange: function Framework_Behavior_ElementBehavior$add_onChange(value) {
        this._onChangeEventHandler = Delegate.combine(this._onChangeEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange), Delegate.create(this, this.onChangeEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange, value);
        }
    },
    remove_onChange: function Framework_Behavior_ElementBehavior$remove_onChange(value) {
        this._onChangeEventHandler = Delegate.remove(this._onChangeEventHandler, value);
        if (!this._onChangeEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange);
        }
    },
    
    detachAllOnChange: function Framework_Behavior_ElementBehavior$detachAllOnChange() {
        this._onChangeEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange);
    },
    
    onChangeEventFired: function Framework_Behavior_ElementBehavior$onChangeEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnChangeEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onChangeEventHandler.invoke(this, eventArgs);
    },
    
    _onKeyUpEventHandler: null,
    
    add_onKeyUp: function Framework_Behavior_ElementBehavior$add_onKeyUp(value) {
        this._onKeyUpEventHandler = Delegate.combine(this._onKeyUpEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup), Delegate.create(this, this.onKeyUpEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup, value);
        }
    },
    remove_onKeyUp: function Framework_Behavior_ElementBehavior$remove_onKeyUp(value) {
        this._onKeyUpEventHandler = Delegate.remove(this._onKeyUpEventHandler, value);
        if (!this._onKeyUpEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup);
        }
    },
    
    detachAllOnKeyUp: function Framework_Behavior_ElementBehavior$detachAllOnKeyUp() {
        this._onKeyUpEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup);
    },
    
    onKeyUpEventFired: function Framework_Behavior_ElementBehavior$onKeyUpEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyUpEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onKeyUpEventHandler.invoke(this, eventArgs);
    },
    
    _onMouseOverEventHandler: null,
    
    add_onMouseOver: function Framework_Behavior_ElementBehavior$add_onMouseOver(value) {
        this._onMouseOverEventHandler = Delegate.combine(this._onMouseOverEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover), Delegate.create(this, this.onMouseOverEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover, value);
        }
    },
    remove_onMouseOver: function Framework_Behavior_ElementBehavior$remove_onMouseOver(value) {
        this._onMouseOverEventHandler = Delegate.remove(this._onMouseOverEventHandler, value);
        if (!this._onMouseOverEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover);
        }
    },
    
    detachAllOnMouseOver: function Framework_Behavior_ElementBehavior$detachAllOnMouseOver() {
        this._onMouseOverEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover);
    },
    
    onMouseOverEventFired: function Framework_Behavior_ElementBehavior$onMouseOverEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOverEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onMouseOverEventHandler.invoke(this, eventArgs);
    },
    
    _onMouseOutEventHandler: null,
    
    add_onMouseOut: function Framework_Behavior_ElementBehavior$add_onMouseOut(value) {
        this._onMouseOutEventHandler = Delegate.combine(this._onMouseOutEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout), Delegate.create(this, this.onMouseOutEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout, value);
        }
    },
    remove_onMouseOut: function Framework_Behavior_ElementBehavior$remove_onMouseOut(value) {
        this._onMouseOutEventHandler = Delegate.remove(this._onMouseOutEventHandler, value);
        if (!this._onMouseOutEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout);
        }
    },
    
    detachAllOnMouseOut: function Framework_Behavior_ElementBehavior$detachAllOnMouseOut() {
        this._onMouseOutEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout);
    },
    
    onMouseOutEventFired: function Framework_Behavior_ElementBehavior$onMouseOutEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOutEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onMouseOutEventHandler.invoke(this, eventArgs);
    },
    
    _onFocusEventHandler: null,
    
    add_onFocus: function Framework_Behavior_ElementBehavior$add_onFocus(value) {
        this._onFocusEventHandler = Delegate.combine(this._onFocusEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus), Delegate.create(this, this.onFocusEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus, value);
        }
    },
    remove_onFocus: function Framework_Behavior_ElementBehavior$remove_onFocus(value) {
        this._onFocusEventHandler = Delegate.remove(this._onFocusEventHandler, value);
        if (!this._onFocusEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus);
        }
    },
    
    detachAllOnFocus: function Framework_Behavior_ElementBehavior$detachAllOnFocus() {
        this._onFocusEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus);
    },
    
    onFocusEventFired: function Framework_Behavior_ElementBehavior$onFocusEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnFocusEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onFocusEventHandler.invoke(this, eventArgs);
    },
    
    _onBlurEventHandler: null,
    
    add_onBlur: function Framework_Behavior_ElementBehavior$add_onBlur(value) {
        this._onBlurEventHandler = Delegate.combine(this._onBlurEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur), Delegate.create(this, this.onBlurEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur, value);
        }
    },
    remove_onBlur: function Framework_Behavior_ElementBehavior$remove_onBlur(value) {
        this._onBlurEventHandler = Delegate.remove(this._onBlurEventHandler, value);
        if (!this._onBlurEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur);
        }
    },
    
    detachAllOnBlur: function Framework_Behavior_ElementBehavior$detachAllOnBlur() {
        this._onBlurEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur);
    },
    
    onBlurEventFired: function Framework_Behavior_ElementBehavior$onBlurEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnBlurEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onBlurEventHandler.invoke(this, eventArgs);
    },
    
    _onSubmitEventHandler: null,
    
    add_onSubmit: function Framework_Behavior_ElementBehavior$add_onSubmit(value) {
        this._onSubmitEventHandler = Delegate.combine(this._onSubmitEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit), Delegate.create(this, this.onSubmitEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit, value);
        }
    },
    remove_onSubmit: function Framework_Behavior_ElementBehavior$remove_onSubmit(value) {
        this._onSubmitEventHandler = Delegate.remove(this._onSubmitEventHandler, value);
        if (!this._onBlurEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit);
        }
    },
    
    detachAllOnSubmit: function Framework_Behavior_ElementBehavior$detachAllOnSubmit() {
        this._onSubmitEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit);
    },
    
    onSubmitEventFired: function Framework_Behavior_ElementBehavior$onSubmitEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnSubmitEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onSubmitEventHandler.invoke(this, eventArgs);
    },
    
    _onKeyDownEventHandler: null,
    
    add_onKeyDown: function Framework_Behavior_ElementBehavior$add_onKeyDown(value) {
        this._onKeyDownEventHandler = Delegate.combine(this._onKeyDownEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeydown))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeydown), Delegate.create(this, this.onKeyDownEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeydown, value);
        }
    },
    remove_onKeyDown: function Framework_Behavior_ElementBehavior$remove_onKeyDown(value) {
        this._onKeyDownEventHandler = Delegate.remove(this._onKeyDownEventHandler, value);
        if (!this._onKeyDownEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeydown));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeydown);
        }
    },
    
    detachAllOnKeyDown: function Framework_Behavior_ElementBehavior$detachAllOnKeyDown() {
        this._onKeyDownEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeydown);
    },
    
    onKeyDownEventFired: function Framework_Behavior_ElementBehavior$onKeyDownEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyDownEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onKeyDownEventHandler.invoke(this, eventArgs);
    },
    
    dispose: function Framework_Behavior_ElementBehavior$dispose() {
        if (this.isBehaviorDisposed) {
            return;
        }
        if (!this.get_isDisposed()) {
            this.get_domEvents().dispose();
            Framework.Behavior.ElementBehavior.callBase(this, 'dispose');
        }
        this._onClickEventHandler = null;
        this._onChangeEventHandler = null;
        this._onKeyUpEventHandler = null;
        this._onMouseOverEventHandler = null;
        this._onMouseOutEventHandler = null;
        this._onFocusEventHandler = null;
        this._onBlurEventHandler = null;
        this._onSubmitEventHandler = null;
        this._onKeyDownEventHandler = null;
        this.isBehaviorDisposed = true;
    },
    
    _addDebugAttribute$1: function Framework_Behavior_ElementBehavior$_addDebugAttribute$1(eventName, value) {
        if (this.get__isDevelopmentModeTurnedOn$1()) {
            this.get_domElement().setAttribute(this._getDebugAttributeName$1(eventName), this._getDelegateDebugInfo$1(value));
        }
    },
    
    _removeDebugAttribute$1: function Framework_Behavior_ElementBehavior$_removeDebugAttribute$1(eventName) {
        if (this.get__isDevelopmentModeTurnedOn$1()) {
            this.get_domElement().removeAttribute(this._getDebugAttributeName$1(eventName));
        }
    },
    
    _getDebugAttributeName$1: function Framework_Behavior_ElementBehavior$_getDebugAttributeName$1(eventName) {
        return 'debug.behavior.' + Framework.Behavior.ElementBehavior.behaviorEventToString(eventName) + '_boundto';
    },
    
    get__isDevelopmentModeTurnedOn$1: function Framework_Behavior_ElementBehavior$get__isDevelopmentModeTurnedOn$1() {
        return Framework.AbstractEnvironment._debugMode;
    },
    
    _getDelegateDebugInfo$1: function Framework_Behavior_ElementBehavior$_getDelegateDebugInfo$1(value) {
        return Framework.Util.DebugInfoProvider.delegateDebugInfo(value);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.UrlRewrittingInfoObject

Framework.Behavior.UrlRewrittingInfoObject = function Framework_Behavior_UrlRewrittingInfoObject() {
    this.urlItems = {};
    this.descriptiveItems = [];
}
Framework.Behavior.UrlRewrittingInfoObject.prototype = {
    pageArea: null,
    region: null,
    
    addUrlItem: function Framework_Behavior_UrlRewrittingInfoObject$addUrlItem(key, value) {
    }
}


Type.createNamespace('Framework.Behavior.EventArgs');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnKeyDownEventArgs

Framework.Behavior.EventArgs.OnKeyDownEventArgs = function Framework_Behavior_EventArgs_OnKeyDownEventArgs() {
    Framework.Behavior.EventArgs.OnKeyDownEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnSubmitEventArgs

Framework.Behavior.EventArgs.OnSubmitEventArgs = function Framework_Behavior_EventArgs_OnSubmitEventArgs() {
    Framework.Behavior.EventArgs.OnSubmitEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnBlurEventArgs

Framework.Behavior.EventArgs.OnBlurEventArgs = function Framework_Behavior_EventArgs_OnBlurEventArgs() {
    Framework.Behavior.EventArgs.OnBlurEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnFocusEventArgs

Framework.Behavior.EventArgs.OnFocusEventArgs = function Framework_Behavior_EventArgs_OnFocusEventArgs() {
    Framework.Behavior.EventArgs.OnFocusEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnMouseOutEventArgs

Framework.Behavior.EventArgs.OnMouseOutEventArgs = function Framework_Behavior_EventArgs_OnMouseOutEventArgs() {
    Framework.Behavior.EventArgs.OnMouseOutEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnMouseOverEventArgs

Framework.Behavior.EventArgs.OnMouseOverEventArgs = function Framework_Behavior_EventArgs_OnMouseOverEventArgs() {
    Framework.Behavior.EventArgs.OnMouseOverEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnKeyUpEventArgs

Framework.Behavior.EventArgs.OnKeyUpEventArgs = function Framework_Behavior_EventArgs_OnKeyUpEventArgs() {
    Framework.Behavior.EventArgs.OnKeyUpEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.Parameters

Framework.Behavior.EventArgs.Parameters = function Framework_Behavior_EventArgs_Parameters(parameters) {
    this._parameters = parameters;
}
Framework.Behavior.EventArgs.Parameters.prototype = {
    _parameters: null,
    
    getAsInt32: function Framework_Behavior_EventArgs_Parameters$getAsInt32(parametername) {
        return Framework.Util.StringConverter.getAsInt32(this._parameters[parametername]);
    },
    
    getAsNumber: function Framework_Behavior_EventArgs_Parameters$getAsNumber(parametername) {
        return Framework.Util.StringConverter.getAsNumber(this._parameters[parametername]);
    },
    
    getAsString: function Framework_Behavior_EventArgs_Parameters$getAsString(parametername) {
        return Framework.Util.StringConverter.getAsString(this._parameters[parametername]);
    },
    
    getAsStringArray: function Framework_Behavior_EventArgs_Parameters$getAsStringArray(parametername) {
        return Framework.Util.StringConverter.getAsStringArray(this._parameters[parametername]);
    },
    
    getAsNumberArray: function Framework_Behavior_EventArgs_Parameters$getAsNumberArray(parametername) {
        return Framework.Util.StringConverter.getAsNumberArray(this._parameters[parametername]);
    },
    
    getAsBoolean: function Framework_Behavior_EventArgs_Parameters$getAsBoolean(parametername) {
        return Framework.Util.StringConverter.getAsBoolean(this._parameters[parametername]);
    },
    
    getAsEscapedString: function Framework_Behavior_EventArgs_Parameters$getAsEscapedString(parametername) {
        return Framework.Util.StringConverter.getAsEscapedString(this._parameters[parametername]);
    },
    
    getAsDictionary: function Framework_Behavior_EventArgs_Parameters$getAsDictionary(parametername) {
        return Framework.Util.StringConverter.getAsDictionary(this._parameters[parametername]);
    },
    
    containsKey: function Framework_Behavior_EventArgs_Parameters$containsKey(parametername) {
        return Object.keyExists(this._parameters, parametername);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnLoadEventArgs

Framework.Behavior.EventArgs.OnLoadEventArgs = function Framework_Behavior_EventArgs_OnLoadEventArgs() {
    Framework.Behavior.EventArgs.OnLoadEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.BehaviorEventArgs

Framework.Behavior.EventArgs.BehaviorEventArgs = function Framework_Behavior_EventArgs_BehaviorEventArgs() {
}
Framework.Behavior.EventArgs.BehaviorEventArgs.prototype = {
    domElement: null,
    parameters: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnChangeEventArgs

Framework.Behavior.EventArgs.OnChangeEventArgs = function Framework_Behavior_EventArgs_OnChangeEventArgs() {
    Framework.Behavior.EventArgs.OnChangeEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnClickEventArgs

Framework.Behavior.EventArgs.OnClickEventArgs = function Framework_Behavior_EventArgs_OnClickEventArgs() {
    Framework.Behavior.EventArgs.OnClickEventArgs.constructBase(this);
}


Type.createNamespace('Framework.Component');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.IDynamicComponent

Framework.Component.IDynamicComponent = function() { };
Framework.Component.IDynamicComponent.prototype = {
    get_componentLifeCycleManager : null,
    get_componentInstanceName : null,
    get_domElementId : null,
    createDynamicComponent : null,
    killAllDynamicChildComponents : null,
    dispose : null
}
Framework.Component.IDynamicComponent.createInterface('Framework.Component.IDynamicComponent');


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.AbstractComponent

Framework.Component.AbstractComponent = function Framework_Component_AbstractComponent() {
    this._log = Framework.Logger.getLog('AbstractComponent');
    this._children = new Array(0);
    this._dynamicChildren = new Array(0);
    this._dynamicChildrenHashTable = {};
    this._componentLifeCycleManager = this.createComponentLifeCycleManager();
}
Framework.Component.AbstractComponent.setFormEnabled = function Framework_Component_AbstractComponent$setFormEnabled(domElementId, enabled) {
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('select'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('input'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('button'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('textarea'), enabled);
}
Framework.Component.AbstractComponent._setCollectionEnabled = function Framework_Component_AbstractComponent$_setCollectionEnabled(domElementCollection, enabled) {
    for (var i = 0; i < domElementCollection.length; i++) {
        domElementCollection[i].disabled = !enabled;
    }
}
Framework.Component.AbstractComponent.prototype = {
    _environment: null,
    _componentInstanceName: null,
    _domElementId: null,
    _currentArea: 0,
    _area: null,
    _adminHtmlUrl: null,
    _childID: null,
    _cssClass: null,
    _visibleNavigationTypes: null,
    
    get_visibleNavigationTypes: function Framework_Component_AbstractComponent$get_visibleNavigationTypes() {
        return this._visibleNavigationTypes;
    },
    
    get_cssClass: function Framework_Component_AbstractComponent$get_cssClass() {
        return this._cssClass;
    },
    
    _parent: null,
    _siblingIndex: 0,
    _componentLifeCycleManager: null,
    
    get_componentLifeCycleManager: function Framework_Component_AbstractComponent$get_componentLifeCycleManager() {
        return this._componentLifeCycleManager;
    },
    
    childrenUpdateComplete: function Framework_Component_AbstractComponent$childrenUpdateComplete(eventArgs) {
    },
    
    childComponentUpdateComplete: function Framework_Component_AbstractComponent$childComponentUpdateComplete(eventArgs) {
    },
    
    createDynamicComponent: function Framework_Component_AbstractComponent$createDynamicComponent(componentType, placeholder, startComponent, customComponentParameters) {
        var component = Framework.Component.ComponentFactory.createDynamicComponent(componentType, this, placeholder, customComponentParameters, startComponent);
        this._dynamicChildren[this._dynamicChildren.length] = component;
        this._dynamicChildrenHashTable[component.get_componentInstanceName()] = component;
        return component.get_componentInstanceName();
    },
    
    killDynamicChildComponent: function Framework_Component_AbstractComponent$killDynamicChildComponent(component) {
        if (!this._dynamicChildren.contains(component)) {
            throw new Error(String.format('Error: AbstractComponent, RemoveDynamicComponent => Component \'{0}\' is not child component of the component \'{1}\'', component.get_componentInstanceName(), this.get_componentInstanceName()));
        }
        Framework.Component.ComponentFactory.deleteComponent(component);
        var newArray = new Array(0);
        var $enum1 = this._dynamicChildren.getEnumerator();
        while ($enum1.moveNext()) {
            var com = $enum1.get_current();
            if (com !== component) {
                newArray[newArray.length] = com;
            }
        }
        this._dynamicChildren = newArray;
        this._dynamicChildrenHashTable[component.get_componentInstanceName()] = null;
    },
    
    killAllDynamicChildComponents: function Framework_Component_AbstractComponent$killAllDynamicChildComponents() {
        var $enum1 = this._dynamicChildren.getEnumerator();
        while ($enum1.moveNext()) {
            var component = $enum1.get_current();
            Framework.Component.ComponentFactory.deleteComponent(component);
        }
        this._dynamicChildren = new Array(0);
        this._dynamicChildrenHashTable = {};
    },
    
    get_hasDynamicChildren: function Framework_Component_AbstractComponent$get_hasDynamicChildren() {
        return ((this._dynamicChildren) && (this._dynamicChildren.length > 0));
    },
    
    get_dynamicChildren: function Framework_Component_AbstractComponent$get_dynamicChildren() {
        return this._dynamicChildren;
    },
    
    getDynamicChildByInstanceName: function Framework_Component_AbstractComponent$getDynamicChildByInstanceName(instanceName) {
        return this._dynamicChildrenHashTable[instanceName];
    },
    
    dispose: function Framework_Component_AbstractComponent$dispose() {
    },
    
    get_componentInstanceName: function Framework_Component_AbstractComponent$get_componentInstanceName() {
        return this._componentInstanceName;
    },
    
    get_domElementId: function Framework_Component_AbstractComponent$get_domElementId() {
        return this._domElementId;
    },
    set_domElementId: function Framework_Component_AbstractComponent$set_domElementId(value) {
        this._domElementId = value;
        return value;
    },
    
    init: function Framework_Component_AbstractComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log = Framework.Logger.getLog(domElementId);
        this._log.debug('Init');
        this._environment = environment;
        this._componentInstanceName = componentInstanceName;
        this._domElementId = domElementId;
        this._adminHtmlUrl = parameters['admin-html-url'];
        this._cssClass = parameters['css-class'];
        if (!String.isNullOrEmpty(parameters['visible-navigation-types'])) {
            this._visibleNavigationTypes = ScriptFX.JSON.deserialize((parameters['visible-navigation-types']));
        }
    },
    
    start: function Framework_Component_AbstractComponent$start() {
        this._log.debug('Start');
    },
    
    repaintForAdmin: function Framework_Component_AbstractComponent$repaintForAdmin() {
        var ajaxUpdater = new Framework.AjaxUpdater(this._domElementId, this._adminHtmlUrl, null, Delegate.create(this, function() {
            this._environment.updateDomElement(this._domElementId, this._domElementId);
        }));
        ajaxUpdater.update();
    },
    
    createComponentLifeCycleManager: function Framework_Component_AbstractComponent$createComponentLifeCycleManager() {
        return new Framework.Component.LifeCycleManagement.ComponentLifeCycleManager(this);
    },
    
    disableForAdmin: function Framework_Component_AbstractComponent$disableForAdmin() {
        var anchors = this._environment.getDomElement(this._domElementId).getElementsByTagName('A');
        for (var i = 0; i < anchors.length; i++) {
            var anchor = anchors[i];
            anchor.setAttribute('href', '#');
            anchor.setAttribute('onclick', 'return false;');
        }
    },
    
    isVisible: function Framework_Component_AbstractComponent$isVisible(visibleOn, notVisibleOn, action) {
        if (!visibleOn.length && !notVisibleOn.length) {
            return true;
        }
        if (visibleOn.length > 0) {
            return visibleOn.contains(action);
        }
        if (notVisibleOn.length > 0) {
            return !notVisibleOn.contains(action);
        }
        throw new Error('Parameters were not specified correctly.');
    },
    
    isNavigationTypesInAValidCombination: function Framework_Component_AbstractComponent$isNavigationTypesInAValidCombination(currentNavTypes) {
        var navtypesToCheck = this.get_visibleNavigationTypes();
        if (!currentNavTypes) {
            return true;
        }
        if (!navtypesToCheck) {
            return true;
        }
        for (var count = 0; count < navtypesToCheck.length; count++) {
            if (navtypesToCheck[count].isMatch(currentNavTypes)) {
                return true;
            }
        }
        return false;
    },
    
    show: function Framework_Component_AbstractComponent$show() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'block';
    },
    
    hide: function Framework_Component_AbstractComponent$hide() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'none';
    },
    
    disable: function Framework_Component_AbstractComponent$disable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'wait';
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    enable: function Framework_Component_AbstractComponent$enable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'default';
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    getPrivateDomElement: function Framework_Component_AbstractComponent$getPrivateDomElement(domElementNameSuffix) {
        return document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
    },
    
    updatePrivateDomElement: function Framework_Component_AbstractComponent$updatePrivateDomElement(domElementNameSuffix, htmlContent) {
        this.updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, null, null);
    },
    
    updatePrivateDomElementWithCallback: function Framework_Component_AbstractComponent$updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, successCallback, failureCallback) {
        try {
            var element = document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
            if (element) {
                this._environment.updateDomElementDirect(element, htmlContent);
                if (successCallback) {
                    successCallback.invoke();
                }
            }
            else {
                throw new Error(String.format('domElementNameSuffix [{0}] cannot be found!', domElementNameSuffix));
            }
        }
        catch (ex) {
            this._log.error('UpdatePrivateDomElement', ex);
            if (failureCallback) {
                failureCallback.invoke(ex);
            }
        }
    },
    
    activateArea: function Framework_Component_AbstractComponent$activateArea(area, messages) {
        this._log.debug(String.format('ActivateArea area=[{0}] messages=[{1}]', area, messages));
        var areaElement = this.getPrivateDomElement(this._area[this._currentArea]);
        if (areaElement) {
            areaElement.style.display = 'none';
        }
        this._currentArea = area;
        areaElement = this.getPrivateDomElement(this._area[this._currentArea]);
        if (areaElement) {
            areaElement.style.display = 'block';
        }
        if (messages) {
            for (var i = 0; i < messages.length; i++) {
                if (!String.isNullOrEmpty(messages[i])) {
                    this.getPrivateDomElement(this._area[this._currentArea] + '-' + i).innerText = messages[i];
                }
            }
        }
    },
    
    getTranslation: function Framework_Component_AbstractComponent$getTranslation(phrase) {
        return this.getPrivateDomElement(phrase).innerHTML;
    },
    
    get_parent: function Framework_Component_AbstractComponent$get_parent() {
        return this._parent;
    },
    
    get_childID: function Framework_Component_AbstractComponent$get_childID() {
        return this._childID;
    },
    set_childID: function Framework_Component_AbstractComponent$set_childID(value) {
        this._childID = value;
        return value;
    },
    
    startChildren: function Framework_Component_AbstractComponent$startChildren() {
        for (var index = 0; index < this._children.length; index++) {
            var newComponent = (this._children[index]);
            if (!isNullOrUndefined(newComponent.get_componentLifeCycleManager())) {
                newComponent.get_componentLifeCycleManager().start();
            }
            else {
                this._children[index].start();
            }
        }
    },
    
    addChild: function Framework_Component_AbstractComponent$addChild(child) {
        var index = this._children.length;
        this._children[index] = child;
        child._parent = this;
        child._siblingIndex = index;
    },
    
    get_hasChildren: function Framework_Component_AbstractComponent$get_hasChildren() {
        if (!this._children) {
            return false;
        }
        return this._children.length > 0;
    },
    
    get_children: function Framework_Component_AbstractComponent$get_children() {
        return this._children;
    },
    
    getChildByID: function Framework_Component_AbstractComponent$getChildByID(childID) {
        for (var count = 0; count < this._children.length; count++) {
            if (this._children[count].get_childID() === childID) {
                return this._children[count];
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.ComponentFactory

Framework.Component.ComponentFactory = function Framework_Component_ComponentFactory() {
}
Framework.Component.ComponentFactory.create = function Framework_Component_ComponentFactory$create(componentName, componentConfigurationItem, placeholderId, environment) {
    Framework.Component.ComponentFactory._log.debug(String.format('Processing {0}', componentName));
    var component = eval('new ' + componentConfigurationItem.className + '();');
    component.set_childID(componentConfigurationItem.childID);
    if (placeholderId) {
        var componentDocumentElement = document.createElement('div');
        componentDocumentElement.className = (!componentConfigurationItem.parameters['css-class']) ? 'component' : componentConfigurationItem.parameters['css-class'].toString();
        componentDocumentElement.id = componentName;
        document.getElementById(placeholderId).appendChild(componentDocumentElement);
    }
    component.get_componentLifeCycleManager().initialize(environment, String.format('autoWiring.getComponents()[\'{0}\']', componentName), componentName, componentConfigurationItem.parameters);
    return component;
}
Framework.Component.ComponentFactory.createDynamicComponent = function Framework_Component_ComponentFactory$createDynamicComponent(componentType, parent, placeholder, customComponentParameters, startComponent) {
    Framework.Component.ComponentFactory._dynamicComponentCounter++;
    var componentName = String.format('dynamic_{0}{1}', componentType.get_name(), Framework.Component.ComponentFactory._dynamicComponentCounter);
    Framework.Component.ComponentFactory._log.debug(String.format('CreateDynamicComponent {0}', componentName));
    if (!placeholder) {
        throw new Error('Error: ComponentFactory, CreateDynamicComponent => placeholder equals null');
    }
    var configuration = Framework.AbstractEnvironment.getInstance().dynamicComponentsConfiguration[componentType.get_fullName()];
    if (!configuration) {
        throw new Error(String.format('Error: ComponentFactory, CreateDynamicComponent => Configuration of component \'{0}\' doesn\'t exist', componentType.get_fullName()));
    }
    var componentParameters = Framework.Component.ComponentFactory._mergeComponentParameters(configuration.parameters, customComponentParameters);
    var component = new componentType();
    component.get_componentLifeCycleManager().set_parent(parent.get_componentLifeCycleManager());
    var componentDocumentElement = document.createElement('div');
    componentDocumentElement.className = (!componentParameters['css-class']) ? 'component' : componentParameters['css-class'].toString();
    componentDocumentElement.id = componentName;
    placeholder.appendChild(componentDocumentElement);
    component.get_componentLifeCycleManager().initialize(Framework.AbstractEnvironment.getInstance(), componentName, componentName, componentParameters);
    Framework.Component.ComponentFactory._bindServices(componentName, component, configuration.requiredServices, configuration.connectEvents, Framework.AbstractEnvironment.getInstance().services);
    if (startComponent) {
        component.get_componentLifeCycleManager().start();
    }
    return component;
}
Framework.Component.ComponentFactory.initialize = function Framework_Component_ComponentFactory$initialize(componentName, component, componentConfigurationItem, services, components) {
    Framework.Component.ComponentFactory._bindServices(componentName, component, componentConfigurationItem.requiredServices, componentConfigurationItem.connectEvents, services);
    Framework.Component.ComponentFactory._addChildComponents(component, componentConfigurationItem, components);
}
Framework.Component.ComponentFactory.deleteComponent = function Framework_Component_ComponentFactory$deleteComponent(component) {
    Framework.Component.ComponentFactory._log.debug(String.format('Deleting component {0}', component.get_componentInstanceName()));
    var configuration = Framework.AbstractEnvironment.getInstance().dynamicComponentsConfiguration[Type.getInstanceType(component).get_fullName()];
    if (!configuration) {
        throw new Error(String.format('Error: ComponentFactory, DeleteComponent => Configuration of component \'{0}\' doesn\'t exist', typeof(component)));
    }
    Framework.Component.ComponentFactory._unbindServices(component, configuration);
    Framework.AbstractEnvironment.getInstance().get_componentUpdateScheduler().removeScheduledTasksByLifeCycleManager(component.get_componentLifeCycleManager());
    component.get_componentLifeCycleManager().set_parent(null);
    component.dispose();
    component.killAllDynamicChildComponents();
    Framework.HtmlUtils.detachBehavioursAndClearHtmlElementContent(component.get_domElementId());
}
Framework.Component.ComponentFactory._unbindServices = function Framework_Component_ComponentFactory$_unbindServices(component, configuration) {
    Framework.Component.ComponentFactory._log.debug(String.format('Disconnecting services from {0}', component.get_componentInstanceName()));
    var $dict1 = configuration.connectEvents;
    for (var $key2 in $dict1) {
        var connectedEventsDictionaryEntry = { key: $key2, value: $dict1[$key2] };
        var service = Framework.AbstractEnvironment.getInstance().services[connectedEventsDictionaryEntry.key];
        var events = connectedEventsDictionaryEntry.value;
        if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
        }
        else {
            var $enum3 = events.getEnumerator();
            while ($enum3.moveNext()) {
                var eventName = $enum3.get_current();
                service['unregister' + eventName + 'Listener'](component);
            }
        }
    }
}
Framework.Component.ComponentFactory._bindServices = function Framework_Component_ComponentFactory$_bindServices(componentName, component, requiredServices, connectEvents, services) {
    Framework.Component.ComponentFactory._log.debug(String.format('Connecting services to {0}', componentName));
    var $enum1 = requiredServices.getEnumerator();
    while ($enum1.moveNext()) {
        var requiredServiceName = $enum1.get_current();
        Framework.Component.ComponentFactory._log.debug(String.format('Injecting [{0}] into [{1}]', requiredServiceName, componentName));
        var requiredService = services[requiredServiceName];
        component['set' + Type.getInstanceType(requiredService).get_name()](requiredService);
    }
    Framework.Component.ComponentFactory._log.debug(String.format('Subscribing to events {0}', componentName));
    var $dict2 = connectEvents;
    for (var $key3 in $dict2) {
        var connectedEventsDictionaryEntry = { key: $key3, value: $dict2[$key3] };
        var service = services[connectedEventsDictionaryEntry.key];
        var events = connectedEventsDictionaryEntry.value;
        if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
        }
        else {
            var $enum4 = events.getEnumerator();
            while ($enum4.moveNext()) {
                var eventName = $enum4.get_current();
                service['register' + eventName + 'Listener'](component);
            }
        }
    }
}
Framework.Component.ComponentFactory._addChildComponents = function Framework_Component_ComponentFactory$_addChildComponents(component, componentConfigurationItem, components) {
    var $enum1 = componentConfigurationItem.childComponents.getEnumerator();
    while ($enum1.moveNext()) {
        var childComponentName = $enum1.get_current();
        var childComponent = (components[childComponentName]);
        component.addChild(childComponent);
    }
}
Framework.Component.ComponentFactory._mergeComponentParameters = function Framework_Component_ComponentFactory$_mergeComponentParameters(parameters, newParameters) {
    if (!newParameters) {
        return parameters;
    }
    if (!parameters) {
        return newParameters;
    }
    var $dict1 = newParameters;
    for (var $key2 in $dict1) {
        var newParameter = { key: $key2, value: $dict1[$key2] };
        parameters[newParameter.key] = newParameter.value;
    }
    return parameters;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.AbstractXsltBasedComponent

Framework.Component.AbstractXsltBasedComponent = function Framework_Component_AbstractXsltBasedComponent() {
    Framework.Component.AbstractXsltBasedComponent.constructBase(this);
}
Framework.Component.AbstractXsltBasedComponent.prototype = {
    _parameters: null,
    
    get_componentElement: function Framework_Component_AbstractXsltBasedComponent$get_componentElement() {
        return this._environment.getDomElement(this._domElementId);
    },
    
    init: function Framework_Component_AbstractXsltBasedComponent$init(environment, componentInstanceName, domElementId, parameters) {
    },
    
    start: function Framework_Component_AbstractXsltBasedComponent$start() {
    },
    
    preTransformation: function Framework_Component_AbstractXsltBasedComponent$preTransformation(eventArgs) {
    },
    
    xmlContentReceived: function Framework_Component_AbstractXsltBasedComponent$xmlContentReceived(eventArgs) {
    },
    
    preRender: function Framework_Component_AbstractXsltBasedComponent$preRender(eventArgs) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(eventArgs.get_inMemoryContent(), this);
    },
    
    renderComplete: function Framework_Component_AbstractXsltBasedComponent$renderComplete(eventArgs) {
    },
    
    childrenUpdateComplete: function Framework_Component_AbstractXsltBasedComponent$childrenUpdateComplete(eventArgs) {
    },
    
    createComponentLifeCycleManager: function Framework_Component_AbstractXsltBasedComponent$createComponentLifeCycleManager() {
        return new Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager(this);
    },
    
    _preTransformationAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preTransformationAbstractXsltBasedComponent(eventArgs) {
        if (!this.get_isComponentVisible()) {
            eventArgs.set_cancelUpdate(true);
            this.hide();
        }
        else {
            this.show();
        }
    },
    
    _preInitializeAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preInitializeAbstractXsltBasedComponent(environment, componentInstanceName, domElementId, parameters) {
        Framework.Component.AbstractXsltBasedComponent.callBase(this, 'init', [ environment, componentInstanceName, domElementId, parameters ]);
        this._parameters = new Framework.CommonComponentParameters(parameters);
    },
    
    _preStartAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preStartAbstractXsltBasedComponent() {
        this._log.debug('Start');
    },
    
    removeAllScheduledUpdates: function Framework_Component_AbstractXsltBasedComponent$removeAllScheduledUpdates() {
        this._environment.get_componentUpdateScheduler().removeScheduledTasksByDomain(this._domElementId);
    },
    
    getXsltParameters: function Framework_Component_AbstractXsltBasedComponent$getXsltParameters(contextObject) {
        var result = {};
        result['component-instance-name'] = this._componentInstanceName;
        result['component-dom-element-id'] = this._domElementId;
        result['culture-name'] = CultureInfo.Current.name;
        return result;
    },
    
    _getDefaultUpdateContextObject$1: function Framework_Component_AbstractXsltBasedComponent$_getDefaultUpdateContextObject$1(inilialization) {
        var region = this._environment.getRegion();
        var language = this._environment.getLanguage();
        var xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(this.get_componentElement(), null, region, language, inilialization);
        xsltBasedUpdateContextObject.contentUrl = this._parameters.get_contentUrl();
        xsltBasedUpdateContextObject.xsltUrl = this._parameters.get_xsltUrl();
        xsltBasedUpdateContextObject.xsltParameters = this.getXsltParameters(null);
        return xsltBasedUpdateContextObject;
    },
    
    _initialUpdate: function Framework_Component_AbstractXsltBasedComponent$_initialUpdate() {
        var xsltBasedUpdateContextObject = this._getDefaultUpdateContextObject$1(true);
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.get_componentLifeCycleManager());
        updateTask.execute();
    },
    
    update: function Framework_Component_AbstractXsltBasedComponent$update(domElement, contentID, xsltUrl, xsltParameters, customEventArgs) {
        var xsltBasedUpdateContextObject;
        if (!domElement) {
            xsltBasedUpdateContextObject = this._getDefaultUpdateContextObject$1(false);
        }
        else {
            xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(domElement, null, this._environment.getRegion(), this._environment.getLanguage(), false);
            xsltBasedUpdateContextObject.contentUrl = contentID;
            xsltBasedUpdateContextObject.xsltUrl = xsltUrl;
            xsltBasedUpdateContextObject.xsltParameters = xsltParameters;
        }
        xsltBasedUpdateContextObject.customEventArgs = customEventArgs;
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.get_componentLifeCycleManager());
        updateTask.execute();
    },
    
    periodicalUpdate: function Framework_Component_AbstractXsltBasedComponent$periodicalUpdate(domElementId, contentID, xsltUrl, xsltParameters, domain, autoRefreshPeriod, customEventArgs) {
        var xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(null, domElementId, this._environment.getRegion(), this._environment.getLanguage(), false);
        xsltBasedUpdateContextObject.contentUrl = contentID;
        xsltBasedUpdateContextObject.xsltUrl = xsltUrl;
        xsltBasedUpdateContextObject.xsltParameters = xsltParameters;
        xsltBasedUpdateContextObject.customEventArgs = customEventArgs;
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.get_componentLifeCycleManager());
        this._environment.get_componentUpdateScheduler().scheduleNewTask(updateTask, domain, autoRefreshPeriod);
    }
}


Type.createNamespace('Framework.Component.LifeCycleManagement.EventArgs');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_ChildrenUpdateCompleteEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs.prototype = {
    _customEventArgs: null,
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_ChildrenUpdateCompleteEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_ChildrenUpdateCompleteEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_ChildUpdateCompleteEventArgs(updateSucceeded, childComponentInstanceName) {
    this.updateSucceeded = updateSucceeded;
    this.childComponentInstanceName = childComponentInstanceName;
}
Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs.prototype = {
    updateSucceeded: false,
    childComponentInstanceName: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs

Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs.prototype = {
    _contentXmlDocument: null,
    _customEventArgs: null,
    _cancelUpdate: false,
    
    get_contentXmlDocument: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_contentXmlDocument() {
        return this._contentXmlDocument;
    },
    set_contentXmlDocument: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_contentXmlDocument(value) {
        this._contentXmlDocument = value;
        return value;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    },
    
    get_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_cancelUpdate() {
        return this._cancelUpdate;
    },
    set_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_cancelUpdate(value) {
        this._cancelUpdate = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs

Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_CustomEventArgs() {
    this.parametersDictionary = {};
}
Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs.prototype = {
    parametersDictionary: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs.prototype = {
    _customEventArgs: null,
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    },
    
    _domElement: null,
    
    get_domElement: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$get_domElement() {
        return this._domElement;
    },
    set_domElement: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$set_domElement(value) {
        this._domElement = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs

Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs(inMemoryContent) {
    this._inMemoryContent = inMemoryContent;
}
Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs.prototype = {
    _inMemoryContent: null,
    _customEventArgs: null,
    
    get_inMemoryContent: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$get_inMemoryContent() {
        return this._inMemoryContent;
    },
    set_inMemoryContent: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$set_inMemoryContent(value) {
        this._inMemoryContent = value;
        return value;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs

Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs(contextObject, isPeriodicalUpdate) {
    this._isPeriodicalUpdate = isPeriodicalUpdate;
    this._contextObject = contextObject;
}
Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs.prototype = {
    _cancelUpdate: false,
    _isPeriodicalUpdate: false,
    _showIndicator: true,
    _contextObject: null,
    
    get_contextObject: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_contextObject() {
        return this._contextObject;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_customEventArgs() {
        return this._contextObject.customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_customEventArgs(value) {
        this._contextObject.customEventArgs = value;
        return value;
    },
    
    get_isPeriodicalUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_isPeriodicalUpdate() {
        return this._isPeriodicalUpdate;
    },
    
    get_isInitialRender: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_isInitialRender() {
        return this._contextObject.initialRender;
    },
    
    get_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_cancelUpdate() {
        return this._cancelUpdate;
    },
    set_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_cancelUpdate(value) {
        this._cancelUpdate = value;
        return value;
    },
    
    get_showIndicator: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_showIndicator() {
        return this._showIndicator;
    },
    set_showIndicator: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_showIndicator(value) {
        this._showIndicator = value;
        return value;
    }
}


Type.createNamespace('Framework.Component.LifeCycleManagement');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.ComponentUpdateState

Framework.Component.LifeCycleManagement.ComponentUpdateState = function() { };
Framework.Component.LifeCycleManagement.ComponentUpdateState.prototype = {
    notUpdating: 0, 
    updating: 1, 
    waitingForChildren: 2
}
Framework.Component.LifeCycleManagement.ComponentUpdateState.createEnum('Framework.Component.LifeCycleManagement.ComponentUpdateState', false);


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.ComponentLifeCycleManager

Framework.Component.LifeCycleManagement.ComponentLifeCycleManager = function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager(component) {
    this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.notUpdating;
    this._component = component;
}
Framework.Component.LifeCycleManagement.ComponentLifeCycleManager.prototype = {
    _component: null,
    _environment: null,
    _childrenUpdateQueue: null,
    _parent: null,
    
    get_parent: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$get_parent() {
        return this._parent;
    },
    set_parent: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$set_parent(value) {
        this._parent = value;
        return value;
    },
    
    initialize: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$initialize(environment, componentInstanceName, domElementId, parameters) {
        this._environment = environment;
        this._component.init(environment, componentInstanceName, domElementId, parameters);
    },
    
    start: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$start() {
        this.componentUpdateStarted();
        this._component.start();
        this.componentUpdateFinished();
    },
    
    childComponentUpdateStarted: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$childComponentUpdateStarted(componentLifecycleManager) {
        if (this._componentUpdateStatus === Framework.Component.LifeCycleManagement.ComponentUpdateState.updating) {
            this._childrenUpdateQueue.add(componentLifecycleManager);
        }
    },
    
    childComponentUpdatedFinished: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$childComponentUpdatedFinished(componentLifecycleManager, updateSecceeded) {
        this._component.childComponentUpdateComplete(new Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs(updateSecceeded, componentLifecycleManager._component.get_componentInstanceName()));
        if (this._componentUpdateStatus === Framework.Component.LifeCycleManagement.ComponentUpdateState.updating || this._componentUpdateStatus === Framework.Component.LifeCycleManagement.ComponentUpdateState.waitingForChildren) {
            this._childrenUpdateQueue.remove(componentLifecycleManager);
            if (!this._childrenUpdateQueue.length) {
                this.fireChildrenUpdateCompleteEventAndLetParentKnow();
            }
        }
    },
    
    componentUpdateStarted: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$componentUpdateStarted() {
        this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.updating;
        this._childrenUpdateQueue = [];
        if (this._parent) {
            this._parent.childComponentUpdateStarted(this);
        }
    },
    
    componentUpdateFinished: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$componentUpdateFinished() {
        if (!this._childrenUpdateQueue.length) {
            this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.notUpdating;
            this.fireChildrenUpdateCompleteEventAndLetParentKnow();
        }
        else {
            this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.waitingForChildren;
        }
    },
    
    componentUpdateCanceled: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$componentUpdateCanceled() {
        this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.notUpdating;
        this._childrenUpdateQueue = [];
        if (this._parent) {
            this._parent.childComponentUpdatedFinished(this, false);
        }
    },
    
    fireChildrenUpdateCompleteEventAndLetParentKnow: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$fireChildrenUpdateCompleteEventAndLetParentKnow() {
        var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs();
        this._component.childrenUpdateComplete(eventArgs);
        if (this._parent) {
            this._parent.childComponentUpdatedFinished(this, true);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager

Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager = function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager(component) {
    Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.constructBase(this, [ component ]);
    this._childrenUpdateQueue = [];
}
Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.prototype = {
    _customEventArgs$1: null,
    
    get__component$1: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$get__component$1() {
        return this._component;
    },
    
    initialize: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$initialize(environment, componentInstanceName, domElementId, parameters) {
        this._environment = environment;
        this.get__component$1()._preInitializeAbstractXsltBasedComponent(environment, componentInstanceName, domElementId, parameters);
        this.get__component$1().init(environment, componentInstanceName, domElementId, parameters);
    },
    
    start: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$start() {
        this.componentUpdateStarted();
        this.get__component$1()._preStartAbstractXsltBasedComponent();
        this.get__component$1().start();
        this.get__component$1().removeAllScheduledUpdates();
        this.get__component$1()._initialUpdate();
    },
    
    preTransformation: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$preTransformation(eventArgs) {
        (this._component)._preTransformationAbstractXsltBasedComponent(eventArgs);
        (this._component).preTransformation(eventArgs);
    },
    
    xmlContentReceived: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$xmlContentReceived(eventArgs) {
        (this._component).xmlContentReceived(eventArgs);
    },
    
    preRender: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$preRender(eventArgs) {
        (this._component).preRender(eventArgs);
    },
    
    renderComplete: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$renderComplete(eventArgs) {
        (this._component).renderComplete(eventArgs);
        this._customEventArgs$1 = eventArgs.get_customEventArgs();
        this.componentUpdateFinished();
    },
    
    fireChildrenUpdateCompleteEventAndLetParentKnow: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$fireChildrenUpdateCompleteEventAndLetParentKnow() {
        var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs();
        eventArgs.set_customEventArgs(this._customEventArgs$1);
        this.get__component$1().childrenUpdateComplete(eventArgs);
        if (this._parent) {
            this._parent.childComponentUpdatedFinished(this, true);
        }
    }
}


Type.createNamespace('Framework.Component.Updating');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.XsltBasedUpdateContextObject

Framework.Component.Updating.XsltBasedUpdateContextObject = function Framework_Component_Updating_XsltBasedUpdateContextObject(domElement, domElementId, region, language, initialRender) {
    this.domElement = domElement;
    this.domElementId = domElementId;
    this.region = region;
    this.language = language;
    this.initialRender = initialRender;
}
Framework.Component.Updating.XsltBasedUpdateContextObject.prototype = {
    domElement: null,
    domElementId: null,
    region: null,
    language: null,
    initialRender: false,
    contentUrl: null,
    xsltUrl: null,
    xsltParameters: null,
    domain: null,
    customXmlDocument: null,
    customEventArgs: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.ComponentUpdateScheduler

Framework.Component.Updating.ComponentUpdateScheduler = function Framework_Component_Updating_ComponentUpdateScheduler() {
    this._transformAndUpdateQueue = [];
}
Framework.Component.Updating.ComponentUpdateScheduler.prototype = {
    
    scheduleNewTask: function Framework_Component_Updating_ComponentUpdateScheduler$scheduleNewTask(task, domain, autoRefreshPeriod) {
        if (!task) {
            return;
        }
        task.set_isPeriodical(true);
        task.set_autoRefreshPeriod(autoRefreshPeriod);
        task.set_domain(domain);
        task.execute();
        this._transformAndUpdateQueue.add(task);
    },
    
    removeScheduledTasksByDomain: function Framework_Component_Updating_ComponentUpdateScheduler$removeScheduledTasksByDomain(domain) {
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RemoveScheduledTasksByDomain domain=[{0}]', domain));
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (domain !== (this._transformAndUpdateQueue[i]).get_domain()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    removeScheduledTasksByLifeCycleManager: function Framework_Component_Updating_ComponentUpdateScheduler$removeScheduledTasksByLifeCycleManager(manager) {
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug('RemoveScheduledTasksByLifeCycleManager');
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (manager !== (this._transformAndUpdateQueue[i]).get_lifeCycleManager()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    runSchedulingRuntime: function Framework_Component_Updating_ComponentUpdateScheduler$runSchedulingRuntime(startIndex) {
        var queue = this._transformAndUpdateQueue;
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RunSchedulingRuntime woke up!, StartIndex=[{0}]', startIndex));
        if (queue && queue.length > 0) {
            startIndex = Math.min(startIndex, queue.length - 1);
            var i = startIndex;
            do {
                var currentTask = queue[i];
                Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RunSchedulingRuntime processing task i=[{0}] LastExecuted=[{1}] AutoRefreshPeriod=[{2}]', i, currentTask.get_lastExecuted(), currentTask.get_autoRefreshPeriod()));
                i = (i + 1) % queue.length;
                if (currentTask.get_lastExecuted().getTime() + currentTask.get_autoRefreshPeriod() < Date.get_now().getTime()) {
                    currentTask.execute();
                    break;
                }
            } while (i !== startIndex);
            startIndex = i;
        }
        window.setTimeout(Delegate.create(this, function() {
            this.runSchedulingRuntime(startIndex);
        }), Framework.Parameters.transformAndUpdateSchedulerPeriod);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.UpdateXsltBasedComponentTask

Framework.Component.Updating.UpdateXsltBasedComponentTask = function Framework_Component_Updating_UpdateXsltBasedComponentTask(contextObject, lifeCycleManager) {
    this._contextObject = contextObject;
    this._contextObject.contentUrl = this._createRealUrl(this._contextObject.contentUrl);
    this._lifeCycleManager = lifeCycleManager;
    this._lastExecuted = Date.get_now();
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._onContentRequestsComplete = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onContentRequestsComplete(contentUrl) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('OnContentRequestsComplete contentUrl=[{0}]', contentUrl));
    if (Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, contentUrl) && Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[contentUrl])) > 0) {
        var xmlCallBacksForUrl = Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[contentUrl];
        var $dict1 = xmlCallBacksForUrl;
        for (var $key2 in $dict1) {
            var callback = { key: $key2, value: $dict1[$key2] };
            Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('OnContentRequestsComplete callback key=[{0}] contentUrl=[{1}]', callback.key, contentUrl));
            (callback.value).invoke();
        }
    }
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._getStamp = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_getStamp(domElementId) {
    return Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap[domElementId];
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._setStamp = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_setStamp(domElementId, value) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap[domElementId] = value;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask.storeXsltDocument = function Framework_Component_Updating_UpdateXsltBasedComponentTask$storeXsltDocument(url, document) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[url] = document;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask.prototype = {
    _isPeriodical: false,
    _autoRefreshPeriod: null,
    _domain: null,
    _startingCounterValue: 0,
    _lastExecuted: null,
    _contentRequest: null,
    _xsltRequest: null,
    _contentXmlDocument: null,
    _xsltXmlDocument: null,
    _sdcToken: null,
    _contextObject: null,
    _lifeCycleManager: null,
    
    get_lifeCycleManager: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_lifeCycleManager() {
        return this._lifeCycleManager;
    },
    
    get_isPeriodical: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_isPeriodical() {
        return this._isPeriodical;
    },
    set_isPeriodical: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_isPeriodical(value) {
        this._isPeriodical = value;
        return value;
    },
    
    get_autoRefreshPeriod: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_autoRefreshPeriod() {
        return this._autoRefreshPeriod;
    },
    set_autoRefreshPeriod: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_autoRefreshPeriod(value) {
        this._autoRefreshPeriod = value;
        return value;
    },
    
    get_domain: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domain() {
        return this._domain;
    },
    set_domain: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_domain(value) {
        this._domain = value;
        return value;
    },
    
    get_lastExecuted: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_lastExecuted() {
        return this._lastExecuted;
    },
    
    get__contentUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get__contentUrl() {
        return this._createRealUrl(this._contextObject.contentUrl);
    },
    
    get_domElementId: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domElementId() {
        return (this.get_isPeriodical()) ? this._contextObject.domElementId : this._contextObject.domElement.id;
    },
    
    get_domElement: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domElement() {
        return (this.get_isPeriodical()) ? document.getElementById(this._contextObject.domElementId) : this._contextObject.domElement;
    },
    
    get__xsltUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get__xsltUrl() {
        return this._contextObject.xsltUrl;
    },
    
    execute: function Framework_Component_Updating_UpdateXsltBasedComponentTask$execute() {
        if (!this._contextObject.initialRender) {
            this._lifeCycleManager.componentUpdateStarted();
        }
        var preTransformationEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs(this._contextObject, this.get_isPeriodical());
        this._lifeCycleManager.preTransformation(preTransformationEventArgs);
        if (preTransformationEventArgs.get_cancelUpdate()) {
            this._lifeCycleManager.componentUpdateCanceled();
            return;
        }
        this._sdcToken = Framework.SDC.SDCManager.sdcManagerInstance().startRenderLog(this.get_domElementId());
        if (preTransformationEventArgs.get_showIndicator()) {
            Framework.Component.Updating.HtmlUpdater.updateDomElementDirect(document.getElementById(this.get_domElementId()), '<img src=\'/indicator.gif\' />');
        }
        this._lastExecuted = Date.get_now();
        this._contentXmlDocument = this._contextObject.customXmlDocument;
        this._update(true);
    },
    
    _update: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_update(appendTimestampToContentUrl) {
        this._startingCounterValue = Framework.Component.Updating.UpdateXsltBasedComponentTask._requestCounter++;
        Framework.Component.Updating.UpdateXsltBasedComponentTask._setStamp(this.get_domElementId(), this._startingCounterValue);
        if (!this._contentXmlDocument) {
            if (this.get__contentUrl()) {
                var doCall = false;
                if (!Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, this.get__contentUrl()) || !Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()]))) {
                    doCall = true;
                    Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()] = {};
                }
                (Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()])[this.get_domElementId()] = Delegate.create(this, this._onContentRequestComplete);
                if (doCall) {
                    this._contentXmlDocument = null;
                    this._contentRequest = new Framework.XMLHttpRequestDecorator();
                    this._contentRequest.onreadystatechange = Delegate.create(this, function() {
                        Framework.Component.Updating.UpdateXsltBasedComponentTask._onContentRequestsComplete(this.get__contentUrl());
                    });
                    this._contentRequest.open('GET', this.get__contentUrl(), true);
                    this._contentRequest.send(null);
                    Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()] = this._contentRequest;
                }
            }
            else {
                this._contentXmlDocument = Framework.XMLUtils.get_emptyContentDocument();
            }
        }
        if (!Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument, this.get__xsltUrl())) {
            this._xsltRequest = new Framework.XMLHttpRequestDecorator();
            this._xsltRequest.onreadystatechange = Delegate.create(this, this._onXsltRequestComplete);
            this._xsltRequest.open('GET', this.get__xsltUrl(), true);
            this._xsltRequest.send(null);
        }
        else {
            this._xsltXmlDocument = Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[this.get__xsltUrl()];
        }
        this._tryTransform();
    },
    
    _onContentRequestComplete: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onContentRequestComplete() {
        if (!this._contentRequest) {
            this._contentRequest = Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()];
        }
        if (this._contentRequest) {
            if (this._contentRequest.readyState === 4) {
                if (this._contentRequest.status === 200 || this._contentRequest.status === 304) {
                    var xmlContentReceivedEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs();
                    xmlContentReceivedEventArgs.set_contentXmlDocument(this._contentRequest.responseXML);
                    xmlContentReceivedEventArgs.set_customEventArgs(this._contextObject.customEventArgs);
                    this._lifeCycleManager.xmlContentReceived(xmlContentReceivedEventArgs);
                    if (xmlContentReceivedEventArgs.get_cancelUpdate()) {
                        this._contentXmlDocument = null;
                        this._lifeCycleManager.componentUpdateCanceled();
                        return;
                    }
                    this._contentXmlDocument = xmlContentReceivedEventArgs.get_contentXmlDocument();
                    this._tryTransform();
                }
                else {
                    Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                    Framework.Component.Updating.HtmlUpdater.updateDomElement(this.get_domElement(), '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
                }
                if (Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, this.get__contentUrl()) && Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()])) > 0) {
                    var xmlCallBack = Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()];
                    if (Object.keyExists(xmlCallBack, this.get_domElementId())) {
                        delete xmlCallBack[this.get_domElementId()];
                    }
                    if (!Object.getKeyCount(xmlCallBack)) {
                        delete Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()];
                        this._contentRequest.onreadystatechange = null;
                    }
                }
            }
        }
    },
    
    _onXsltRequestComplete: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onXsltRequestComplete() {
        if (this._xsltRequest.readyState === 4) {
            if (this._xsltRequest.status === 200 || this._xsltRequest.status === 304) {
                this._xsltXmlDocument = this._xsltRequest.responseXML;
                Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[this.get__xsltUrl()] = this._xsltXmlDocument;
                this._tryTransform();
                if (this._xsltRequest) {
                    this._xsltRequest.onreadystatechange = null;
                }
            }
            else {
                Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                Framework.Component.Updating.HtmlUpdater.updateDomElement(this.get_domElement(), '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
            }
        }
    },
    
    _tryTransform: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_tryTransform() {
        Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('TryTransform domElementId=[{0}] contentUrl=[{1}]', this.get_domElementId(), this.get__contentUrl()));
        if (this._contentXmlDocument && this._xsltXmlDocument && this._startingCounterValue === Framework.Component.Updating.UpdateXsltBasedComponentTask._getStamp(this.get_domElementId())) {
            Framework.XMLUtils.transformAndUpdate(this._contentXmlDocument, this._xsltXmlDocument, this._contextObject.xsltParameters, this.get_domElementId(), this.get_domElement(), Delegate.create(this, this._decoratePreRenderEventCallback));
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla) {
                var css = '#' + this.get_domElementId() + ' .escapedHtml';
                var elements = Framework.DocumentFinder.getElementsBySelector(css);
                if (elements) {
                    for (var i = 0; i < elements.length; i++) {
                        elements[i].innerHTML = elements[i].innerText;
                    }
                }
            }
            Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.noException);
            window.setTimeout(Delegate.create(this, function() {
                var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs();
                eventArgs.set_domElement(this.get_domElement());
                eventArgs.set_customEventArgs(this._contextObject.customEventArgs);
                this._lifeCycleManager.renderComplete(eventArgs);
            }), 0);
        }
    },
    
    _decoratePreRenderEventCallback: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_decoratePreRenderEventCallback(inMemoryContent) {
        var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs(inMemoryContent);
        eventArgs.set_customEventArgs(this._contextObject.customEventArgs);
        this._lifeCycleManager.preRender(eventArgs);
    },
    
    _createRealUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_createRealUrl(url) {
        return ((!url) ? null : url.replace('${region}', this._contextObject.region).replace('${language}', this._contextObject.language));
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.HtmlUpdater

Framework.Component.Updating.HtmlUpdater = function Framework_Component_Updating_HtmlUpdater() {
}
Framework.Component.Updating.HtmlUpdater.updateDomElement = function Framework_Component_Updating_HtmlUpdater$updateDomElement(domElement, htmlContent) {
    if (domElement) {
        Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.Component.Updating.HtmlUpdater._log.debug('Environment.UpdateDomElement Error - Dom element is null');
    }
}
Framework.Component.Updating.HtmlUpdater.updateDomElementById = function Framework_Component_Updating_HtmlUpdater$updateDomElementById(domElementId, htmlContent) {
    Framework.Component.Updating.HtmlUpdater.updateDomElement(document.getElementById(domElementId), htmlContent);
}
Framework.Component.Updating.HtmlUpdater.updateDomElementDirect = function Framework_Component_Updating_HtmlUpdater$updateDomElementDirect(domElement, htmlContent) {
    Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect(domElement, htmlContent);
}
Framework.Component.Updating.HtmlUpdater.safeUpdateDomElement = function Framework_Component_Updating_HtmlUpdater$safeUpdateDomElement(domElementId, htmlContent) {
    var domElement = document.getElementById(domElementId);
    if (domElement) {
        Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.Component.Updating.HtmlUpdater._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
    }
}
Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect = function Framework_Component_Updating_HtmlUpdater$safeUpdateDomElementDirect(domElement, htmlContent) {
    if (!domElement) {
        return;
    }
    if (domElement.innerHTML === htmlContent) {
        Framework.Component.Updating.HtmlUpdater._log.debug(domElement.id + '.InnerHTML unchanged - not updated');
    }
    else {
        Framework.DocumentEvents.purgeEventsBeforeUpdate(domElement, true, 0);
        domElement.innerHTML = htmlContent;
    }
}


Type.createNamespace('Framework.SDC');

////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCManager

Framework.SDC.SDCManager = function Framework_SDC_SDCManager() {
    this._isConfigLoaded = false;
    this._initialiseStatisticAndConfigDictionaries();
    this._isCurrentlySendingBatch = false;
    this._failedBatchSendAttempts = 0;
}
Framework.SDC.SDCManager.initializeSDCManager = function Framework_SDC_SDCManager$initializeSDCManager() {
    Framework.SDC.SDCManager._singletonSDCManager = new Framework.SDC.SDCManager();
    Framework.SDC.SDCManager._singletonSDCManager.fetchConfiguration();
}
Framework.SDC.SDCManager.sdcManagerInstance = function Framework_SDC_SDCManager$sdcManagerInstance() {
    return Framework.SDC.SDCManager._singletonSDCManager;
}
Framework.SDC.SDCManager.prototype = {
    _isSDCLoggingOn: true,
    _intervalID: 0,
    _statistics: null,
    _config: null,
    _isConfigLoaded: false,
    _isCurrentlySendingBatch: false,
    _failedBatchSendAttempts: 0,
    
    fetchConfiguration: function Framework_SDC_SDCManager$fetchConfiguration() {
        if (!this._isSDCLoggingOn) {
            return;
        }
        if (this._getTotalConfigCount() > 0) {
            return;
        }
        Framework.AbstractEnvironment.getInstance().invokeAsync(Framework.SDC.SDCManager._serviceName, 'GetConfiguration', {}, Delegate.create(this, function(result) {
            var config = result;
            if (config) {
                var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
                while ($enum1.moveNext()) {
                    var statType = $enum1.get_current();
                    if (Object.keyExists(config, statType.toString())) {
                        this._loadConfiguration(statType, false, config[statType.toString()]);
                    }
                    if (Object.keyExists(config, String.format('{0}{1}', Framework.SDC.SDCManager._priorityKeyPrefix, statType))) {
                        this._loadConfiguration(statType, true, config[String.format('{0}{1}', Framework.SDC.SDCManager._priorityKeyPrefix, statType)]);
                    }
                }
            }
            if (!this._getTotalConfigCount()) {
                this._isSDCLoggingOn = false;
            }
            this._isConfigLoaded = true;
            this._filterCurrentStatistics();
            if (this._getTotalConfigCount() > 0) {
                this._intervalID = window.setInterval(Delegate.create(this, this._prepareBatch), Framework.SDC.SDCManager._timeoutInterval);
            }
        }), Delegate.create(this, function(exception) {
            this._isSDCLoggingOn = false;
            this._filterCurrentStatistics();
        }));
    },
    
    startRenderLog: function Framework_SDC_SDCManager$startRenderLog(domElementID) {
        if (!this._isSDCLoggingOn) {
            return Framework.SDC.SDCManager.notLoggedInternalToken;
        }
        var componentInstance = new RegExp('^([A-Za-z]*)[0-9]*').exec(domElementID);
        if (componentInstance.length === 2 && Object.keyExists(Framework.AbstractEnvironment.getInstance().components, componentInstance[0])) {
            var componentInstanceID = componentInstance[0];
            var javascriptClass = Type.getInstanceType((Framework.AbstractEnvironment.getInstance().components[componentInstanceID])).get_fullName().toString();
            var internalToken = this._generateInternalToken(Framework.SDC.SDCStatisticType.render, javascriptClass);
            if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken) {
                var statistic = new Framework.SDC.SDCStatistic(internalToken, Framework.SDC.SDCStatisticType.render, javascriptClass, this._getIDFWSDCObject(Framework.SDC.SDCStatisticType.render, javascriptClass));
                statistic.beginStatisticLogging();
                this._getStatisticDictionary(Framework.SDC.SDCStatisticType.render)[internalToken] = statistic;
                return internalToken;
            }
        }
        return Framework.SDC.SDCManager.notLoggedInternalToken;
    },
    
    endRenderLog: function Framework_SDC_SDCManager$endRenderLog(internalToken, exception) {
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken && Object.keyExists(this._getStatisticDictionary(Framework.SDC.SDCStatisticType.render), internalToken)) {
            this._getStatistic(Framework.SDC.SDCStatisticType.render, internalToken).endStatisticLogging('', exception);
            this._checkForPriorityLogging(this._getStatistic(Framework.SDC.SDCStatisticType.render, internalToken));
        }
    },
    
    startRPCLog: function Framework_SDC_SDCManager$startRPCLog(serviceName, methodName) {
        if (!this._isSDCLoggingOn) {
            return Framework.SDC.SDCManager.notLoggedInternalToken;
        }
        var statisticName = String.format('{0}.{1}', serviceName, methodName);
        var internalToken = this._generateInternalToken(Framework.SDC.SDCStatisticType.RPC, statisticName);
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken) {
            var statistic = new Framework.SDC.SDCStatistic(internalToken, Framework.SDC.SDCStatisticType.RPC, statisticName, this._getIDFWSDCObject(Framework.SDC.SDCStatisticType.RPC, statisticName));
            statistic.beginStatisticLogging();
            this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC)[internalToken] = statistic;
        }
        return internalToken;
    },
    
    endRPCLog: function Framework_SDC_SDCManager$endRPCLog(internalToken, serverToken, exception) {
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken && Object.keyExists(this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC), internalToken)) {
            this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken).endStatisticLogging(serverToken, exception);
            this._checkForPriorityLogging(this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken));
        }
    },
    
    endMultiplexRPCLog: function Framework_SDC_SDCManager$endMultiplexRPCLog(internalToken, serverToken, exception, endTime) {
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken && Object.keyExists(this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC), internalToken)) {
            this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken).endStatisticLogging(serverToken, exception, endTime);
            this._checkForPriorityLogging(this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken));
        }
    },
    
    abortRPCLog: function Framework_SDC_SDCManager$abortRPCLog(internalToken) {
        delete this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC)[internalToken];
    },
    
    _prepareBatch: function Framework_SDC_SDCManager$_prepareBatch() {
        this._clearOldStatistics();
        if (!this._isCurrentlySendingBatch && this._getTotalStatisticCount() >= Framework.SDC.SDCManager._minimumBatchSize) {
            var batchStatistics = [];
            var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
            while ($enum1.moveNext()) {
                var statType = $enum1.get_current();
                var $dict2 = this._getStatisticDictionary(statType);
                for (var $key3 in $dict2) {
                    var entry = { key: $key3, value: $dict2[$key3] };
                    if (batchStatistics.length >= Framework.SDC.SDCManager._maximumBatchSize) {
                        break;
                    }
                    var stat = entry.value;
                    if (stat.isFinishedLogging()) {
                        batchStatistics.add(stat);
                    }
                }
            }
            if (batchStatistics.length >= Framework.SDC.SDCManager._minimumBatchSize) {
                this._sendBatch(batchStatistics, false);
            }
            else {
                this._isCurrentlySendingBatch = false;
            }
        }
    },
    
    _sendBatch: function Framework_SDC_SDCManager$_sendBatch(batchStatistics, isPrioritySend) {
        var batch = [];
        var $enum1 = batchStatistics.getEnumerator();
        while ($enum1.moveNext()) {
            var stat = $enum1.get_current();
            batch.add(stat.serializeStatistic());
        }
        this._isCurrentlySendingBatch = true;
        Framework.AbstractEnvironment.getInstance().invokeAsync(Framework.SDC.SDCManager._serviceName, 'LogStatisticBatch', { stats: batch }, Delegate.create(this, function(result) {
            for (var i = 0; i < batchStatistics.length; i++) {
                var stat = batchStatistics[i];
                delete this._getStatisticDictionary(stat.get_type())[stat.get_internalToken()];
            }
            this._failedBatchSendAttempts = 0;
            if (!isPrioritySend) {
                this._isCurrentlySendingBatch = false;
            }
        }), Delegate.create(this, function(exception) {
            this._failedBatchSendAttempts++;
            if (!isPrioritySend) {
                this._isCurrentlySendingBatch = false;
            }
            if (this._failedBatchSendAttempts > Framework.SDC.SDCManager._maxFailedBatchSendAttempts) {
                this._isSDCLoggingOn = false;
                this._filterCurrentStatistics();
            }
        }));
    },
    
    _checkIfNeedsLogging: function Framework_SDC_SDCManager$_checkIfNeedsLogging(statisticType, statisticName) {
        if (!this._isSDCLoggingOn) {
            return false;
        }
        else if (!this._isConfigLoaded) {
            return true;
        }
        else {
            return Object.keyExists(this._getConfigDictionary(statisticType), statisticName);
        }
    },
    
    _generateInternalToken: function Framework_SDC_SDCManager$_generateInternalToken(statisticType, statisticName) {
        if (this._checkIfNeedsLogging(statisticType, statisticName)) {
            var statistics = this._getStatisticDictionary(statisticType);
            var internalToken = String.format('{0}.{1}', Date.get_now().getTime(), statisticName.substr(0, 6));
            var safteyCounter = 0;
            while (Object.keyExists(statistics, internalToken) && safteyCounter < 15) {
                internalToken += Math.truncate(Math.floor(Math.random() * 1001));
                safteyCounter++;
            }
            if (!Object.keyExists(statistics, internalToken)) {
                return internalToken;
            }
        }
        return Framework.SDC.SDCManager.notLoggedInternalToken;
    },
    
    _filterCurrentStatistics: function Framework_SDC_SDCManager$_filterCurrentStatistics() {
        if (!this._isSDCLoggingOn) {
            this._initialiseStatisticAndConfigDictionaries();
        }
        else {
            var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
            while ($enum1.moveNext()) {
                var statType = $enum1.get_current();
                var removeInternalTokens = [];
                var $dict2 = this._getStatisticDictionary(statType);
                for (var $key3 in $dict2) {
                    var entry = { key: $key3, value: $dict2[$key3] };
                    var stat = entry.value;
                    stat.setIDFWSDCObject(this._getIDFWSDCObject(statType, stat.get_statisticName()));
                    if (!this._checkIfNeedsLogging(statType, stat.get_statisticName())) {
                        removeInternalTokens.add(entry.key);
                    }
                }
                var $enum4 = removeInternalTokens.getEnumerator();
                while ($enum4.moveNext()) {
                    var internalToken = $enum4.get_current();
                    delete this._getStatisticDictionary(statType)[internalToken];
                }
            }
        }
    },
    
    _loadConfiguration: function Framework_SDC_SDCManager$_loadConfiguration(statisticType, isPriority, configs) {
        var config = this._getConfigDictionary(statisticType);
        var $dict1 = configs;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            config[entry.key] = new Framework.SDC.SDCConfig(isPriority, entry.value);
        }
    },
    
    _checkForPriorityLogging: function Framework_SDC_SDCManager$_checkForPriorityLogging(stat) {
        if (Object.keyExists(this._getConfigDictionary(stat.get_type()), stat.get_statisticName()) && (this._getConfigDictionary(stat.get_type())[stat.get_statisticName()]).isPriority) {
            this._sendBatch([ stat ], true);
        }
    },
    
    _getConfigDictionary: function Framework_SDC_SDCManager$_getConfigDictionary(statisticType) {
        if (Object.keyExists(this._config, statisticType.toString())) {
            return this._config[statisticType.toString()];
        }
        else {
            return {};
        }
    },
    
    _getIDFWSDCObject: function Framework_SDC_SDCManager$_getIDFWSDCObject(statisticType, statisticName) {
        var config = this._getConfigDictionary(statisticType);
        if (Object.keyExists(config, statisticName)) {
            return (config[statisticName]).idfwsdcObject;
        }
        else {
            return -1;
        }
    },
    
    _getStatisticDictionary: function Framework_SDC_SDCManager$_getStatisticDictionary(statisticType) {
        if (Object.keyExists(this._statistics, statisticType.toString())) {
            return this._statistics[statisticType.toString()];
        }
        else {
            return {};
        }
    },
    
    _getStatistic: function Framework_SDC_SDCManager$_getStatistic(statisticType, internalToken) {
        return this._getStatisticDictionary(statisticType)[internalToken];
    },
    
    _getTotalStatisticCount: function Framework_SDC_SDCManager$_getTotalStatisticCount() {
        var total = 0;
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            total += Object.getKeyCount(this._getStatisticDictionary(statType));
        }
        return total;
    },
    
    _getTotalConfigCount: function Framework_SDC_SDCManager$_getTotalConfigCount() {
        var total = 0;
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            total += Object.getKeyCount(this._getConfigDictionary(statType));
        }
        return total;
    },
    
    _initialiseStatisticAndConfigDictionaries: function Framework_SDC_SDCManager$_initialiseStatisticAndConfigDictionaries() {
        this._statistics = {};
        this._config = {};
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            this._statistics[statType.toString()] = {};
            this._config[statType.toString()] = {};
        }
    },
    
    _clearOldStatistics: function Framework_SDC_SDCManager$_clearOldStatistics() {
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            var removalList = [];
            var $dict2 = this._getStatisticDictionary(statType);
            for (var $key3 in $dict2) {
                var entry = { key: $key3, value: $dict2[$key3] };
                var stat = entry.value;
                if (!stat.isFinishedLogging() && (Date.get_now().getTime() - stat.get_startTime()) > 500000) {
                    removalList.add(stat.get_internalToken());
                }
            }
            var $enum4 = removalList.getEnumerator();
            while ($enum4.moveNext()) {
                var token = $enum4.get_current();
                delete this._getStatisticDictionary(statType)[token];
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCStatistic

Framework.SDC.SDCStatistic = function Framework_SDC_SDCStatistic(internalToken, statisticType, statisticName, idFWSDCObject) {
    this._internalToken = internalToken;
    this._type = statisticType;
    this._name = statisticName;
    this._idFWSDCObject = idFWSDCObject;
    this._startTime = 0;
    this._endTime = 0;
    this._duration = 0;
    this._exceptionType = Framework.SDC.SDCExceptionType.noException;
}
Framework.SDC.SDCStatistic.prototype = {
    _type: 0,
    
    get_type: function Framework_SDC_SDCStatistic$get_type() {
        return this._type;
    },
    
    _idFWSDCObject: null,
    _trackingToken: null,
    _exceptionType: 0,
    _duration: 0,
    _name: null,
    
    get_statisticName: function Framework_SDC_SDCStatistic$get_statisticName() {
        return this._name;
    },
    
    _internalToken: null,
    
    get_internalToken: function Framework_SDC_SDCStatistic$get_internalToken() {
        return this._internalToken;
    },
    
    _startTime: 0,
    
    get_startTime: function Framework_SDC_SDCStatistic$get_startTime() {
        return this._startTime;
    },
    
    _endTime: 0,
    
    beginStatisticLogging: function Framework_SDC_SDCStatistic$beginStatisticLogging() {
        this._startTime = Date.get_now().getTime();
    },
    
    endStatisticLogging: function Framework_SDC_SDCStatistic$endStatisticLogging(trackingToken, exception, endTime) {
        this._endTime = (endTime) ? endTime : Date.get_now().getTime();
        this._duration = this._endTime - this._startTime;
        this._trackingToken = trackingToken;
        this._exceptionType = exception;
    },
    
    isFinishedLogging: function Framework_SDC_SDCStatistic$isFinishedLogging() {
        return this._duration > 0;
    },
    
    serializeStatistic: function Framework_SDC_SDCStatistic$serializeStatistic() {
        return { Type: this._type, IDFWSDCObject: this._idFWSDCObject, TrackingToken: this._trackingToken, ExceptionType: this._exceptionType, Duration: this._duration };
    },
    
    setIDFWSDCObject: function Framework_SDC_SDCStatistic$setIDFWSDCObject(idFWSDCObject) {
        this._idFWSDCObject = idFWSDCObject;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCStatisticType

Framework.SDC.SDCStatisticType = function Framework_SDC_SDCStatisticType() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCExceptionType

Framework.SDC.SDCExceptionType = function Framework_SDC_SDCExceptionType() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCConfig

Framework.SDC.SDCConfig = function Framework_SDC_SDCConfig(isPriority, IDFWSDCObject) {
    this.isPriority = isPriority;
    this.idfwsdcObject = IDFWSDCObject;
}
Framework.SDC.SDCConfig.prototype = {
    isPriority: false,
    idfwsdcObject: null
}


Type.createNamespace('Framework.Util');

////////////////////////////////////////////////////////////////////////////////
// Framework.Util.TypeInfoProvider

Framework.Util.TypeInfoProvider = function Framework_Util_TypeInfoProvider() {
}
Framework.Util.TypeInfoProvider.isDerivedFrom = function Framework_Util_TypeInfoProvider$isDerivedFrom(source, type) {
    while ((source !== type) && (source)) {
        source = source.get_baseType();
    }
    return (source === type);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Util.StringConverter

Framework.Util.StringConverter = function Framework_Util_StringConverter() {
}
Framework.Util.StringConverter.getAsInt32 = function Framework_Util_StringConverter$getAsInt32(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsNumber = function Framework_Util_StringConverter$getAsNumber(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsString = function Framework_Util_StringConverter$getAsString(data) {
    return data;
}
Framework.Util.StringConverter.getAsStringArray = function Framework_Util_StringConverter$getAsStringArray(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsNumberArray = function Framework_Util_StringConverter$getAsNumberArray(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsBoolean = function Framework_Util_StringConverter$getAsBoolean(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsEscapedString = function Framework_Util_StringConverter$getAsEscapedString(data) {
    return (isNullOrUndefined(data)) ? data : escape(data);
}
Framework.Util.StringConverter.getAsDictionary = function Framework_Util_StringConverter$getAsDictionary(data) {
    return eval('(' + data + ')');
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Util.DOMElementAttributeProvider

Framework.Util.DOMElementAttributeProvider = function Framework_Util_DOMElementAttributeProvider(domElement) {
    this._domElement = domElement;
}
Framework.Util.DOMElementAttributeProvider.prototype = {
    _domElement: null,
    
    getAttributeAsNumber: function Framework_Util_DOMElementAttributeProvider$getAttributeAsNumber(attributeName) {
        return Framework.Util.StringConverter.getAsNumber(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsString: function Framework_Util_DOMElementAttributeProvider$getAttributeAsString(attributeName) {
        return this._domElement.getAttribute(attributeName);
    },
    
    getAttributeAsStringArray: function Framework_Util_DOMElementAttributeProvider$getAttributeAsStringArray(attributeName) {
        return Framework.Util.StringConverter.getAsStringArray(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsNumberArray: function Framework_Util_DOMElementAttributeProvider$getAttributeAsNumberArray(attributeName) {
        return Framework.Util.StringConverter.getAsNumberArray(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsBoolean: function Framework_Util_DOMElementAttributeProvider$getAttributeAsBoolean(attributeName) {
        return Framework.Util.StringConverter.getAsBoolean(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsEscapedString: function Framework_Util_DOMElementAttributeProvider$getAttributeAsEscapedString(attributeName) {
        return Framework.Util.StringConverter.getAsEscapedString(this._domElement.getAttribute(attributeName));
    },
    
    dispose: function Framework_Util_DOMElementAttributeProvider$dispose() {
        this._domElement = null;
    }
}


Type.createNamespace('Framework.Validation');

////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ValidationResult

Framework.Validation.ValidationResult = function Framework_Validation_ValidationResult() {
}
Framework.Validation.ValidationResult.prototype = {
    success: false,
    exception: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ValidationManager

Framework.Validation.ValidationManager = function Framework_Validation_ValidationManager(PageEnvironment) {
    this._environment = PageEnvironment;
    this.headerItemTemplate = '{0}<br />';
    this._validators = {};
}
Framework.Validation.ValidationManager.prototype = {
    _validators: null,
    _environment: null,
    headerElementId: null,
    headerItemTemplate: null,
    
    clearValidators: function Framework_Validation_ValidationManager$clearValidators() {
        Object.clearKeys(this._validators);
    },
    
    registerInputForValidation: function Framework_Validation_ValidationManager$registerInputForValidation(validator) {
        if (Object.keyExists(this._validators, validator.inputElementId.trim())) {
            var arrvalidators = this._validators[validator.inputElementId.trim()];
            this._validators[validator.inputElementId] = arrvalidators.concat(validator);
        }
        else {
            var arrvalidators = [ validator ];
            this._validators[validator.inputElementId.trim()] = arrvalidators;
        }
    },
    
    unregisterInputForValidation: function Framework_Validation_ValidationManager$unregisterInputForValidation(inputElementId) {
        if (Object.keyExists(this._validators, inputElementId.trim())) {
            delete this._validators[inputElementId.trim()];
        }
    },
    
    registerMandatoryValidator: function Framework_Validation_ValidationManager$registerMandatoryValidator(InputElementId, LabelElementId, ErrorElementId) {
        var _mandatoryValidator = new Framework.Validation.MandatoryValidator();
        _mandatoryValidator.inputElementId = InputElementId;
        _mandatoryValidator.errorElementId = ErrorElementId;
        _mandatoryValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_mandatoryValidator);
    },
    
    registerNumericValidator: function Framework_Validation_ValidationManager$registerNumericValidator(InputElementId, LabelElementId, ErrorElementId, Length) {
        var _numericValidator = new Framework.Validation.NumericValidator(Length);
        _numericValidator.inputElementId = InputElementId;
        _numericValidator.errorElementId = ErrorElementId;
        _numericValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_numericValidator);
    },
    
    registerNumericRangeValidator: function Framework_Validation_ValidationManager$registerNumericRangeValidator(InputElementId, LabelElementId, ErrorElementId, MinValue, MaxValue) {
        var _numericRngValidator = new Framework.Validation.NumericRangeValidator(MinValue, MaxValue);
        _numericRngValidator.inputElementId = InputElementId;
        _numericRngValidator.errorElementId = ErrorElementId;
        _numericRngValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_numericRngValidator);
    },
    
    registerDateValidator: function Framework_Validation_ValidationManager$registerDateValidator(InputElementId, LabelElementId, ErrorElementId, MinDate, MaxDate) {
        var _dateValidator = new Framework.Validation.DateValidator();
        _dateValidator.inputElementId = InputElementId;
        _dateValidator.errorElementId = ErrorElementId;
        _dateValidator.labelElementId = LabelElementId;
        _dateValidator.minDate = MinDate;
        _dateValidator.maxDate = MaxDate;
        this.registerInputForValidation(_dateValidator);
    },
    
    registerThreePartDateValidator: function Framework_Validation_ValidationManager$registerThreePartDateValidator(DayInputElementId, MonthInputElementId, YearInputelementId, LabelElementId, ErrorElementId, MinDate, MaxDate) {
        var _dateValidator = new Framework.Validation.ThreePartDateValidator();
        _dateValidator.dayInputId = DayInputElementId;
        _dateValidator.monthInputId = MonthInputElementId;
        _dateValidator.yearInputId = YearInputelementId;
        _dateValidator.errorElementId = ErrorElementId;
        _dateValidator.labelElementId = LabelElementId;
        _dateValidator.minDate = MinDate;
        _dateValidator.maxDate = MaxDate;
        this.registerInputForValidation(_dateValidator);
    },
    
    registerMinimumDateOfBirthValidator: function Framework_Validation_ValidationManager$registerMinimumDateOfBirthValidator(DayInputElementId, MonthInputElementId, YearInputelementId, LabelElementId, ErrorElementId, MinDate) {
        var _dateMinDOBValidator = new Framework.Validation.MinimumDateOfBirthValidator();
        _dateMinDOBValidator.dayInputId = DayInputElementId;
        _dateMinDOBValidator.monthInputId = MonthInputElementId;
        _dateMinDOBValidator.yearInputId = YearInputelementId;
        _dateMinDOBValidator.errorElementId = ErrorElementId;
        _dateMinDOBValidator.labelElementId = LabelElementId;
        _dateMinDOBValidator.minDate = MinDate;
        this.registerInputForValidation(_dateMinDOBValidator);
    },
    
    registerMinimumAgeValidator: function Framework_Validation_ValidationManager$registerMinimumAgeValidator(DayInputElementId, MonthInputElementId, YearInputelementId, LabelElementId, ErrorElementId, MinimumAge) {
        var _minAgeValidator = new Framework.Validation.ThreePartMinimumAgeValidator(MinimumAge);
        _minAgeValidator.dayInputId = DayInputElementId;
        _minAgeValidator.monthInputId = MonthInputElementId;
        _minAgeValidator.yearInputId = YearInputelementId;
        _minAgeValidator.errorElementId = ErrorElementId;
        _minAgeValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_minAgeValidator);
    },
    
    registerRegexValidator: function Framework_Validation_ValidationManager$registerRegexValidator(InputElementId, LabelElementId, ErrorElementId, Expression) {
        var _regexValidator = new Framework.Validation.RegexValidator(Expression);
        _regexValidator.inputElementId = InputElementId;
        _regexValidator.errorElementId = ErrorElementId;
        _regexValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_regexValidator);
    },
    
    registerEmailAddressValidator: function Framework_Validation_ValidationManager$registerEmailAddressValidator(InputElementId, LabelElementId, ErrorElementId) {
        var _emailVal = new Framework.Validation.EmailAddressValidator();
        _emailVal.inputElementId = InputElementId;
        _emailVal.errorElementId = ErrorElementId;
        _emailVal.labelElementId = LabelElementId;
        this.registerInputForValidation(_emailVal);
    },
    
    registerSameUsernamePasswordValidator: function Framework_Validation_ValidationManager$registerSameUsernamePasswordValidator(InputElementId, LabelElementId, ErrorElementId, InputUsernameID, InputPasswordID) {
        var _usernamePasswordValidator = new Framework.Validation.SameUsernamePasswordValidator();
        _usernamePasswordValidator.inputElementId = InputElementId;
        _usernamePasswordValidator.errorElementId = ErrorElementId;
        _usernamePasswordValidator.labelElementId = LabelElementId;
        _usernamePasswordValidator.inputUsernameID = InputUsernameID;
        _usernamePasswordValidator.inputPasswordID = InputPasswordID;
        this.registerInputForValidation(_usernamePasswordValidator);
    },
    
    registerValidateRUT: function Framework_Validation_ValidationManager$registerValidateRUT(InputElementId, LabelElementId, ErrorElementId) {
        var _validateRUT = new Framework.Validation.ValidateRUT();
        _validateRUT.inputElementId = InputElementId;
        _validateRUT.errorElementId = ErrorElementId;
        _validateRUT.labelElementId = LabelElementId;
        _validateRUT.inputUsernameId = InputElementId;
        this.registerInputForValidation(_validateRUT);
    },
    
    validateSingleInput: function Framework_Validation_ValidationManager$validateSingleInput(input) {
        var arrvalidators = this._validators[input.id.trim()];
        var $enum1 = arrvalidators.getEnumerator();
        while ($enum1.moveNext()) {
            var validator = $enum1.get_current();
            validator._environment = this._environment;
            if (!validator.validate()) {
                return false;
            }
        }
        return true;
    },
    
    validateAll: function Framework_Validation_ValidationManager$validateAll() {
        if (!String.isNullOrEmpty(this.headerElementId)) {
            this._environment.getDomElement(this.headerElementId).innerHTML = '';
        }
        var isValid = true;
        var $dict1 = this._validators;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var arrvalidators = entry.value;
            var $enum3 = arrvalidators.getEnumerator();
            while ($enum3.moveNext()) {
                var validator = $enum3.get_current();
                validator._environment = this._environment;
                if (!validator.validate()) {
                    if (!String.isNullOrEmpty(this.headerElementId)) {
                        this._environment.getDomElement(this.headerElementId).innerHTML = String.format(this.headerItemTemplate, validator.errorMessage);
                    }
                    isValid = false;
                    break;
                }
            }
        }
        if (!isValid) {
            window.scrollTo(0, 0);
        }
        return isValid;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.AbstractValidator

Framework.Validation.AbstractValidator = function Framework_Validation_AbstractValidator() {
    this._applyInputParentElementErrorClassOnError = true;
    this._inputParentElementErrorClass = 'ParentElementError';
    this._errorLabelClass = 'LabelError';
}
Framework.Validation.AbstractValidator.prototype = {
    _applyInputParentElementErrorClassOnError: false,
    _inputParentElementErrorClass: null,
    _errorLabelClass: null,
    _onSuccessCallBack: null,
    _onFailureCallBack: null,
    inputElementId: null,
    labelElementId: null,
    errorElementId: null,
    errorMessage: null,
    _environment: null,
    
    get_errorLabelClass: function Framework_Validation_AbstractValidator$get_errorLabelClass() {
        return this._errorLabelClass;
    },
    set_errorLabelClass: function Framework_Validation_AbstractValidator$set_errorLabelClass(value) {
        this._errorLabelClass = value;
        return value;
    },
    
    get_inputParentElementErrorClass: function Framework_Validation_AbstractValidator$get_inputParentElementErrorClass() {
        return this._inputParentElementErrorClass;
    },
    set_inputParentElementErrorClass: function Framework_Validation_AbstractValidator$set_inputParentElementErrorClass(value) {
        this._inputParentElementErrorClass = value;
        return value;
    },
    
    get_applyInputParentElementErrorClassOnError: function Framework_Validation_AbstractValidator$get_applyInputParentElementErrorClassOnError() {
        return this._applyInputParentElementErrorClassOnError;
    },
    set_applyInputParentElementErrorClassOnError: function Framework_Validation_AbstractValidator$set_applyInputParentElementErrorClassOnError(value) {
        this._applyInputParentElementErrorClassOnError = value;
        return value;
    },
    
    add_onSuccessEvent: function Framework_Validation_AbstractValidator$add_onSuccessEvent(value) {
        this._onSuccessCallBack = Delegate.combine(this._onSuccessCallBack, value);
    },
    remove_onSuccessEvent: function Framework_Validation_AbstractValidator$remove_onSuccessEvent(value) {
        this._onSuccessCallBack = Delegate.remove(this._onSuccessCallBack, value);
    },
    
    add_onFailureEvent: function Framework_Validation_AbstractValidator$add_onFailureEvent(value) {
        this._onFailureCallBack = Delegate.combine(this._onFailureCallBack, value);
    },
    remove_onFailureEvent: function Framework_Validation_AbstractValidator$remove_onFailureEvent(value) {
        this._onFailureCallBack = Delegate.remove(this._onFailureCallBack, value);
    },
    
    doesElementExist: function Framework_Validation_AbstractValidator$doesElementExist() {
        return (this._environment.getDomElement(this.inputElementId));
    },
    
    inputValue: function Framework_Validation_AbstractValidator$inputValue() {
        if (!this.doesElementExist()) {
            return null;
        }
        return (this._environment.getDomElement(this.inputElementId)).value;
    },
    
    validate: function Framework_Validation_AbstractValidator$validate() {
        return true;
    },
    
    getErrorText: function Framework_Validation_AbstractValidator$getErrorText() {
        if (!this._environment.getDomElement(this.errorElementId)) {
            return '';
        }
        if (!String.isNullOrEmpty(this.errorElementId)) {
            return this._environment.getDomElement(this.errorElementId).innerHTML;
        }
        return '';
    },
    
    createExceptionFromTextInErrorElement: function Framework_Validation_AbstractValidator$createExceptionFromTextInErrorElement() {
        return Framework.ExceptionUtil.createException(Framework.Validation.AbstractValidator.VALIDATIONEXCEPTIONTYPE, this.getErrorText());
    },
    
    onFailure: function Framework_Validation_AbstractValidator$onFailure(exception) {
        if (!String.isNullOrEmpty(this.errorElementId)) {
            if (this._environment.getDomElement(this.errorElementId)) {
                this._environment.safelySetCssClass(this.errorElementId, this._errorLabelClass);
            }
        }
        if (!String.isNullOrEmpty(this.labelElementId)) {
            if (this._environment.getDomElement(this.labelElementId)) {
                this._environment.safelySetCssClass(this.labelElementId, this._errorLabelClass);
            }
        }
        if (this._applyInputParentElementErrorClassOnError) {
            if (this._environment.getDomElement(this.inputElementId)) {
                this._environment.safelySetCssClassOnElement(this._environment.getDomElement(this.inputElementId).parentNode, this._inputParentElementErrorClass);
            }
        }
        this.errorMessage = exception.message;
        if (this._onFailureCallBack) {
            this._onFailureCallBack.invoke(exception);
        }
    },
    
    onSuccess: function Framework_Validation_AbstractValidator$onSuccess() {
        if (!String.isNullOrEmpty(this.errorElementId)) {
            if (this._environment.getDomElement(this.errorElementId)) {
                this._environment.safelyRemoveCssClass(this.errorElementId, this._errorLabelClass);
            }
        }
        if (!String.isNullOrEmpty(this.labelElementId)) {
            if (this._environment.getDomElement(this.labelElementId)) {
                this._environment.safelyRemoveCssClass(this.labelElementId, this._errorLabelClass);
            }
        }
        if (this._applyInputParentElementErrorClassOnError) {
            if (this._environment.getDomElement(this.inputElementId)) {
                this._environment.safelyRemoveCssClassOnElement(this._environment.getDomElement(this.inputElementId).parentNode, this._inputParentElementErrorClass);
            }
        }
        if (this._onSuccessCallBack) {
            this._onSuccessCallBack.invoke();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.MandatoryValidator

Framework.Validation.MandatoryValidator = function Framework_Validation_MandatoryValidator() {
    Framework.Validation.MandatoryValidator.constructBase(this);
}
Framework.Validation.MandatoryValidator.prototype = {
    
    validate: function Framework_Validation_MandatoryValidator$validate() {
        if (this.doesElementExist()) {
            var val = '';
            if ((document.getElementById(this.inputElementId.trim())).type === 'checkbox') {
                if ((document.getElementById(this.inputElementId.trim())).checked) {
                    val = 'checked';
                }
                else {
                    val = String.Empty;
                }
            }
            else {
                val = (document.getElementById(this.inputElementId.trim())).value.trim();
            }
            if (!String.isNullOrEmpty(val)) {
                Framework.Validation.MandatoryValidator.callBase(this, 'onSuccess');
                return true;
            }
            else {
                var ex = new Error(this.getErrorText());
                Framework.Validation.MandatoryValidator.callBase(this, 'onFailure', [ ex ]);
                return false;
            }
        }
        else {
            Framework.Validation.MandatoryValidator.callBase(this, 'onSuccess');
            return true;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.DateValidator

Framework.Validation.DateValidator = function Framework_Validation_DateValidator() {
    Framework.Validation.DateValidator.constructBase(this);
}
Framework.Validation.DateValidator.prototype = {
    minDate: null,
    maxDate: null,
    
    validate: function Framework_Validation_DateValidator$validate() {
        var inputVal = this.inputValue();
        if (this.doesElementExist()) {
            var val = Date.get_today();
            try {
                val = Date.parse(inputVal);
            }
            catch ($e1) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.minDate && val.getTime() < this.minDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.maxDate && val.getTime() > this.maxDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ThreePartDateValidator

Framework.Validation.ThreePartDateValidator = function Framework_Validation_ThreePartDateValidator() {
    this.val = Date.get_now();
    Framework.Validation.ThreePartDateValidator.constructBase(this);
    this.inputElementId = Framework.Validation.AbstractValidator.UNASSIGNEDINPUTID;
}
Framework.Validation.ThreePartDateValidator.prototype = {
    dayInputId: null,
    monthInputId: null,
    yearInputId: null,
    day: null,
    month: null,
    year: null,
    minDate: null,
    maxDate: null,
    
    isValidDate: function Framework_Validation_ThreePartDateValidator$isValidDate(dayin, monthin, yearin) {
        if (dayin <= 0 || yearin <= 0) {
            return false;
        }
        var validDate = true;
        var month30 = [ 4, 6, 9, 11 ];
        var month31 = [ 1, 3, 5, 7, 8, 10, 12 ];
        var oMonth;
        oMonth = monthin - 2;
        if (!oMonth & dayin > 28 + this._leapYear$1(yearin)) {
            validDate = false;
        }
        for (var i = 0; i < month30.length; i++) {
            oMonth = monthin - month30[i];
            if (!oMonth && dayin > 30) {
                validDate = false;
            }
        }
        for (var y = 0; y < month31.length; y++) {
            oMonth = monthin - month31[y];
            if (!oMonth && dayin > 31) {
                validDate = false;
            }
        }
        return validDate;
    },
    
    _leapYear$1: function Framework_Validation_ThreePartDateValidator$_leapYear$1(year) {
        var Result = 0;
        if (!(year % 4)) {
            if (!(year % 100)) {
                Result = (!(year % 400)) ? 1 : 0;
            }
            else {
                Result = 1;
            }
        }
        return Result;
    },
    
    validate: function Framework_Validation_ThreePartDateValidator$validate() {
        this.inputElementId = this.dayInputId;
        this.day = this.inputValue();
        this.inputElementId = this.monthInputId;
        this.month = this.inputValue();
        this.inputElementId = this.yearInputId;
        this.year = this.inputValue();
        if (!(String.isNullOrEmpty(this.day) || String.isNullOrEmpty(this.month) || String.isNullOrEmpty(this.year))) {
            if (!this.isValidDate(Number.parse(this.day), Number.parse(this.month), Number.parse(this.year))) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            this.val = new Date(Number.parse(this.year), Number.parse(this.month) - 1, Number.parse(this.day));
            if (!this.val) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.minDate && this.val.getTime() < this.minDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.maxDate && this.val.getTime() > this.maxDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.MinimumDateOfBirthValidator

Framework.Validation.MinimumDateOfBirthValidator = function Framework_Validation_MinimumDateOfBirthValidator() {
    this.val = Date.get_now();
    Framework.Validation.MinimumDateOfBirthValidator.constructBase(this);
    this.inputElementId = Framework.Validation.AbstractValidator.UNASSIGNEDINPUTID;
}
Framework.Validation.MinimumDateOfBirthValidator.prototype = {
    dayInputId: null,
    monthInputId: null,
    yearInputId: null,
    day: null,
    month: null,
    year: null,
    minDate: null,
    
    validate: function Framework_Validation_MinimumDateOfBirthValidator$validate() {
        this.inputElementId = this.dayInputId;
        this.day = this.inputValue();
        this.inputElementId = this.monthInputId;
        this.month = this.inputValue();
        this.inputElementId = this.yearInputId;
        this.year = this.inputValue();
        if (!(String.isNullOrEmpty(this.day) || String.isNullOrEmpty(this.month) || String.isNullOrEmpty(this.year))) {
            this.val = new Date(Number.parse(this.year), Number.parse(this.month), Number.parse(this.day));
            if (!this.val) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.minDate) {
                var heavyMinDOB = (this.minDate.getFullYear() * 1000) + (this.minDate.getMonth() * 100) + (this.minDate.getDate() * 10);
                var heavyDOB = (this.val.getFullYear() * 1000) + (this.val.getMonth() * 100) + (this.val.getDate() * 10);
                var isValidDate = (heavyMinDOB > heavyDOB) ? false : true;
                if (!isValidDate) {
                    this.onFailure(this.createExceptionFromTextInErrorElement());
                    return false;
                }
            }
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ThreePartMinimumAgeValidator

Framework.Validation.ThreePartMinimumAgeValidator = function Framework_Validation_ThreePartMinimumAgeValidator(MinAge) {
    Framework.Validation.ThreePartMinimumAgeValidator.constructBase(this);
    this.minimumAge = MinAge;
}
Framework.Validation.ThreePartMinimumAgeValidator.prototype = {
    
    validate: function Framework_Validation_ThreePartMinimumAgeValidator$validate() {
        this.inputElementId = this.dayInputId;
        this.day = this.inputValue();
        this.inputElementId = this.monthInputId;
        this.month = this.inputValue();
        this.inputElementId = this.yearInputId;
        this.year = this.inputValue();
        if (!(String.isNullOrEmpty(this.day) || String.isNullOrEmpty(this.month) || String.isNullOrEmpty(this.year))) {
            if (this.isValidDate(Number.parse(this.day), Number.parse(this.month), Number.parse(this.year))) {
                this.val = new Date(Number.parse(this.year), Number.parse(this.month) - 1, Number.parse(this.day));
                var temp = Date.get_now();
                var limit = new Date(temp.getFullYear() - this.minimumAge, temp.getMonth(), temp.getDate());
                if (limit.getTime() < this.val.getTime()) {
                    this.onFailure(this.createExceptionFromTextInErrorElement());
                    return false;
                }
            }
        }
        this.onSuccess();
        return true;
    },
    
    minimumAge: 0
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.NumericValidator

Framework.Validation.NumericValidator = function Framework_Validation_NumericValidator(length) {
    Framework.Validation.NumericValidator.constructBase(this);
    this.maxLength = 0;
    if (length > 0) {
        this.maxLength = length;
    }
}
Framework.Validation.NumericValidator.prototype = {
    
    validate: function Framework_Validation_NumericValidator$validate() {
        var val = this.inputValue();
        if (this.doesElementExist()) {
            var work = '*';
            if (this.maxLength > 0) {
                work = '{1,' + this.maxLength.toString() + '}';
            }
            var regex = new RegExp('^\\d' + work + '$');
            if (!regex.test(val)) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    },
    
    maxLength: 0
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.StandardPasswordValidator

Framework.Validation.StandardPasswordValidator = function Framework_Validation_StandardPasswordValidator(minLength, maxLength) {
    Framework.Validation.StandardPasswordValidator.constructBase(this, [ '' ]);
    this.minimumLength = (minLength > 0) ? minLength : 4;
    this.maximumLength = (maxLength > 0) ? maxLength : 30;
    this._passwordRegex$2 = String.format('^[a-zA-Z0-9_@\\\\.]\\w{{0},{1}}$', this.minimumLength - 1, this.maximumLength - 1);
}
Framework.Validation.StandardPasswordValidator.prototype = {
    
    validate: function Framework_Validation_StandardPasswordValidator$validate() {
        this.regexString = this._passwordRegex$2;
        return Framework.Validation.StandardPasswordValidator.callBase(this, 'validate');
    },
    
    minimumLength: 0,
    maximumLength: 0,
    _passwordRegex$2: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.StandardUsernameValidator

Framework.Validation.StandardUsernameValidator = function Framework_Validation_StandardUsernameValidator(minLength, maxLength) {
    Framework.Validation.StandardUsernameValidator.constructBase(this, [ minLength, maxLength ]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.EmailAddressValidator

Framework.Validation.EmailAddressValidator = function Framework_Validation_EmailAddressValidator() {
    Framework.Validation.EmailAddressValidator.constructBase(this, [ '^[0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z_+])*@([0-9a-zA-Z][-\\w]*[0-9a-zA-Z]\\.)+[a-zA-Z]{2,9}$' ]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.MatchedInputsValidator

Framework.Validation.MatchedInputsValidator = function Framework_Validation_MatchedInputsValidator(Input1Id, Input2Id, Input2Label1Id, ErrorElementId) {
    Framework.Validation.MatchedInputsValidator.constructBase(this);
    this.inputElementId = Input2Id;
    this.errorElementId = ErrorElementId;
    this.labelElementId = Input2Label1Id;
    this.inputElement1Id = Input1Id;
    this.inputElement2Id = Input2Id;
}
Framework.Validation.MatchedInputsValidator.prototype = {
    inputElement1Id: null,
    inputElement2Id: null,
    
    validate: function Framework_Validation_MatchedInputsValidator$validate() {
        this.inputElementId = this.inputElement1Id;
        if (!this.doesElementExist()) {
            this.onSuccess();
            return true;
        }
        var input1 = this.inputValue();
        this.inputElementId = this.inputElement2Id;
        if (!this.doesElementExist()) {
            this.onSuccess();
            return true;
        }
        var input2 = this.inputValue();
        if (input1 !== input2) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        else {
            this.onSuccess();
            return true;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.NumericRangeValidator

Framework.Validation.NumericRangeValidator = function Framework_Validation_NumericRangeValidator(minvalue, maxvalue) {
    Framework.Validation.NumericRangeValidator.constructBase(this);
    this.minValue = minvalue;
    this.maxValue = maxvalue;
}
Framework.Validation.NumericRangeValidator.prototype = {
    minValue: 0,
    maxValue: 0,
    
    validate: function Framework_Validation_NumericRangeValidator$validate() {
        var success = false;
        var val = this.inputValue();
        if (this.doesElementExist()) {
            var regex = new RegExp('^\\d*$');
            if (regex.test(val)) {
                success = true;
            }
            if (success) {
                var intVal = Number.parse(val);
                if (this.minValue > 0 && intVal < this.minValue) {
                    success = false;
                }
                if (this.maxValue > 0 && intVal > this.maxValue) {
                    success = false;
                }
            }
        }
        else {
            success = true;
        }
        if (success) {
            this.onSuccess();
        }
        else {
            this.onFailure(this.createExceptionFromTextInErrorElement());
        }
        return success;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.RegexValidator

Framework.Validation.RegexValidator = function Framework_Validation_RegexValidator(regex) {
    Framework.Validation.RegexValidator.constructBase(this);
    this.regexString = regex;
}
Framework.Validation.RegexValidator.prototype = {
    
    validate: function Framework_Validation_RegexValidator$validate() {
        var inputVal = this.inputValue();
        if (this.doesElementExist()) {
            var regex = new RegExp(this.regexString);
            if (!regex.test(inputVal)) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    },
    
    regexString: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.CustomValidator

Framework.Validation.CustomValidator = function Framework_Validation_CustomValidator() {
    Framework.Validation.CustomValidator.constructBase(this);
}
Framework.Validation.CustomValidator.prototype = {
    customValidatorMethod: null,
    
    validate: function Framework_Validation_CustomValidator$validate() {
        if (this.customValidatorMethod) {
            var result = this.customValidatorMethod.invoke(this.inputValue());
            if (result.success) {
                this.onSuccess();
                return true;
            }
            else {
                this.onFailure(result.exception);
                return false;
            }
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.SameUsernamePasswordValidator

Framework.Validation.SameUsernamePasswordValidator = function Framework_Validation_SameUsernamePasswordValidator() {
    Framework.Validation.SameUsernamePasswordValidator.constructBase(this);
}
Framework.Validation.SameUsernamePasswordValidator.prototype = {
    inputUsernameID: null,
    inputPasswordID: null,
    
    validate: function Framework_Validation_SameUsernamePasswordValidator$validate() {
        this.inputElementId = this.inputUsernameID;
        var Username = this.inputValue();
        this.inputElementId = this.inputPasswordID;
        var Password = this.inputValue();
        if (Username === Password) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ValidateRUT

Framework.Validation.ValidateRUT = function Framework_Validation_ValidateRUT() {
    Framework.Validation.ValidateRUT.constructBase(this);
}
Framework.Validation.ValidateRUT.prototype = {
    inputUsernameId: null,
    
    validate: function Framework_Validation_ValidateRUT$validate() {
        this.inputElementId = this.inputUsernameId;
        var RUT = this.inputValue();
        var Kcheck = RUT.charAt(RUT.length - 1);
        if (!(Kcheck === 'k' || Kcheck === 'K' || (new RegExp('^\\d*$')).test(Kcheck.toString()))) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        RUT = RUT.substring(0, RUT.length - 1);
        var s1 = RUT.replace((new RegExp('[^0-9A-Za-z]', 'g')), '');
        var s2 = s1.replace((new RegExp('[0-9]', 'gi')), '');
        if (RUT.replace((new RegExp('[^0-9A-Za-z]', 'g')), '').replace((new RegExp('[0-9]', 'gi')), '').length) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        RUT = RUT.replace((new RegExp('[^0-9]', 'gi')), '') + Kcheck.toString();
        if (RUT.length < 6 || RUT.length > 9) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        if (this._checkMOD11$1(RUT, true)) {
            this.onSuccess();
            return true;
        }
        this.onFailure(this.createExceptionFromTextInErrorElement());
        return false;
    },
    
    _checkMOD11$1: function Framework_Validation_ValidateRUT$_checkMOD11$1(inStr, acceptMod10) {
        var validNum = '0123456789';
        var i;
        var resStr = '';
        var inStrLen = inStr.length;
        if (inStrLen >= 6) {
            resStr = inStr.substring(0, inStrLen - 1);
        }
        else {
            resStr = inStr.charAt(0);
        }
        var dv = inStr.charAt(inStrLen - 1);
        if (String.isNullOrEmpty(resStr) || String.isNullOrEmpty(dv)) {
            return false;
        }
        var drv = '0';
        var sum = 0;
        var mul = 2;
        for (i = resStr.length - 1; i >= 0; i--) {
            if (validNum.indexOf(resStr.charAt(i)) < 0) {
                return false;
            }
            var tmp = resStr.charAt(i);
            sum = sum + tmp * mul;
            if (mul === 7) {
                mul = 2;
            }
            else {
                mul++;
            }
        }
        var dvi;
        var res = sum % 11;
        if (res === 1) {
            if (acceptMod10) {
                drv = 'k';
            }
            else {
                return false;
            }
        }
        else if (!res) {
            drv = '0';
        }
        else {
            dvi = 11 - res;
            drv = dvi.toString();
        }
        if (drv !== dv.toLowerCase()) {
            return false;
        }
        return true;
    }
}


Framework.AbstractComponent.createClass('Framework.AbstractComponent');
Framework.AbstractEnvironment.createClass('Framework.AbstractEnvironment', null, Framework.IEnvironment);
Framework.AbstractService.createClass('Framework.AbstractService');
Framework.ComponentInfo.createClass('Framework.ComponentInfo');
Framework.PagerCall.createClass('Framework.PagerCall');
Framework.MessageIndicators.createClass('Framework.MessageIndicators');
Framework.Pager.createClass('Framework.Pager');
Framework.PagerLastCall.createClass('Framework.PagerLastCall');
Framework.BubblingEvent.createClass('Framework.BubblingEvent');
Framework.AdminClassNames.createClass('Framework.AdminClassNames');
Framework.AdminUrls.createClass('Framework.AdminUrls');
Framework.AdminPageIds.createClass('Framework.AdminPageIds');
Framework.AdminUtil.createClass('Framework.AdminUtil');
Framework.AdminDragController.createClass('Framework.AdminDragController');
Framework.AdminController.createClass('Framework.AdminController');
Framework.AutoWiring.createClass('Framework.AutoWiring');
Framework.ComponentConfiguration.createClass('Framework.ComponentConfiguration');
Framework.CommonComponentParameters.createClass('Framework.CommonComponentParameters');
Framework.CookieUtil.createClass('Framework.CookieUtil');
Framework.AjaxUpdater.createClass('Framework.AjaxUpdater');
Framework.AbstractMessagingService.createClass('Framework.AbstractMessagingService', Framework.AbstractService);
Framework.CustomCultureInfo.createClass('Framework.CustomCultureInfo');
Framework.DynamicComponentConfiguration.createClass('Framework.DynamicComponentConfiguration');
Framework.NavigationTypeGroup.createClass('Framework.NavigationTypeGroup');
Framework.ListenerInvoker.createClass('Framework.ListenerInvoker');
Framework.Parameters.createClass('Framework.Parameters');
Framework.DragEventArgs.createClass('Framework.DragEventArgs');
Framework.DragObjectPosition.createClass('Framework.DragObjectPosition');
Framework.DragArgs.createClass('Framework.DragArgs');
Framework.Droppables.createClass('Framework.Droppables');
Framework.DraggableStartLocations.createClass('Framework.DraggableStartLocations');
Framework.DragableControl.createClass('Framework.DragableControl', Object);
Framework.Position.createClass('Framework.Position');
Framework.DragController.createClass('Framework.DragController');
Framework.Logger.createClass('Framework.Logger');
Framework.JSONFormat.createClass('Framework.JSONFormat');
Framework.JsonRpcTask.createClass('Framework.JsonRpcTask', null, Framework.IRpcTask);
Framework.ExceptionDetails.createClass('Framework.ExceptionDetails');
Framework.ExceptionTypes.createClass('Framework.ExceptionTypes');
Framework.ExceptionUtil.createClass('Framework.ExceptionUtil');
Framework.Log.createClass('Framework.Log');
Framework.RemoteException.createClass('Framework.RemoteException');
Framework.ServiceConfiguration.createClass('Framework.ServiceConfiguration');
Framework.FormUtil.createClass('Framework.FormUtil');
Framework.DictionaryUtil.createClass('Framework.DictionaryUtil');
Framework.ToolTipBehavior.createClass('Framework.ToolTipBehavior', ScriptFX.UI.Behavior);
Framework.TransformAndUpdateTask.createClass('Framework.TransformAndUpdateTask');
Framework.DOMParser.createClass('Framework.DOMParser', null, IDisposable);
Framework.Behavior.Binding.BehaviorBinder.createClass('Framework.Behavior.Binding.BehaviorBinder');
Framework.Behavior.Binding.AbstractBinding.createClass('Framework.Behavior.Binding.AbstractBinding');
Framework.Behavior.Binding.OnKeyDownBinding.createClass('Framework.Behavior.Binding.OnKeyDownBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnSubmitBinding.createClass('Framework.Behavior.Binding.OnSubmitBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnBlurBinding.createClass('Framework.Behavior.Binding.OnBlurBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnFocusBinding.createClass('Framework.Behavior.Binding.OnFocusBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnMouseOutBinding.createClass('Framework.Behavior.Binding.OnMouseOutBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnMouseOverBinding.createClass('Framework.Behavior.Binding.OnMouseOverBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnKeyUpBinding.createClass('Framework.Behavior.Binding.OnKeyUpBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnChangeBinding.createClass('Framework.Behavior.Binding.OnChangeBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnLoadBinding.createClass('Framework.Behavior.Binding.OnLoadBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnClickBinding.createClass('Framework.Behavior.Binding.OnClickBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.ElementBehavior.createClass('Framework.Behavior.ElementBehavior', ScriptFX.UI.Behavior);
Framework.Behavior.OnKeyDownBehavior.createClass('Framework.Behavior.OnKeyDownBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnSubmitBehavior.createClass('Framework.Behavior.OnSubmitBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnBlurBehavior.createClass('Framework.Behavior.OnBlurBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnFocusBehavior.createClass('Framework.Behavior.OnFocusBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnMouseOutBehavior.createClass('Framework.Behavior.OnMouseOutBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnMouseOverBehavior.createClass('Framework.Behavior.OnMouseOverBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnKeyUpBehavior.createClass('Framework.Behavior.OnKeyUpBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnChangeBehavior.createClass('Framework.Behavior.OnChangeBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnLoadBehavior.createClass('Framework.Behavior.OnLoadBehavior');
Framework.Behavior.OnClickBehavior.createClass('Framework.Behavior.OnClickBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.UrlRewrittingInfoObject.createClass('Framework.Behavior.UrlRewrittingInfoObject');
Framework.Behavior.EventArgs.BehaviorEventArgs.createClass('Framework.Behavior.EventArgs.BehaviorEventArgs');
Framework.Behavior.EventArgs.OnKeyDownEventArgs.createClass('Framework.Behavior.EventArgs.OnKeyDownEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnSubmitEventArgs.createClass('Framework.Behavior.EventArgs.OnSubmitEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnBlurEventArgs.createClass('Framework.Behavior.EventArgs.OnBlurEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnFocusEventArgs.createClass('Framework.Behavior.EventArgs.OnFocusEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnMouseOutEventArgs.createClass('Framework.Behavior.EventArgs.OnMouseOutEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnMouseOverEventArgs.createClass('Framework.Behavior.EventArgs.OnMouseOverEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnKeyUpEventArgs.createClass('Framework.Behavior.EventArgs.OnKeyUpEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.Parameters.createClass('Framework.Behavior.EventArgs.Parameters');
Framework.Behavior.EventArgs.OnLoadEventArgs.createClass('Framework.Behavior.EventArgs.OnLoadEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnChangeEventArgs.createClass('Framework.Behavior.EventArgs.OnChangeEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnClickEventArgs.createClass('Framework.Behavior.EventArgs.OnClickEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Component.AbstractComponent.createClass('Framework.Component.AbstractComponent', null, Framework.Component.IDynamicComponent);
Framework.Component.ComponentFactory.createClass('Framework.Component.ComponentFactory');
Framework.Component.AbstractXsltBasedComponent.createClass('Framework.Component.AbstractXsltBasedComponent', Framework.Component.AbstractComponent);
Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs');
Framework.Component.LifeCycleManagement.ComponentLifeCycleManager.createClass('Framework.Component.LifeCycleManagement.ComponentLifeCycleManager');
Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.createClass('Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager', Framework.Component.LifeCycleManagement.ComponentLifeCycleManager);
Framework.Component.Updating.XsltBasedUpdateContextObject.createClass('Framework.Component.Updating.XsltBasedUpdateContextObject');
Framework.Component.Updating.ComponentUpdateScheduler.createClass('Framework.Component.Updating.ComponentUpdateScheduler');
Framework.Component.Updating.UpdateXsltBasedComponentTask.createClass('Framework.Component.Updating.UpdateXsltBasedComponentTask');
Framework.Component.Updating.HtmlUpdater.createClass('Framework.Component.Updating.HtmlUpdater');
Framework.SDC.SDCManager.createClass('Framework.SDC.SDCManager');
Framework.SDC.SDCStatistic.createClass('Framework.SDC.SDCStatistic');
Framework.SDC.SDCStatisticType.createClass('Framework.SDC.SDCStatisticType');
Framework.SDC.SDCExceptionType.createClass('Framework.SDC.SDCExceptionType');
Framework.SDC.SDCConfig.createClass('Framework.SDC.SDCConfig');
Framework.Util.TypeInfoProvider.createClass('Framework.Util.TypeInfoProvider');
Framework.Util.StringConverter.createClass('Framework.Util.StringConverter');
Framework.Util.DOMElementAttributeProvider.createClass('Framework.Util.DOMElementAttributeProvider', null, IDisposable);
Framework.Validation.ValidationResult.createClass('Framework.Validation.ValidationResult');
Framework.Validation.ValidationManager.createClass('Framework.Validation.ValidationManager');
Framework.Validation.AbstractValidator.createClass('Framework.Validation.AbstractValidator');
Framework.Validation.MandatoryValidator.createClass('Framework.Validation.MandatoryValidator', Framework.Validation.AbstractValidator);
Framework.Validation.DateValidator.createClass('Framework.Validation.DateValidator', Framework.Validation.AbstractValidator);
Framework.Validation.ThreePartDateValidator.createClass('Framework.Validation.ThreePartDateValidator', Framework.Validation.AbstractValidator);
Framework.Validation.MinimumDateOfBirthValidator.createClass('Framework.Validation.MinimumDateOfBirthValidator', Framework.Validation.AbstractValidator);
Framework.Validation.ThreePartMinimumAgeValidator.createClass('Framework.Validation.ThreePartMinimumAgeValidator', Framework.Validation.ThreePartDateValidator);
Framework.Validation.NumericValidator.createClass('Framework.Validation.NumericValidator', Framework.Validation.AbstractValidator);
Framework.Validation.RegexValidator.createClass('Framework.Validation.RegexValidator', Framework.Validation.AbstractValidator);
Framework.Validation.StandardPasswordValidator.createClass('Framework.Validation.StandardPasswordValidator', Framework.Validation.RegexValidator);
Framework.Validation.StandardUsernameValidator.createClass('Framework.Validation.StandardUsernameValidator', Framework.Validation.StandardPasswordValidator);
Framework.Validation.EmailAddressValidator.createClass('Framework.Validation.EmailAddressValidator', Framework.Validation.RegexValidator);
Framework.Validation.MatchedInputsValidator.createClass('Framework.Validation.MatchedInputsValidator', Framework.Validation.AbstractValidator);
Framework.Validation.NumericRangeValidator.createClass('Framework.Validation.NumericRangeValidator', Framework.Validation.AbstractValidator);
Framework.Validation.CustomValidator.createClass('Framework.Validation.CustomValidator', Framework.Validation.AbstractValidator);
Framework.Validation.SameUsernamePasswordValidator.createClass('Framework.Validation.SameUsernamePasswordValidator', Framework.Validation.AbstractValidator);
Framework.Validation.ValidateRUT.createClass('Framework.Validation.ValidateRUT', Framework.Validation.AbstractValidator);
Framework.AbstractComponent.noMessages = [];
Framework.AbstractEnvironment._log = Framework.Logger.getLog('AbstractEnvironment');
Framework.AbstractEnvironment._jsonpRequestTimeout = 60000;
Framework.AbstractEnvironment._enableMultiplexing = true;
Framework.AbstractEnvironment._debugMode = false;
Framework.AbstractEnvironment._singeltonAbstractEnvironment = null;
Framework.MessageIndicators.trueVal = 'True';
Framework.Pager.defaultCallBack = null;
Framework.PagerLastCall._callsByContainerId = {};
Framework.AutoWiring._log = Framework.Logger.getLog('AutoWiring');
Framework.CommonComponentParameters._log = Framework.Logger.getLog('CommonComponentParameters');
Framework.AjaxUpdater._scriptregex = '<script [^\\>]*>([^<]+)</script\\>';
Framework.AbstractMessagingService._log$1 = Framework.Logger.getLog('AbstractMessagingService');
Framework.CustomCultureInfo._customCultures = {};
Framework.CustomCultureInfo._regionalDefaultCulture = {};
Framework.ListenerInvoker._log = Framework.Logger.getLog('ListenerInvoker');
Framework.Parameters.transformAndUpdateSchedulerPeriod = 2000;
Framework.Droppables.drops = [];
Framework.Droppables.offsetLocation = ScriptFX.UI.$create_Location(0, 0);
Framework.DraggableStartLocations._dictionary = {};
Framework.Logger._isLoggingEnabled = false;
Framework.Logger._maximumLogSize = -1;
Framework.JSONFormat.dateFormat = 'd-M-yyyy H-m-s';
Framework.ExceptionTypes.remoteException = 'RemoteException';
Framework.ExceptionTypes.runtimeException = 'RuntimeException';
Framework.ExceptionUtil._log = Framework.Logger.getLog('ExceptionUtil');
Framework.ExceptionUtil._separator = '|';
Framework.Log._domElementName = 'debug';
Framework.TransformAndUpdateTask._log = Framework.Logger.getLog('TransformAndUpdateTask');
Framework.TransformAndUpdateTask._requestCounter = 1;
Framework.TransformAndUpdateTask._xmlCallBacks = {};
Framework.TransformAndUpdateTask._contentRequests = {};
Framework.TransformAndUpdateTask._domElementCounterMap = {};
Framework.TransformAndUpdateTask._cachedXsltXmlDocument = {};
Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE = 'behavior.ID';
Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE = 'behavior.autobind';
Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_HANDLER_SUFFIX = 'EventHandler';
Framework.Behavior.ElementBehavior.behavioR_ID_ATTRIBUTE = 'behavior.ID';
Framework.Component.AbstractComponent.noMessages = [];
Framework.Component.ComponentFactory._log = Framework.Logger.getLog('ComponentFactory');
Framework.Component.ComponentFactory._dynamicComponentCounter = 0;
Framework.Component.Updating.ComponentUpdateScheduler._log = Framework.Logger.getLog('ServerUpdateScheduler');
Framework.Component.Updating.UpdateXsltBasedComponentTask._log = Framework.Logger.getLog('TransformAndUpdateTask');
Framework.Component.Updating.UpdateXsltBasedComponentTask._requestCounter = 1;
Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks = {};
Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests = {};
Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap = {};
Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument = {};
Framework.Component.Updating.HtmlUpdater._log = Framework.Logger.getLog('DirectUpdater');
Framework.SDC.SDCManager._singletonSDCManager = null;
Framework.SDC.SDCManager.notLoggedInternalToken = '';
Framework.SDC.SDCManager._serviceName = 'StatisticsDataCollectionService';
Framework.SDC.SDCManager._minimumBatchSize = 15;
Framework.SDC.SDCManager._maximumBatchSize = 30;
Framework.SDC.SDCManager._timeoutInterval = 15 * 1000;
Framework.SDC.SDCManager._maxFailedBatchSendAttempts = 5;
Framework.SDC.SDCManager._priorityKeyPrefix = '1';
Framework.SDC.SDCStatisticType.render = 1;
Framework.SDC.SDCStatisticType.RPC = 2;
Framework.SDC.SDCStatisticType.sdcStatisticTypes = [ Framework.SDC.SDCStatisticType.render, Framework.SDC.SDCStatisticType.RPC ];
Framework.SDC.SDCExceptionType.noException = 0;
Framework.SDC.SDCExceptionType.callBrokerSystemException = 1;
Framework.SDC.SDCExceptionType.operationalException = 2;
Framework.SDC.SDCExceptionType.infrastructuralException = 3;
Framework.SDC.SDCExceptionType.callbrokerRPCException = 4;
Framework.Validation.AbstractValidator.VALIDATIONEXCEPTIONTYPE = 'System.Warp.ValidationException';
Framework.Validation.AbstractValidator.UNASSIGNEDINPUTID = '_unassigned';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------

Framework.CustomCultureInfo.add('es-CL', new CultureInfo('es-CL',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',

        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: ',',
        percentGroupSeparator: '.',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol: '$',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 0,
        currencyDecimalSeparator: ',',
        currencyGroupSeparator: '.',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 0,
        numberDecimalSeparator: ',',
        numberGroupSeparator: '.'
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, dd MMMM, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, dd MMMM, yyyy',
        shortDatePattern: 'd/M/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['domingo', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado'],
        shortDayNames: ['dom', 'lun', 'mar', 'mie', 'jue', 'vie', 'sab'],
        minimizedDayNames: ['do', 'lu', 'ma', 'mi', 'ju', 'vie', 'sa'],

        monthNames: ['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre', ''],
        shortMonthNames: ['ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'sep', 'oct', 'nov', 'dic', '']
    }));

    Framework.CustomCultureInfo.addLanguageDefaultCulture('ES', 'es-CL');
Type.createNamespace('NavigationService');

////////////////////////////////////////////////////////////////////////////////
// NavigationService.IPageFilterChangedListener

NavigationService.IPageFilterChangedListener = function() { };
NavigationService.IPageFilterChangedListener.prototype = {
    onPageFilterChanged : null
}
NavigationService.IPageFilterChangedListener.createInterface('NavigationService.IPageFilterChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NavigationService.GoToBehavior

NavigationService.GoToBehavior = function NavigationService_GoToBehavior(domElement, id, navigationService) {
    NavigationService.GoToBehavior.constructBase(this, [ domElement, id ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var pageArea = srcElement.getAttribute('pagearea');
        var pageFilter = srcElement.getAttribute('pagefilter');
        if (!String.isNullOrEmpty(pageArea)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            navigationService.goTo(pageArea, (String.isNullOrEmpty(pageFilter)) ? {} : eval('(' + pageFilter + ')'));
        }
        else if (!String.isNullOrEmpty(pageFilter)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            navigationService.setPageFilter(eval(pageFilter));
        }
    }));
}


////////////////////////////////////////////////////////////////////////////////
// NavigationService.NavigationService

NavigationService.NavigationService = function NavigationService_NavigationService() {
    this._pageFilter$1 = {};
    this._navigationStack$1 = [];
    this._httpsAreas$1 = {};
    this._pageFilterChangedListeners$1 = [];
    this._topicalizedPageFilterChangedListeners$1 = {};
    NavigationService.NavigationService.constructBase(this);
    NavigationService.NavigationService._log$1.debug('ctor');
}
NavigationService.NavigationService.prototype = {
    _pageArea$1: null,
    _initialLoad$1: true,
    
    registerPageFilterChangedListener: function NavigationService_NavigationService$registerPageFilterChangedListener(pageFilterChangedListener) {
        NavigationService.NavigationService._log$1.debug('RegisterPageFilterChangedListener');
        if (!this._pageFilterChangedListeners$1.contains(pageFilterChangedListener)) {
            this._pageFilterChangedListeners$1.add(pageFilterChangedListener);
        }
    },
    
    unregisterPageFilterChangedListener: function NavigationService_NavigationService$unregisterPageFilterChangedListener(pageFilterChangedListener) {
        NavigationService.NavigationService._log$1.debug('UnregisterPageFilterChangedListener');
        this._pageFilterChangedListeners$1.remove(pageFilterChangedListener);
    },
    
    registerTopicalizedPageFilterChangedListener: function NavigationService_NavigationService$registerTopicalizedPageFilterChangedListener(pageFilterChangedListener, topic) {
        NavigationService.NavigationService._log$1.debug(String.format('RegisterTopicalizedPageFilterChangedListener topic=[{0}]', topic));
        if (!Object.keyExists(this._topicalizedPageFilterChangedListeners$1, topic)) {
            this._topicalizedPageFilterChangedListeners$1[topic] = [];
        }
        if (!(this._topicalizedPageFilterChangedListeners$1[topic]).contains(pageFilterChangedListener)) {
            (this._topicalizedPageFilterChangedListeners$1[topic]).add(pageFilterChangedListener);
        }
    },
    
    unregisterFromAllTopicsPageFilterChangedListener: function NavigationService_NavigationService$unregisterFromAllTopicsPageFilterChangedListener(pageFilterChangedListener) {
        NavigationService.NavigationService._log$1.debug('UnregisterFromAllTopicsPageFilterChangedListener');
        var $dict1 = this._topicalizedPageFilterChangedListeners$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            (entry.value).remove(pageFilterChangedListener);
        }
    },
    
    _firePageFilterChangedEvent$1: function NavigationService_NavigationService$_firePageFilterChangedEvent$1(listeners) {
        NavigationService.NavigationService._log$1.debug('FirePageFilterChangedEvent');
        var $enum1 = listeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onPageFilterChanged(this);
            }
            catch (ex) {
                NavigationService.NavigationService._log$1.error('FirePageFilterChangedEvent OnPageFilterChanged', ex);
            }
        }
    },
    
    init: function NavigationService_NavigationService$init(environment, parameters) {
        NavigationService.NavigationService._log$1.debug(String.format('Init environment=[{0}] parameters=[{1}]', environment.toString(), Framework.DictionaryUtil.dumpToString(parameters)));
        NavigationService.NavigationService.callBase(this, 'init', [ environment, parameters ]);
        var httpsAreas = (parameters['https-areas']).split(',');
        for (var i = 0; i < httpsAreas.length; i++) {
            this._httpsAreas$1[httpsAreas[i].toLowerCase()] = true;
        }
        this._pageArea$1 = environment.getPageArea();
        this._pageFilter$1 = environment.getInitialPageFilter();
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            var iframe = window.document.createElement('IFRAME');
            iframe.style.display = 'none';
            iframe.id = '_historyFrame';
            iframe.src = '/common/Empty.htm';
            window.document.body.appendChild(iframe);
        }
        ScriptFX.Application.current.enableHistory();
        ScriptFX.Application.current.get_history().add_navigated(Delegate.create(this, this._history_Navigated$1));
    },
    
    _history_Navigated$1: function NavigationService_NavigationService$_history_Navigated$1(sender, e) {
        if (this._initialLoad$1) {
            this._initialLoad$1 = false;
            var hash = window.location.hash.remove(0, 1);
            if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
                ScriptFX.Application.current.get_history().addEntry(hash);
            }
        }
        else {
            if (String.isNullOrEmpty(e.get_entryName())) {
                ScriptFX.Application.current.get_history().goBack();
            }
            else {
                var hashFragments = e.get_entryName().split('&');
                var pageFilter = {};
                var $enum1 = hashFragments.getEnumerator();
                while ($enum1.moveNext()) {
                    var hashFragment = $enum1.get_current();
                    pageFilter[hashFragment.split('=')[0]] = hashFragment.split('=')[1];
                }
                this.goTo(this.getPageArea(), pageFilter);
            }
        }
    },
    
    start: function NavigationService_NavigationService$start() {
        NavigationService.NavigationService._log$1.debug('Start');
    },
    
    getPageArea: function NavigationService_NavigationService$getPageArea() {
        return this._pageArea$1;
    },
    
    getPageFilter: function NavigationService_NavigationService$getPageFilter() {
        var result = {};
        var $dict1 = this._pageFilter$1;
        for (var $key2 in $dict1) {
            var de = { key: $key2, value: $dict1[$key2] };
            result[de.key] = de.value;
        }
        return result;
    },
    
    setPageFilter: function NavigationService_NavigationService$setPageFilter(pageFilter) {
        this.goTo(this._pageArea$1, pageFilter);
    },
    
    getAction: function NavigationService_NavigationService$getAction() {
        return this._pageFilter$1[NavigationService.NavigationService.action];
    },
    
    setAction: function NavigationService_NavigationService$setAction(action) {
        var pageFilter = {};
        var $dict1 = this._pageFilter$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (String.compare(entry.key, NavigationService.NavigationService.action, true)) {
                pageFilter[entry.key] = entry.value;
            }
        }
        if (!String.isNullOrEmpty(action)) {
            pageFilter[NavigationService.NavigationService.action] = action;
        }
        this.goTo(this._pageArea$1, pageFilter);
    },
    
    goTo: function NavigationService_NavigationService$goTo(pageArea, pageFilter) {
        NavigationService.NavigationService._log$1.debug(String.format('GoTo pageArea=[{0}] pageFilter=[{1}]', pageArea, Framework.DictionaryUtil.dumpToString(pageFilter)));
        var protocol = (Object.keyExists(this._httpsAreas$1, pageArea.toLowerCase())) ? 'https' : 'http';
        if (String.equals(this._pageArea$1, pageArea, true) && (String.isNullOrEmpty(protocol) || String.equals(protocol, this._environment.getProtocol(), true))) {
            var changedTopics = [];
            var $dict1 = this._pageFilter$1;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                if (!Object.keyExists(pageFilter, entry.key) || pageFilter[entry.key] !== entry.value) {
                    changedTopics.add(entry.key);
                }
            }
            var $dict3 = pageFilter;
            for (var $key4 in $dict3) {
                var entry = { key: $key4, value: $dict3[$key4] };
                if (!changedTopics.contains(entry.key) && (!Object.keyExists(this._pageFilter$1, entry.key) || this._pageFilter$1[entry.key] !== entry.value)) {
                    changedTopics.add(entry.key);
                }
            }
            var listeners = [];
            for (var i = 0; i < this._pageFilterChangedListeners$1.length; i++) {
                listeners.add(this._pageFilterChangedListeners$1[i]);
            }
            for (var i = 0; i < changedTopics.length; i++) {
                var topicListeners = [];
                if (Object.keyExists(this._topicalizedPageFilterChangedListeners$1, changedTopics[i])) {
                    topicListeners = this._topicalizedPageFilterChangedListeners$1[changedTopics[i]];
                }
                for (var j = 0; j < topicListeners.length; j++) {
                    if (!listeners.contains(topicListeners[j])) {
                        listeners.add(topicListeners[j]);
                    }
                }
            }
            if (changedTopics.length > 0) {
                this._pageFilter$1 = pageFilter;
                this._environment.setHash(pageFilter);
                this._firePageFilterChangedEvent$1(listeners);
            }
        }
        else {
            this._environment.changeLocation(pageArea, pageFilter, true, protocol);
        }
    },
    
    forwardTo: function NavigationService_NavigationService$forwardTo(pageArea, pageFilter) {
        NavigationService.NavigationService._log$1.debug(String.format('ForwardTo pageArea=[{0}] pageFilter=[{1}]', pageArea, Framework.DictionaryUtil.dumpToString(pageFilter)));
        this._navigationStack$1.add(new NavigationService.NavigationStackElement(this._pageArea$1, this._pageFilter$1));
        this.goTo(pageArea, pageFilter);
    },
    
    isEmpty: function NavigationService_NavigationService$isEmpty() {
        return !this._navigationStack$1.length;
    },
    
    goBack: function NavigationService_NavigationService$goBack() {
        NavigationService.NavigationService._log$1.debug('GoBack');
        var top = this._navigationStack$1.removeAt(this._navigationStack$1.length - 1);
        if (top) {
            this.goTo(top.pageArea, top.pageFilter);
        }
    },
    
    goBackAndReport: function NavigationService_NavigationService$goBackAndReport() {
        NavigationService.NavigationService._log$1.debug('GoBackAndReport');
        var top = this._navigationStack$1.removeAt(this._navigationStack$1.length - 1);
        if (top) {
            this.goTo(top.pageArea, top.pageFilter);
            return true;
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// NavigationService.NavigationStackElement

NavigationService.NavigationStackElement = function NavigationService_NavigationStackElement(pageArea, pageFilter) {
    this.pageArea = pageArea;
    this.pageFilter = pageFilter;
}
NavigationService.NavigationStackElement.prototype = {
    pageArea: null,
    pageFilter: null
}


NavigationService.GoToBehavior.createClass('NavigationService.GoToBehavior', ScriptFX.UI.Behavior);
NavigationService.NavigationService.createClass('NavigationService.NavigationService', Framework.AbstractService);
NavigationService.NavigationStackElement.createClass('NavigationService.NavigationStackElement');
NavigationService.NavigationService._log$1 = Framework.Logger.getLog('NavigationService');
NavigationService.NavigationService.action = 'action';
NavigationService.NavigationService.page = 'page';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('SharedWalletService');

////////////////////////////////////////////////////////////////////////////////
// SharedWalletService.SharedWalletService

SharedWalletService.SharedWalletService = function SharedWalletService_SharedWalletService() {
    SharedWalletService.SharedWalletService.constructBase(this);
    SharedWalletService.SharedWalletService._log$1.debug('Ctor');
}
SharedWalletService.SharedWalletService.prototype = {
    
    init: function SharedWalletService_SharedWalletService$init(environment, parameters) {
        SharedWalletService.SharedWalletService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        SharedWalletService.SharedWalletService.callBase(this, 'init', [ environment, parameters ]);
    },
    
    start: function SharedWalletService_SharedWalletService$start() {
    },
    
    createTempId: function SharedWalletService_SharedWalletService$createTempId(successCallback, failureCallback) {
        SharedWalletService.SharedWalletService._log$1.debug(String.format('CreateTempId'));
        this._environment.invokeAsync(SharedWalletService.SharedWalletService._serviceName$1, 'CreateTempId', {}, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), failureCallback);
    },
    
    getBetHistoryDetails: function SharedWalletService_SharedWalletService$getBetHistoryDetails(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, tradingStatuses) {
        SharedWalletService.SharedWalletService._log$1.debug(String.format('GetBetHistoryDetails'));
        this._environment.invokeAsync(SharedWalletService.SharedWalletService._serviceName$1, 'GetBetHistoryDetails', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, tradingStatuses: tradingStatuses, IDDCLanguage: this._environment.getLanguage() }, Delegate.create(this, function(result) {
            var res = result;
            successCallback.invoke(res);
        }), failureCallback);
    },
    
    getConfigParameter: function SharedWalletService_SharedWalletService$getConfigParameter(configKey) {
    }
}


////////////////////////////////////////////////////////////////////////////////
// SharedWalletService.SWBetHistoryDetails

SharedWalletService.SWBetHistoryDetails = function SharedWalletService_SWBetHistoryDetails() {
}
SharedWalletService.SWBetHistoryDetails.prototype = {
    SystemCode: null,
    IDMMBusinessUnit: 0,
    IDSWWebSite: 0,
    ExtTradingId: null,
    Description: null,
    GameId: null,
    GameName: null,
    IDSWTradingStatus: null,
    PlacementDateTime: null,
    StakeValue: 0,
    ReturnValue: 0
}


SharedWalletService.SharedWalletService.createClass('SharedWalletService.SharedWalletService', Framework.AbstractService);
SharedWalletService.SWBetHistoryDetails.createClass('SharedWalletService.SWBetHistoryDetails');
SharedWalletService.SharedWalletService._serviceName$1 = 'SharedWalletService';
SharedWalletService.SharedWalletService._log$1 = Framework.Logger.getLog(SharedWalletService.SharedWalletService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BusinessUnitService');

////////////////////////////////////////////////////////////////////////////////
// BusinessUnitService.BusinessUnitService

BusinessUnitService.BusinessUnitService = function BusinessUnitService_BusinessUnitService() {
    BusinessUnitService.BusinessUnitService.constructBase(this);
}
BusinessUnitService.BusinessUnitService.prototype = {
    _dateTimeOffset$1: 0,
    _businessUnit$1: null,
    
    start: function BusinessUnitService_BusinessUnitService$start() {
        BusinessUnitService.BusinessUnitService._log$1.debug('Start');
    },
    
    getDateTimeOffset: function BusinessUnitService_BusinessUnitService$getDateTimeOffset() {
        return this._dateTimeOffset$1;
    },
    
    getBusinessUnitId: function BusinessUnitService_BusinessUnitService$getBusinessUnitId() {
        return this._businessUnit$1;
    },
    
    getBusinessUnitIdAsync: function BusinessUnitService_BusinessUnitService$getBusinessUnitIdAsync(successCallback, failureCallback) {
        BusinessUnitService.BusinessUnitService._log$1.debug('GetBusinessUnitId');
        this._environment.invokeAsync(BusinessUnitService.BusinessUnitService._serviceName$1, 'GetBusinessUnitId', {}, Delegate.create(this, function(result) {
            this._businessUnit$1 = result;
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            BusinessUnitService.BusinessUnitService._log$1.debug('GetBusinessUnitId exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    getCurrentTime: function BusinessUnitService_BusinessUnitService$getCurrentTime(successCallback, failureCallback) {
        BusinessUnitService.BusinessUnitService._log$1.debug('GetCurrentTime');
        this._environment.invokeAsync(BusinessUnitService.BusinessUnitService._serviceName$1, 'GetCurrentTime', {}, Delegate.create(this, function(result) {
            var currentDateTime = Framework.JSONFormat.parseDateTime(result);
            this._dateTimeOffset$1 = currentDateTime.getTime() - Date.get_now().getTime();
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            BusinessUnitService.BusinessUnitService._log$1.debug('GetCurrentTime exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    getDepositLimitConfiguration: function BusinessUnitService_BusinessUnitService$getDepositLimitConfiguration(successCallback, failureCallback) {
        BusinessUnitService.BusinessUnitService._log$1.debug('GetDepositLimitConfiguration');
        this._environment.invokeAsync(BusinessUnitService.BusinessUnitService._serviceName$1, 'GetDepositLimitConfiguration', {}, successCallback, Delegate.create(this, function(exception) {
            BusinessUnitService.BusinessUnitService._log$1.debug('GetDepositLimitConfiguration exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    }
}


////////////////////////////////////////////////////////////////////////////////
// BusinessUnitService.DepositLimitConfiguration

BusinessUnitService.DepositLimitConfiguration = function BusinessUnitService_DepositLimitConfiguration() {
}
BusinessUnitService.DepositLimitConfiguration.prototype = {
    IDMMPeriodUnit: null,
    PendingPeriodDays: 0
}


BusinessUnitService.BusinessUnitService.createClass('BusinessUnitService.BusinessUnitService', Framework.AbstractService);
BusinessUnitService.DepositLimitConfiguration.createClass('BusinessUnitService.DepositLimitConfiguration');
BusinessUnitService.BusinessUnitService._serviceName$1 = 'BusinessUnitService';
BusinessUnitService.BusinessUnitService._log$1 = Framework.Logger.getLog(BusinessUnitService.BusinessUnitService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('UserService');

////////////////////////////////////////////////////////////////////////////////
// UserService.IPreRegisterCustomerListener

UserService.IPreRegisterCustomerListener = function() { };
UserService.IPreRegisterCustomerListener.prototype = {
    onPreRegisterCustomer : null
}
UserService.IPreRegisterCustomerListener.createInterface('UserService.IPreRegisterCustomerListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.IUserIsRegisteredListener

UserService.IUserIsRegisteredListener = function() { };
UserService.IUserIsRegisteredListener.prototype = {
    onUserRegistered : null
}
UserService.IUserIsRegisteredListener.createInterface('UserService.IUserIsRegisteredListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.IUserChangedListener

UserService.IUserChangedListener = function() { };
UserService.IUserChangedListener.prototype = {
    onUserChanged : null
}
UserService.IUserChangedListener.createInterface('UserService.IUserChangedListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.IUserPreferencesChangedListener

UserService.IUserPreferencesChangedListener = function() { };
UserService.IUserPreferencesChangedListener.prototype = {
    onUserPreferencesChanged : null
}
UserService.IUserPreferencesChangedListener.createInterface('UserService.IUserPreferencesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.PlayerProtectionDetails

UserService.PlayerProtectionDetails = function UserService_PlayerProtectionDetails() {
}
UserService.PlayerProtectionDetails.prototype = {
    ExpiryDate: null,
    IDFOPlayerProtectionArea: null,
    PlayerProtectionAreaName: null
}


////////////////////////////////////////////////////////////////////////////////
// UserService.UpgradeCallCentreCustomerDetails

UserService.UpgradeCallCentreCustomerDetails = function UserService_UpgradeCallCentreCustomerDetails(formDetails) {
    if (Object.keyExists(formDetails, 'AccountNumber')) {
        this.AccountNumber = formDetails['AccountNumber'];
    }
    if (Object.keyExists(formDetails, 'Pin')) {
        this.Pin = formDetails['Pin'];
    }
    if (Object.keyExists(formDetails, 'PrimaryEmail')) {
        this.PrimaryEmail = formDetails['PrimaryEmail'];
    }
    if (Object.keyExists(formDetails, 'HomePhone')) {
        this.HomePhone = formDetails['HomePhone'];
    }
    if (Object.keyExists(formDetails, 'IsNoCorrespondence')) {
        this.IsNoCorrespondence = formDetails['IsNoCorrespondence'];
    }
    if (Object.keyExists(formDetails, 'DateOfBirth')) {
        this.DateOfBirth = formDetails['DateOfBirth'];
    }
    if (Object.keyExists(formDetails, 'UserName')) {
        this.UserName = formDetails['UserName'];
    }
    if (Object.keyExists(formDetails, 'Password')) {
        this.Password = formDetails['Password'];
    }
    if (Object.keyExists(formDetails, 'OddsType')) {
        this.OddsType = formDetails['OddsType'];
    }
    if (Object.keyExists(formDetails, 'IDDCSecretQuestion')) {
        this.IDDCSecretQuestion = formDetails['IDDCSecretQuestion'];
    }
    if (Object.keyExists(formDetails, 'SecretQuestion')) {
        this.SecretQuestion = formDetails['SecretQuestion'];
    }
    if (Object.keyExists(formDetails, 'SecretAnswer')) {
        this.SecretAnswer = formDetails['SecretAnswer'];
    }
}
UserService.UpgradeCallCentreCustomerDetails.prototype = {
    AccountNumber: null,
    Pin: null,
    PrimaryEmail: null,
    HomePhone: null,
    IsNoCorrespondence: false,
    DateOfBirth: null,
    UserName: null,
    Password: null,
    OddsType: null,
    IDDCSecretQuestion: null,
    SecretQuestion: null,
    SecretAnswer: null
}


////////////////////////////////////////////////////////////////////////////////
// UserService.UserService

UserService.UserService = function UserService_UserService() {
    this._userChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._userPreferenceChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._userRegisteredListeners$1 = new Framework.ListenerInvoker(true);
    this._preRegisterCustomerListeners$1 = new Framework.ListenerInvoker(false);
    UserService.UserService.constructBase(this);
    UserService.UserService._log$1.debug('Ctor');
}
UserService.UserService.prototype = {
    _isLoginSecure$1: true,
    _fimsIDCookieName$1: '',
    _allowUpdateTitle$1: false,
    _allowUpdateDOB$1: false,
    
    get_fimsIDCookieName: function UserService_UserService$get_fimsIDCookieName() {
        return this._fimsIDCookieName$1;
    },
    set_fimsIDCookieName: function UserService_UserService$set_fimsIDCookieName(value) {
        this._fimsIDCookieName$1 = value;
        return value;
    },
    
    _fimsAdvertIDCookieName$1: '',
    
    get_fimsAdvertIDCookieName: function UserService_UserService$get_fimsAdvertIDCookieName() {
        return this._fimsAdvertIDCookieName$1;
    },
    set_fimsAdvertIDCookieName: function UserService_UserService$set_fimsAdvertIDCookieName(value) {
        this._fimsAdvertIDCookieName$1 = value;
        return value;
    },
    
    _fimsCookieValidLength$1: '',
    _sessionTimeoutPageArea$1: null,
    _personalDetails$1: null,
    
    get_username: function UserService_UserService$get_username() {
        if (!this._personalDetails$1) {
            return null;
        }
        return this._personalDetails$1.UserName;
    },
    
    get_personalDetails: function UserService_UserService$get_personalDetails() {
        return this._personalDetails$1;
    },
    
    _customerRegistrationDetails$1: null,
    
    onPageWillChange: function UserService_UserService$onPageWillChange() {
        UserService.UserService._log$1.debug('OnPageWillChange');
        this._environment.storeState(UserService.UserService._serviceName$1, { personalDetails: this._personalDetails$1 });
    },
    
    _navigationService$1: null,
    
    setNavigationService: function UserService_UserService$setNavigationService(navigationService) {
        UserService.UserService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    handleSessionTimeout: function UserService_UserService$handleSessionTimeout(exception) {
        UserService.UserService._log$1.debug('HandleSessionTimeout');
        if ((!exception || Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') && this._personalDetails$1) {
            this._personalDetails$1 = null;
            this._fireUserChangedEvent$1();
        }
    },
    
    init: function UserService_UserService$init(environment, parameters) {
        UserService.UserService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        UserService.UserService.callBase(this, 'init', [ environment, parameters ]);
        this._sessionTimeoutPageArea$1 = parameters['session-timeout-page-area'];
        this._fimsIDCookieName$1 = parameters['fimsid-cookie-name'];
        this._fimsAdvertIDCookieName$1 = parameters['fimsadvertid-cookie-name'];
        this._fimsCookieValidLength$1 = parameters['fims-cookie-duration'];
        if (Object.keyExists(parameters, 'is-login-secure')) {
            this._isLoginSecure$1 = Boolean.parse(parameters['is-login-secure']);
        }
        if (Object.keyExists(parameters, 'allow-update-title')) {
            this._allowUpdateTitle$1 = Boolean.parse(parameters['allow-update-title']);
        }
        if (Object.keyExists(parameters, 'allow-update-DOB')) {
            this._allowUpdateDOB$1 = Boolean.parse(parameters['allow-update-DOB']);
        }
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(UserService.UserService._serviceName$1);
        if (state && Object.keyExists(state, 'personalDetails')) {
            this._personalDetails$1 = state['personalDetails'];
        }
        UserService.UserService._log$1.debug(String.format('Retrieving personalDetails, UserName= [{0}]', (!this._personalDetails$1) ? '' : this._personalDetails$1.UserName));
    },
    
    start: function UserService_UserService$start() {
        UserService.UserService._log$1.debug(String.format('Start IsLoggedIn={0}', this.isLoggedIn()));
        if (!this._personalDetails$1) {
            this.getPersonalDetailsIfLoggedIn(Delegate.create(this, function(result) {
            }), Delegate.create(this, function(exception) {
            }));
        }
        var fimsID = this._getFimsParameterValues$1(this._fimsIDCookieName$1);
        var fimsAdverID = this._getFimsParameterValues$1(this._fimsAdvertIDCookieName$1);
        if (!String.isNullOrEmpty(fimsID)) {
            if (String.isNullOrEmpty(this._fimsCookieValidLength$1)) {
                Framework.CookieUtil.setCookie(this._fimsIDCookieName$1, fimsID);
            }
            else {
                Framework.CookieUtil.setCookieWithDays(this._fimsIDCookieName$1, fimsID, Number.parse(this._fimsCookieValidLength$1));
            }
        }
        if (!String.isNullOrEmpty(fimsAdverID)) {
            Framework.CookieUtil.setCookie(this._fimsAdvertIDCookieName$1, fimsAdverID);
        }
    },
    
    _getFimsParameterValues$1: function UserService_UserService$_getFimsParameterValues$1(fimsParameter) {
        var fimsParameterValue = '';
        if (this._navigationService$1.getPageFilter()[fimsParameter]) {
            fimsParameterValue = this._navigationService$1.getPageFilter()[fimsParameter].toString();
        }
        else if (!String.isNullOrEmpty(Framework.CookieUtil.getCookie('_defaultAspxQuerystring')) && Framework.CookieUtil.getCookie('_defaultAspxQuerystring').toLowerCase().indexOf(fimsParameter.toLowerCase()) >= 0) {
            var cookieValue = Framework.CookieUtil.getCookie('_defaultAspxQuerystring').toLowerCase();
            var regex = new RegExp('(?:^|&)' + fimsParameter.toLowerCase() + '=(.*?)&');
            var cookieParse = regex.exec(cookieValue + '&');
            if (cookieParse && cookieParse.length === 2) {
                fimsParameterValue = cookieParse[1];
            }
            cookieValue = cookieValue.replace(String.format('{0}={1}', fimsParameter, fimsParameterValue), '');
            if (String.isNullOrEmpty(cookieValue)) {
                Framework.CookieUtil.clearCookie('_defaultAspxQuerystring');
            }
            else {
                Framework.CookieUtil.setCookie('_defaultAspxQuerystring', cookieValue);
            }
        }
        return fimsParameterValue;
    },
    
    registerUserChangedListener: function UserService_UserService$registerUserChangedListener(userChangedListener) {
        UserService.UserService._log$1.debug('RegisterUserChangedListener');
        this._userChangedListeners$1.registerListener(userChangedListener);
    },
    
    unregisterUserChangedListener: function UserService_UserService$unregisterUserChangedListener(userChangedListener) {
        UserService.UserService._log$1.debug('UnregisterUserChangedListener');
        this._userChangedListeners$1.unregisterListener(userChangedListener);
    },
    
    _fireUserChangedEvent$1: function UserService_UserService$_fireUserChangedEvent$1() {
        UserService.UserService._log$1.debug('FireUserChangedEvent');
        this._userChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onUserChanged(this);
        }));
    },
    
    registerUserPreferencesChangedListener: function UserService_UserService$registerUserPreferencesChangedListener(userPreferencesChangedListener) {
        UserService.UserService._log$1.debug('RegisterUserPreferencesChangedListener');
        this._userPreferenceChangedListeners$1.registerListener(userPreferencesChangedListener);
    },
    
    unregisterUserPreferencesChangedListener: function UserService_UserService$unregisterUserPreferencesChangedListener(userPreferencesChangedListener) {
        UserService.UserService._log$1.debug('UnregisterUserPreferencesChangedListener');
        this._userPreferenceChangedListeners$1.unregisterListener(userPreferencesChangedListener);
    },
    
    _fireUserPreferencesChangedEvent$1: function UserService_UserService$_fireUserPreferencesChangedEvent$1() {
        UserService.UserService._log$1.debug('FireUserPreferencesChangedEvent');
        this._userPreferenceChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onUserPreferencesChanged(this);
        }));
    },
    
    registerUserRegisteredListener: function UserService_UserService$registerUserRegisteredListener(userRegisteredListener) {
        UserService.UserService._log$1.debug('RegisterUserRegisteredListener');
        this._userRegisteredListeners$1.registerListener(userRegisteredListener);
    },
    
    unregisterUserRegisteredListener: function UserService_UserService$unregisterUserRegisteredListener(userRegisteredListener) {
        UserService.UserService._log$1.debug('UnregisterUserRegisteredListener');
        this._userRegisteredListeners$1.unregisterListener(userRegisteredListener);
    },
    
    _fireUserRegisteredEvent$1: function UserService_UserService$_fireUserRegisteredEvent$1() {
        UserService.UserService._log$1.debug('FireUserRegisteredEvent');
        this._userRegisteredListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onUserRegistered();
        }));
    },
    
    registerPreRegisterCustomerListener: function UserService_UserService$registerPreRegisterCustomerListener(preRegisterCustomer) {
        UserService.UserService._log$1.debug('RegisterPreRegisterCustomerListener');
        this._preRegisterCustomerListeners$1.registerListener(preRegisterCustomer);
    },
    
    unregisterPreRegisterCustomerListener: function UserService_UserService$unregisterPreRegisterCustomerListener(preRegisterCustomer) {
        UserService.UserService._log$1.debug('UnregisterPreRegisterCustomerListener');
        this._preRegisterCustomerListeners$1.unregisterListener(preRegisterCustomer);
    },
    
    _firePreRegisterCustomerEvent$1: function UserService_UserService$_firePreRegisterCustomerEvent$1() {
        UserService.UserService._log$1.debug('FirePreRegisterCustomerEvent');
        this._preRegisterCustomerListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onPreRegisterCustomer(this);
        }));
    },
    
    registerCustomer: function UserService_UserService$registerCustomer(successCallback, failureCallback, customerRegistrationDetails) {
        UserService.UserService._log$1.debug(String.format('RegisterCustomer customerRegistrationDetails=[{0}]', Framework.DictionaryUtil.dumpToString(customerRegistrationDetails)));
        this._customerRegistrationDetails$1 = customerRegistrationDetails;
        var fimsid = Framework.CookieUtil.getCookie(this._fimsIDCookieName$1);
        if (!String.isNullOrEmpty(fimsid)) {
            this._customerRegistrationDetails$1['SessionOrigin'] = fimsid;
        }
        this._firePreRegisterCustomerEvent$1();
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'RegisterCustomer', { customerRegistrationDetails: this._customerRegistrationDetails$1 }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this._fireUserRegisteredEvent$1();
            this.login(Delegate.create(this, function(loginResult) {
            }), Delegate.create(this, function(exception) {
            }), this._customerRegistrationDetails$1['UserName'], this._customerRegistrationDetails$1['Password']);
        }), failureCallback);
    },
    
    upgradeCallCentreCustomer: function UserService_UserService$upgradeCallCentreCustomer(successCallback, failureCallback, upgradeCallCentreCustomerDetails) {
        UserService.UserService._log$1.debug(String.format('UpgradeCallCentreCustomer upgradeCallCentreCustomerDetails=[{0}]', Framework.DictionaryUtil.dumpObjectToString(upgradeCallCentreCustomerDetails)));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpgradeCallCentreCustomer', { upgradeCallCentreCustomerDetails: upgradeCallCentreCustomerDetails }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.login(Delegate.create(this, function(loginResult) {
            }), Delegate.create(this, function(exception) {
            }), upgradeCallCentreCustomerDetails.UserName, upgradeCallCentreCustomerDetails.Password);
        }), failureCallback);
    },
    
    isUsernameAvailable: function UserService_UserService$isUsernameAvailable(successCallback, failureCallback, username) {
        UserService.UserService._log$1.debug(String.format('IsUsernameAvailable username=[{0}]', username));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'IsUsernameAvailable', { username: username }, successCallback, failureCallback);
    },
    
    isLoggedIn: function UserService_UserService$isLoggedIn() {
        UserService.UserService._log$1.debug('IsLoggedIn');
        return (this._personalDetails$1) ? true : false;
    },
    
    login: function UserService_UserService$login(successCallback, failureCallback, username, password) {
        UserService.UserService._log$1.debug(String.format('Login username=[{0}] password=[{1}]', username, password));
        this._environment.invokeAsyncUsingJsonp(UserService.UserService._serviceName$1, 'Login', { username: username, password: password }, Delegate.create(this, function(result) {
            this._personalDetails$1 = result;
            successCallback.invoke(result);
            this._fireUserChangedEvent$1();
            if (this._personalDetails$1.IsVerificationRequired) {
                this._navigationService$1.goTo('Accounting', { action: 'verify-customer' });
            }
        }), failureCallback, this._isLoginSecure$1);
    },
    
    loginWithCryptogram: function UserService_UserService$loginWithCryptogram(successCallback, failureCallback, username, passwordCryptogram) {
        UserService.UserService._log$1.debug(String.format('Login username=[{0}] passwordCryptogram=[{1}]', username, passwordCryptogram));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'LoginWithCryptogram', { username: username, passwordCryptogram: passwordCryptogram }, Delegate.create(this, function(result) {
            this._personalDetails$1 = result;
            successCallback.invoke(result);
            this._fireUserChangedEvent$1();
            if (this._personalDetails$1.IsVerificationRequired) {
                this._navigationService$1.goTo('Accounting', { action: 'verify-customer' });
            }
        }), failureCallback);
    },
    
    logout: function UserService_UserService$logout(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('Logout');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'Logout', {}, Delegate.create(this, function(result) {
            this._personalDetails$1 = null;
            successCallback.invoke(result);
            this._fireUserChangedEvent$1();
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug(String.format('Error while logging out errorMessage = [{0}]', Framework.ExceptionUtil.getExceptionDetails(exception).get_message()));
            this._personalDetails$1 = null;
            failureCallback.invoke(exception);
            this._fireUserChangedEvent$1();
        }));
    },
    
    setPassword: function UserService_UserService$setPassword(successCallback, failureCallback, oldPassword, password) {
        UserService.UserService._log$1.debug(String.format('SetPassword oldPassword=[{0}] password=[{1}]', oldPassword, password));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'SetPassword', { oldPassword: oldPassword, password: password }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('SetPassword exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getSecretQuestion: function UserService_UserService$getSecretQuestion(successCallback, failureCallback, userName, dateOfBirth) {
        UserService.UserService._log$1.debug(String.format('GetSecretQuestion userName=[{0}] dateOfBirth=[{1}]', userName, dateOfBirth));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetSecretQuestion', { username: userName, dateOfBirth: Framework.JSONFormat.formatDateTime(dateOfBirth) }, successCallback, failureCallback);
    },
    
    setPasswordUsingSecretAnswer: function UserService_UserService$setPasswordUsingSecretAnswer(successCallback, failureCallback, username, answer, password, IDDCSecretQuestion) {
        UserService.UserService._log$1.debug(String.format('SetPassword userName=[{0}] answer=[{1}] password=[{2}] IDDCSecretQuestion=[{3}]', username, answer, password, IDDCSecretQuestion));
        var dictionary = { username: username, answer: answer, password: password, IDDCSecretQuestion: IDDCSecretQuestion };
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'SetPasswordUsingSecretAnswer', dictionary, successCallback, failureCallback);
    },
    
    resetPassword: function UserService_UserService$resetPassword(successCallback, failureCallback, username, dateOfBirth) {
        UserService.UserService._log$1.debug(String.format('ResetPassword userName=[{0}] dateOfBirth=[{1}]', username, dateOfBirth));
        var dictionary = { username: username, dateOfBirth: Framework.JSONFormat.formatDateTime(dateOfBirth) };
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'ResetPassword', dictionary, successCallback, failureCallback);
    },
    
    getTempSession4PasswordReset: function UserService_UserService$getTempSession4PasswordReset(successCallback, failureCallback, username, email) {
        UserService.UserService._log$1.debug(String.format('GetTempSession4PasswordReset username=[{0}] email=[{1}]', username, email));
        var dictionary = { IDMDLanguage: this._environment.getLanguage(), username: username, email: email };
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetTempSessionForPasswordReset', dictionary, successCallback, failureCallback);
    },
    
    isVerified: function UserService_UserService$isVerified(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('IsVerified');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'IsVerified', {}, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('IsVerified exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    startVerification: function UserService_UserService$startVerification(successCallback, failureCallback, IDMMCVType, detailsToBeVerified) {
        UserService.UserService._log$1.debug(String.format('StartVerification IDMMCVType=[{0}] detailsToBeVerified=[{1}]', IDMMCVType, detailsToBeVerified));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'StartVerification', { IDMMCVType: IDMMCVType, detailsToBeVerified: detailsToBeVerified }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('StartVerification exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    completeVerification: function UserService_UserService$completeVerification(successCallback, failureCallback, verificationCodeEntered) {
        UserService.UserService._log$1.debug(String.format('CompleteVerification verificationCodeEntered=[{0}]', verificationCodeEntered));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'CompleteVerification', { verificationCodeEntered: verificationCodeEntered }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('CompleteVerification exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getPersonalDetails: function UserService_UserService$getPersonalDetails(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPersonalDetails');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPersonalDetails', {}, Delegate.create(this, function(result) {
            var personalDetails = result;
            var changed = false;
            if (personalDetails) {
                changed = !this._personalDetails$1 || this._personalDetails$1.UserName !== personalDetails.UserName;
            }
            else {
                changed = this._personalDetails$1;
            }
            this._personalDetails$1 = personalDetails;
            successCallback.invoke(result);
            if (changed) {
                this._fireUserChangedEvent$1();
            }
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetPersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getPersonalDetailsIfLoggedIn: function UserService_UserService$getPersonalDetailsIfLoggedIn(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPersonalDetailsIfLoggedIn');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPersonalDetailsIfLoggedIn', {}, Delegate.create(this, function(result) {
            var personalDetails = result;
            var changed = false;
            if (personalDetails) {
                changed = !this._personalDetails$1 || this._personalDetails$1.UserName !== personalDetails.UserName;
            }
            else {
                changed = this._personalDetails$1;
            }
            this._personalDetails$1 = personalDetails;
            successCallback.invoke(result);
            if (changed) {
                this._fireUserChangedEvent$1();
            }
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetPersonalDetailsIfLoggedIn exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    updatePersonalDetails: function UserService_UserService$updatePersonalDetails(successCallback, failureCallback, personalDetails) {
        UserService.UserService._log$1.debug(String.format('UpdatePersonalDetails personalDetails=[{0}]', Framework.DictionaryUtil.dumpToString(personalDetails)));
        if (!this._allowUpdateTitle$1 || !personalDetails['Title']) {
            personalDetails['Title'] = this._personalDetails$1.Title;
        }
        if (!this._allowUpdateDOB$1 || !personalDetails['DateOfBirth']) {
            personalDetails['DateOfBirth'] = this._personalDetails$1.DateOfBirth;
        }
        if (!Object.keyExists(personalDetails, 'IDMMGender')) {
            personalDetails['IDMMGender'] = this._personalDetails$1.IDMMGender;
        }
        if (!Object.keyExists(personalDetails, 'FirstName')) {
            personalDetails['FirstName'] = this._personalDetails$1.FirstName;
        }
        if (!Object.keyExists(personalDetails, 'LastName')) {
            personalDetails['LastName'] = this._personalDetails$1.LastName;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpdatePersonalDetails', { personalDetails: personalDetails }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('UpdatePersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    updateExtendedPersonalDetails: function UserService_UserService$updateExtendedPersonalDetails(successCallback, failureCallback, personalDetails) {
        UserService.UserService._log$1.debug(String.format('UpdateExtendedPersonalDetails personalDetails=[{0}]', Framework.DictionaryUtil.dumpToString(personalDetails)));
        if (!Object.keyExists(personalDetails, 'IVRPin')) {
            personalDetails['IVRPin'] = '';
        }
        if (!Object.keyExists(personalDetails, 'Title')) {
            personalDetails['Title'] = this._personalDetails$1.Title;
        }
        if (!Object.keyExists(personalDetails, 'IDMMGender')) {
            personalDetails['IDMMGender'] = this._personalDetails$1.IDMMGender;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpdateExtendedPersonalDetails', { personalDetails: personalDetails }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('UpdateExtendedPersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    setPlayerProtection: function UserService_UserService$setPlayerProtection(successCallback, failureCallback, playerProtectionDetails) {
        UserService.UserService._log$1.debug('SetPlayerProtection');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'SetPlayerProtection', { playerProtectionDetails: playerProtectionDetails }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('SetPlayerProtection exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getPlayerProtection: function UserService_UserService$getPlayerProtection(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPlayerProtection');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPlayerProtection', {}, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetPlayerProtection exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    _getIntegration$1: function UserService_UserService$_getIntegration$1(integrations, integrationName) {
        var integration = null;
        var $enum1 = integrations.getEnumerator();
        while ($enum1.moveNext()) {
            var item = $enum1.get_current();
            if (Object.keyExists(item, UserService.UserService._nameConst$1) && String.equals(item[UserService.UserService._nameConst$1].toString(), integrationName, false)) {
                integration = item;
                break;
            }
        }
        if (!integration) {
            integration = {};
            integration[UserService.UserService._nameConst$1] = integrationName;
            integration[UserService.UserService._propertiesConst$1] = {};
        }
        return integration;
    },
    
    _setIntegration$1: function UserService_UserService$_setIntegration$1(integrations, integrationName, integration) {
        var item = null;
        var found = false;
        for (var i = 0; i < integrations.length; i++) {
            item = integrations[i];
            if (Object.keyExists(item, UserService.UserService._nameConst$1) && String.equals(item[UserService.UserService._nameConst$1].toString(), integrationName, false)) {
                integrations[i] = integration;
                found = true;
                break;
            }
        }
        if (!found) {
            integrations.add(integration);
        }
    },
    
    setIntegrationDetails: function UserService_UserService$setIntegrationDetails(integrationName, propertyName, propertyValue) {
        UserService.UserService._log$1.debug('SetIntegrationDetails');
        var integrations;
        var integration;
        var properties = null;
        if (Object.keyExists(this._customerRegistrationDetails$1, UserService.UserService._integrationDetailsConst$1)) {
            integrations = this._customerRegistrationDetails$1[UserService.UserService._integrationDetailsConst$1];
        }
        else {
            integrations = [];
        }
        integration = this._getIntegration$1(integrations, integrationName);
        properties = integration[UserService.UserService._propertiesConst$1];
        properties[propertyName] = (propertyValue) ? propertyValue : '';
        integration[UserService.UserService._propertiesConst$1] = properties;
        this._setIntegration$1(integrations, integrationName, integration);
        this._customerRegistrationDetails$1[UserService.UserService._integrationDetailsConst$1] = integrations;
    },
    
    contactUsViaEmail: function UserService_UserService$contactUsViaEmail(successCallback, failureCallback, subject, email, body) {
        var oBody = '';
        var i = 0;
        var $dict1 = body;
        for (var $key2 in $dict1) {
            var oEntry = { key: $key2, value: $dict1[$key2] };
            var separator = (!i) ? '' : '|';
            oBody = oBody + separator + oEntry.value;
            i++;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'sendContactUsEmail', { subject: subject, email: email, body: oBody }, successCallback, failureCallback);
    }
}


////////////////////////////////////////////////////////////////////////////////
// UserService.PersonalDetails

UserService.PersonalDetails = function UserService_PersonalDetails() {
}
UserService.PersonalDetails.prototype = {
    City: null,
    CountyOrStateOrProvince: null,
    FirstName: null,
    FullName: null,
    HomePhone: null,
    IDMMCountry: null,
    LastName: null,
    MiddleNames: null,
    MobilePhone: null,
    PostCode: null,
    PrimaryEmail: null,
    StreetAddress: null,
    Title: null,
    UserName: null,
    DateOfBirth: null,
    IsVerificationRequired: false,
    ResetPasswordRequired: null,
    ExpiredPwdChangeMethod: null,
    IDMMGender: null
}


UserService.PlayerProtectionDetails.createClass('UserService.PlayerProtectionDetails');
UserService.UpgradeCallCentreCustomerDetails.createClass('UserService.UpgradeCallCentreCustomerDetails');
UserService.UserService.createClass('UserService.UserService', Framework.AbstractService, Framework.IPageWillChangeListener);
UserService.PersonalDetails.createClass('UserService.PersonalDetails');
UserService.UserService._serviceName$1 = 'UserService';
UserService.UserService._integrationDetailsConst$1 = 'IntegrationDetails';
UserService.UserService._nameConst$1 = 'Name';
UserService.UserService._propertiesConst$1 = 'Properties';
UserService.UserService._log$1 = Framework.Logger.getLog(UserService.UserService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('AccountService');

////////////////////////////////////////////////////////////////////////////////
// AccountService.IAccountPreferencesChangedListener

AccountService.IAccountPreferencesChangedListener = function() { };
AccountService.IAccountPreferencesChangedListener.prototype = {
    onAccountPreferencesChanged : null
}
AccountService.IAccountPreferencesChangedListener.createInterface('AccountService.IAccountPreferencesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// AccountService.IBalanceChangedListener

AccountService.IBalanceChangedListener = function() { };
AccountService.IBalanceChangedListener.prototype = {
    onBalanceChanged : null
}
AccountService.IBalanceChangedListener.createInterface('AccountService.IBalanceChangedListener');


////////////////////////////////////////////////////////////////////////////////
// AccountService.IDepositExecutedListener

AccountService.IDepositExecutedListener = function() { };
AccountService.IDepositExecutedListener.prototype = {
    onDepositExecuted : null
}
AccountService.IDepositExecutedListener.createInterface('AccountService.IDepositExecutedListener');


////////////////////////////////////////////////////////////////////////////////
// AccountService.AccountPreferences

AccountService.AccountPreferences = function AccountService_AccountPreferences(isAccountBalanceConstantlyDisplayed, isCallCentreAccountNumberConstantlyDisplayed, promotionalEmailFormat, IDDCSecretQuestion, answer, isNoCorrespondence) {
    this.IsAccountBalanceConstantlyDisplayed = isAccountBalanceConstantlyDisplayed;
    this.IsCallCentreAccountNumberConstantlyDisplayed = isCallCentreAccountNumberConstantlyDisplayed;
    this.PromotionalEmailFormat = (promotionalEmailFormat !== AccountService.AccountPreferences.plainText && promotionalEmailFormat !== AccountService.AccountPreferences.html && promotionalEmailFormat !== AccountService.AccountPreferences.dontSend) ? AccountService.AccountPreferences.defaultType : promotionalEmailFormat;
    this.IDDCSecretQuestion = IDDCSecretQuestion;
    this.IsNoCorrespondence = isNoCorrespondence;
    this.Answer = answer;
}
AccountService.AccountPreferences.equals = function AccountService_AccountPreferences$equals(preferences1, preferences2) {
    if (!preferences1 && !preferences2) {
        return true;
    }
    if (!preferences1 && preferences2) {
        return false;
    }
    if (preferences1 && !preferences2) {
        return false;
    }
    if (preferences1.IsAccountBalanceConstantlyDisplayed !== preferences2.IsAccountBalanceConstantlyDisplayed) {
        return false;
    }
    if (preferences1.IsCallCentreAccountNumberConstantlyDisplayed !== preferences2.IsCallCentreAccountNumberConstantlyDisplayed) {
        return false;
    }
    if (preferences1.IsNoCorrespondence !== preferences2.IsNoCorrespondence) {
        return false;
    }
    if (!String.equals(preferences1.PromotionalEmailFormat, preferences2.PromotionalEmailFormat, true)) {
        return false;
    }
    if (!String.equals(preferences1.IDDCSecretQuestion, preferences2.IDDCSecretQuestion, true)) {
        return false;
    }
    if (!String.equals(preferences1.Answer, preferences2.Answer, true)) {
        return false;
    }
    return true;
}
AccountService.AccountPreferences.prototype = {
    IsAccountBalanceConstantlyDisplayed: false,
    IsCallCentreAccountNumberConstantlyDisplayed: false,
    PromotionalEmailFormat: null,
    IDDCSecretQuestion: null,
    Answer: null,
    IsNoCorrespondence: false
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.AccountService

AccountService.AccountService = function AccountService_AccountService() {
    this._accountPreferencesChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._balanceChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._depositExecutedListener$1 = new Framework.ListenerInvoker(true);
    AccountService.AccountService.constructBase(this);
    AccountService.AccountService._log$1.debug('ctor');
}
AccountService.AccountService.prototype = {
    _preferences$1: null,
    _accountsDetails$1: null,
    
    _getState$1: function AccountService_AccountService$_getState$1() {
        return { preferences: this._preferences$1, accountsDetails: this._accountsDetails$1 };
    },
    
    init: function AccountService_AccountService$init(environment, parameters) {
        AccountService.AccountService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        AccountService.AccountService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(AccountService.AccountService._serviceName$1);
        if (state && Object.keyExists(state, 'preferences')) {
            this._preferences$1 = state['preferences'];
        }
        else {
            this._preferences$1 = this._getDefaultPreferences$1();
        }
        if (state && Object.keyExists(state, 'accountsDetails')) {
            this._accountsDetails$1 = state['accountsDetails'];
        }
    },
    
    start: function AccountService_AccountService$start() {
        AccountService.AccountService._log$1.debug('Start');
    },
    
    onPageWillChange: function AccountService_AccountService$onPageWillChange() {
        AccountService.AccountService._log$1.debug('OnPageWillChange');
        this._environment.storeState(AccountService.AccountService._serviceName$1, this._getState$1());
    },
    
    _userService$1: null,
    
    setUserService: function AccountService_AccountService$setUserService(userService) {
        AccountService.AccountService._log$1.debug('SetUserService');
        this._userService$1 = userService;
        this._userService$1.registerUserChangedListener(this);
    },
    
    onUserChanged: function AccountService_AccountService$onUserChanged(eventSource) {
        AccountService.AccountService._log$1.debug('OnUserChanged');
        if (this._userService$1.isLoggedIn()) {
            this.fetchPreferences(null, null);
            this.fetchAccountsDetails();
        }
        else {
            this._preferences$1 = this._getDefaultPreferences$1();
            this._accountsDetails$1 = null;
            this._fireBalanceChangedEvent$1();
        }
    },
    
    registerAccountPreferencesChangedListener: function AccountService_AccountService$registerAccountPreferencesChangedListener(accountPreferencesChangedListener) {
        AccountService.AccountService._log$1.debug('RegisterAccountPreferencesChangedListener');
        this._accountPreferencesChangedListeners$1.registerListener(accountPreferencesChangedListener);
    },
    
    unregisterAccountPreferencesChangedListener: function AccountService_AccountService$unregisterAccountPreferencesChangedListener(accountPreferencesChangedListener) {
        AccountService.AccountService._log$1.debug('UnregisterAccountPreferencesChangedListener');
        this._accountPreferencesChangedListeners$1.unregisterListener(accountPreferencesChangedListener);
    },
    
    _fireAccountPreferencesChangedEvent$1: function AccountService_AccountService$_fireAccountPreferencesChangedEvent$1() {
        AccountService.AccountService._log$1.debug('FireAccountPreferencesChangedEvent');
        this._accountPreferencesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onAccountPreferencesChanged(this);
        }));
    },
    
    registerBalanceChangedListener: function AccountService_AccountService$registerBalanceChangedListener(listener) {
        AccountService.AccountService._log$1.debug('RegisterBalanceChangedListener');
        this._balanceChangedListeners$1.registerListener(listener);
    },
    
    unregisterBalanceChangedListener: function AccountService_AccountService$unregisterBalanceChangedListener(listener) {
        AccountService.AccountService._log$1.debug('UnregisterBalanceChangedListener');
        this._balanceChangedListeners$1.unregisterListener(listener);
    },
    
    _fireBalanceChangedEvent$1: function AccountService_AccountService$_fireBalanceChangedEvent$1() {
        AccountService.AccountService._log$1.debug('FireBalanceChangedEvent');
        this._balanceChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBalanceChanged(this);
        }));
    },
    
    registerDepositExecutedListener: function AccountService_AccountService$registerDepositExecutedListener(listener) {
        AccountService.AccountService._log$1.debug('RegisterDepositExecutedListener');
        this._depositExecutedListener$1.registerListener(listener);
    },
    
    unregisterDepositExecutedListener: function AccountService_AccountService$unregisterDepositExecutedListener(listener) {
        AccountService.AccountService._log$1.debug('UnregisterDepositExecutedListener');
        this._depositExecutedListener$1.unregisterListener(listener);
    },
    
    _fireDepositExecutedEvent$1: function AccountService_AccountService$_fireDepositExecutedEvent$1() {
        AccountService.AccountService._log$1.debug('FireDepositExecutedEvent');
        this._depositExecutedListener$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onDepositExecuted(this);
        }));
    },
    
    getCurrencySimbol: function AccountService_AccountService$getCurrencySimbol() {
        if (!this._accountsDetails$1 || !this._accountsDetails$1.length) {
            return null;
        }
        return this._accountsDetails$1[0].CurrencyNotation;
    },
    
    getCurrencySimbolHTML: function AccountService_AccountService$getCurrencySimbolHTML() {
        if (!this._accountsDetails$1 || !this._accountsDetails$1.length) {
            return null;
        }
        return this._accountsDetails$1[0].CurrencyHtmlNotation;
    },
    
    get_accountsDetails: function AccountService_AccountService$get_accountsDetails() {
        return this._accountsDetails$1;
    },
    
    get_creditAccountDetails: function AccountService_AccountService$get_creditAccountDetails() {
        var details = this._accountsDetails$1;
        if (details) {
            for (var i = 0; i < details.length; i++) {
                if (!String.compare(details[i].IDMMAccountClass, 'credit', true)) {
                    return details[i];
                }
            }
        }
        return null;
    },
    
    get_freeAccountDetails: function AccountService_AccountService$get_freeAccountDetails() {
        var details = this._accountsDetails$1;
        if (details) {
            for (var i = 0; i < details.length; i++) {
                if (!String.compare(details[i].IDMMAccountClass, 'free', true)) {
                    return details[i];
                }
            }
        }
        return null;
    },
    
    fetchAccountsDetails: function AccountService_AccountService$fetchAccountsDetails() {
        AccountService.AccountService._log$1.debug('GetAccountsDetails');
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetAccountsDetails', {}, Delegate.create(this, function(result) {
            if (result) {
                var hasChanged = !AccountService.AccountDetails.equalsArray(this._accountsDetails$1, result);
                this._accountsDetails$1 = result;
                if (hasChanged) {
                    this._fireBalanceChangedEvent$1();
                }
            }
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetAccountsDetails exception' + exception.message);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistory: function AccountService_AccountService$getBalanceHistory(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistory from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistory', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistoryFiltered: function AccountService_AccountService$getBalanceHistoryFiltered(successCallback, failureCallback, from, to, IncludeTxTypes, ExcludeTxTypes, IncludeTxClasses, ExcludeTxClasses, pageNumber, pageSize, orderBy, orderDesc) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistory from=[{0}] to=[{1}] includeTxType[{6}] excludeTxType[{7}] includeTxClasses[{8}] excludeTxClasses[{9}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, (!IncludeTxTypes) ? String.Empty : IncludeTxTypes.join(','), (!ExcludeTxTypes) ? String.Empty : ExcludeTxTypes.join(','), (!IncludeTxClasses) ? String.Empty : IncludeTxClasses.join(','), (!ExcludeTxClasses) ? String.Empty : ExcludeTxClasses.join(',')));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistoryFiltered', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), IncludeTxTypes: IncludeTxTypes, ExcludeTxTypes: ExcludeTxTypes, IncludeTxClasses: IncludeTxClasses, ExcludeTxClasses: ExcludeTxClasses, pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistoryWithNumberOfRecords: function AccountService_AccountService$getBalanceHistoryWithNumberOfRecords(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistoryWithNumberOfRecords from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}] numberOfRecords=[{6}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistoryWithNumberOfRecords', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, numberOfRecords: numberOfRecords }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistoryFilteredWithNumberOfRecords: function AccountService_AccountService$getBalanceHistoryFilteredWithNumberOfRecords(successCallback, failureCallback, from, to, IncludeTxTypes, ExcludeTxTypes, IncludeTxClasses, ExcludeTxClasses, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistoryWithNumberOfRecords from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}] numberOfRecords=[{6}] inclideTxTypes=[{7}] excludeTXTypes =[{8}] includeTxClasses=[{9}] excludeTxClasses=[{10}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords, (!IncludeTxTypes) ? String.Empty : IncludeTxTypes.join(','), (!ExcludeTxTypes) ? String.Empty : ExcludeTxTypes.join(','), (!IncludeTxClasses) ? String.Empty : IncludeTxClasses.join(','), (!ExcludeTxClasses) ? String.Empty : ExcludeTxClasses.join(',')));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistoryFilteredWithNumberOfRecords', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), IncludeTxTypes: IncludeTxTypes, ExcludeTxTypes: ExcludeTxTypes, IncludeTxClasses: IncludeTxClasses, ExcludeTxClasses: ExcludeTxClasses, pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, numberOfRecords: numberOfRecords }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getAllowedPaymentTypes: function AccountService_AccountService$getAllowedPaymentTypes(successCallback, failureCallback, IDMDLanguage) {
        AccountService.AccountService._log$1.debug(String.format('GetAllowedPaymentTypes IDMDLanguage=[{0}]', IDMDLanguage));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetAllowedPaymentTypes', { IDMDLanguage: IDMDLanguage }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetAllowedPaymentTypes exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getRegisteredSettlementInstructions: function AccountService_AccountService$getRegisteredSettlementInstructions(successCallback, failureCallback, IDMMSITransactionType) {
        AccountService.AccountService._log$1.debug(String.format('GetRegisteredSettlementInstructions IDMMSITransactionType=[{0}]', IDMMSITransactionType));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetActivePaymentInstruments', { IDMMSITransactionType: IDMMSITransactionType }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetRegisteredSettlementInstructions exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getPaymentInstrument: function AccountService_AccountService$getPaymentInstrument(successCallback, failureCallback, IDMMSIInstruction) {
        AccountService.AccountService._log$1.debug(String.format('GetPaymentInstrument IDMMSIInstruction=[{0}]', IDMMSIInstruction));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPaymentInstrument', { IDMMSIInstruction: IDMMSIInstruction }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetPaymentInstrument exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getPaymentType: function AccountService_AccountService$getPaymentType(successCallback, failureCallback, IDMMSIType) {
        AccountService.AccountService._log$1.debug(String.format('GetPaymentType IDMMSIType=[{0}]', IDMMSIType));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPaymentType', { IDMMSIType: IDMMSIType }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetPaymentType exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerCard: function AccountService_AccountService$registerCard(successCallback, failureCallback, card) {
        AccountService.AccountService._log$1.debug(String.format('RegisterCard card=[{0}]', Framework.DictionaryUtil.dumpToString(card)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterCard', { card: card }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterCard exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerPPCard: function AccountService_AccountService$registerPPCard(successCallback, failureCallback, cardNumber, cardKey) {
        AccountService.AccountService._log$1.debug(String.format('RegisterPPCard cardNumber=[{0}] cardKey=[{1}]', cardNumber, cardKey));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterPPCard', { IDMDLanguage: this._environment.getLanguage(), cardNumber: cardNumber, cardKey: cardKey }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.fetchAccountsDetails();
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterPPCard exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerCheque: function AccountService_AccountService$registerCheque(successCallback, failureCallback, cheque) {
        AccountService.AccountService._log$1.debug(String.format('RegisterCheque cheque=[{0}]', Framework.DictionaryUtil.dumpToString(cheque)));
        if (!Object.keyExists(cheque, 'IDMMSIType')) {
            cheque['IDMMSIType'] = 'CHEQUE';
        }
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterCheque', { cheque: cheque }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterCheque exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerBankTransfer: function AccountService_AccountService$registerBankTransfer(successCallback, failureCallback, bankTransfer) {
        AccountService.AccountService._log$1.debug(String.format('RegisterBankTransfer bankTransfer=[{0}]', Framework.DictionaryUtil.dumpToString(bankTransfer)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterBankTransfer', { bankTransfer: bankTransfer }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterBankTransfer exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerRedirectBasedWallet: function AccountService_AccountService$registerRedirectBasedWallet(successCallback, failureCallback, redirectBasedWallet) {
        AccountService.AccountService._log$1.debug(String.format('RegisterRedirectBasedWallet redirectBasedWallet=[{0}]', Framework.DictionaryUtil.dumpToString(redirectBasedWallet)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterRedirectBasedWallet', { redirectBasedWallet: redirectBasedWallet }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterRedirectBasedWallet exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    updateCreditCardDetails: function AccountService_AccountService$updateCreditCardDetails(successCallback, failureCallback, creditCardUpdate) {
        AccountService.AccountService._log$1.debug(String.format('UpdateCreditCardDetails creditCardUpdate=[{0}]', Framework.DictionaryUtil.dumpToString(creditCardUpdate)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'UpdateCreditCardDetails', { creditCardUpdate: creditCardUpdate }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('UpdateCreditCardDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    beginSettlementInstructionTransaction: function AccountService_AccountService$beginSettlementInstructionTransaction(successCallback, failureCallback, password, IDMMSITransactionType, IDMMSIInstruction, amount, securityCode) {
        AccountService.AccountService._log$1.debug(String.format('BeginSettlementInstructionTransaction password=[{0}] IDMMSITransactionType=[{1}] IDMMSIInstruction=[{2}] amount=[{3}] securityCode=[{4}]', password, IDMMSITransactionType, IDMMSIInstruction, amount, securityCode));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'BeginPaymentTransaction', { password: password, IDMMSITransactionType: IDMMSITransactionType, IDMMSIInstruction: IDMMSIInstruction, amount: amount, securityCode: (String.isNullOrEmpty(securityCode)) ? null : securityCode }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('BeginSettlementInstructionTransaction exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    beginSettlementInstructionTransactionWithoutPassword: function AccountService_AccountService$beginSettlementInstructionTransactionWithoutPassword(successCallback, failureCallback, IDMMSITransactionType, IDMMSIInstruction, amount, securityCode) {
        AccountService.AccountService._log$1.debug(String.format('BeginSettlementInstructionTransactionWithoutPassword IDMMSITransactionType=[{0}] IDMMSIInstruction=[{1}] amount=[{2}] securityCode=[{3}]', IDMMSITransactionType, IDMMSIInstruction, amount, securityCode));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'BeginPaymentTransactionWithoutPassword', { IDMMSITransactionType: IDMMSITransactionType, IDMMSIInstruction: IDMMSIInstruction, amount: amount, securityCode: (String.isNullOrEmpty(securityCode)) ? null : securityCode }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('BeginSettlementInstructionTransaction exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getRBWRequest: function AccountService_AccountService$getRBWRequest(successCallback, failureCallback, IDMMSITXRequest, returnUrl, language, description) {
        AccountService.AccountService._log$1.debug(String.format('GetRBWRequest IDMMSITXRequest=[{0}] returnUrl=[{1}] language=[{2}] description=[{3}]', IDMMSITXRequest, returnUrl, language, description));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetRBWRequest', { IDMMSITXRequest: IDMMSITXRequest, returnUrl: returnUrl, language: language, description: description }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetRBWRequest exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getSettlementInstructionTransactionState: function AccountService_AccountService$getSettlementInstructionTransactionState(successCallback, failureCallback, IDMMSITXRequest) {
        AccountService.AccountService._log$1.debug(String.format('GetSettlementInstructionTransactionState IDMMSITXRequest=[{0}]', IDMMSITXRequest));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPaymentTransaction', { IDMMSITXRequest: IDMMSITXRequest }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            var isSuccess = (result)['IsSuccess'];
            var transactionState = (result)['IDMMSITransactionState'];
            if (isSuccess) {
                this.fetchAccountsDetails();
                this._fireDepositExecutedEvent$1();
            }
            else {
                if (transactionState === 'Q') {
                    this.fetchAccountsDetails();
                }
            }
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetSettlementInstructionTransactionState exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    _getDefaultPreferences$1: function AccountService_AccountService$_getDefaultPreferences$1() {
        return new AccountService.AccountPreferences(false, false, null, AccountService.AccountPreferences.dontSend, String.Empty, true);
    },
    
    _updateLocalPreferences$1: function AccountService_AccountService$_updateLocalPreferences$1(preferences) {
        if (!AccountService.AccountPreferences.equals(this._preferences$1, preferences)) {
            this._preferences$1 = preferences;
            this._fireAccountPreferencesChangedEvent$1();
        }
    },
    
    get_preferences: function AccountService_AccountService$get_preferences() {
        return this._preferences$1;
    },
    
    fetchPreferences: function AccountService_AccountService$fetchPreferences(successCallback, failureCallback) {
        AccountService.AccountService._log$1.debug('FetchPreferences');
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPreferences', {}, Delegate.create(this, function(result) {
            if (result) {
                if (successCallback) {
                    successCallback.invoke(result);
                }
                this._updateLocalPreferences$1(result);
            }
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetPreferences exception' + exception.message);
            if (failureCallback) {
                failureCallback.invoke(exception);
            }
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    setPreferences: function AccountService_AccountService$setPreferences(successCallback, failureCallback, preferences) {
        AccountService.AccountService._log$1.debug(String.format('SetPreferences preferences=[{0}]', Framework.DictionaryUtil.dumpObjectToString(preferences)));
        if (!AccountService.AccountPreferences.equals(this._preferences$1, preferences)) {
            this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'SetPreferences', { accountPreferences: preferences }, Delegate.create(this, function(result) {
                successCallback.invoke(null);
                this._updateLocalPreferences$1(preferences);
            }), Delegate.create(this, function(exception) {
                AccountService.AccountService._log$1.debug('SetPreferences exception' + exception.message);
                this._updateLocalPreferences$1(preferences);
                failureCallback.invoke(exception);
                this._userService$1.handleSessionTimeout(exception);
            }));
        }
        else {
            successCallback.invoke(null);
        }
    },
    
    setDepositLimit: function AccountService_AccountService$setDepositLimit(successCallback, failureCallback, IDMMPeriodUnit, limit) {
        AccountService.AccountService._log$1.debug(String.format('SetDepositLimit IDMMPeriodUnit=[{0}] limit=[{1}]', IDMMPeriodUnit, limit));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'SetDepositLimitOnPrimaryAccount', { IDMMPeriodUnit: IDMMPeriodUnit, limit: limit }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.fetchAccountsDetails();
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.error('SetDepositLimit', exception);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    }
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.AccountDetails

AccountService.AccountDetails = function AccountService_AccountDetails() {
}
AccountService.AccountDetails.equals = function AccountService_AccountDetails$equals(details1, details2) {
    if (!details1 && !details2) {
        return true;
    }
    if (!details1 && details2) {
        return false;
    }
    if (details1 && !details2) {
        return false;
    }
    if (details1.CurrentBalance !== details2.CurrentBalance) {
        return false;
    }
    if (details1.TradingBalance !== details2.TradingBalance) {
        return false;
    }
    if (details1.LockedFunds !== details2.LockedFunds) {
        return false;
    }
    if (details1.WithdrawalBalance !== details2.WithdrawalBalance) {
        return false;
    }
    if (details1.IsTestAccount !== details2.IsTestAccount) {
        return false;
    }
    if (details1.CurrencyDecimalPlaces !== details2.CurrencyDecimalPlaces) {
        return false;
    }
    if (details1.CurrencyHtmlNotation !== details2.CurrencyHtmlNotation) {
        return false;
    }
    if (details1.CurrencyNotation !== details2.CurrencyNotation) {
        return false;
    }
    return true;
}
AccountService.AccountDetails.equalsArray = function AccountService_AccountDetails$equalsArray(details1, details2) {
    if (!details1 && !details2) {
        return true;
    }
    if (!details1 && details2) {
        return false;
    }
    if (details1 && !details2) {
        return false;
    }
    if (details1.length !== details2.length) {
        return false;
    }
    for (var i = 0; i < details1.length; i++) {
        if (!AccountService.AccountDetails.equals(details1[i], details2[i])) {
            return false;
        }
    }
    return true;
}
AccountService.AccountDetails.prototype = {
    AccountNumber: null,
    CurrentBalance: null,
    IDMMAccount: null,
    IDMMAccountClass: null,
    IDMMCurrency: null,
    LockedFunds: null,
    TradingBalance: null,
    WithdrawalBalance: null,
    IDMMPeriodUnitDeposit: null,
    DepositLimitInPeriod: null,
    PendingIDMMPeriodUnitDeposit: null,
    PendingDepositLimit: null,
    TSPendingLimitActivation: null,
    IsTestAccount: null,
    CurrencyHtmlNotation: null,
    CurrencyNotation: null,
    CurrencyDecimalPlaces: 0
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.RedirectBasedWalletRequestParameter

AccountService.RedirectBasedWalletRequestParameter = function AccountService_RedirectBasedWalletRequestParameter() {
}
AccountService.RedirectBasedWalletRequestParameter.prototype = {
    Name: null,
    Value: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.PaymentType

AccountService.PaymentType = function AccountService_PaymentType() {
}
AccountService.PaymentType.prototype = {
    AccountNumberCaption: null,
    AccountNumberLengthMax: 0,
    AccountNumberLengthMin: 0,
    AddressLineLength: 0,
    ClearingCodeLengthMax: 0,
    ClearingCodeLengthMin: 0,
    IDMMSIAmountRule_Payment: null,
    IDMMSIAmountRule_Receipt: null,
    IDMMSICardType: null,
    IDMMSICheckAlgorithm: null,
    IDMMSIClass: null,
    IDMMSIType: null,
    IDMMTXType_BankCharge: null,
    IDMMTXType_Payment: null,
    IDMMTXType_Receipt: null,
    IsBankChargeSeparate: false,
    IsBankNameNeeded: false,
    IsCvv2Needed: false,
    IsForPayments: false,
    IsForReceipts: false,
    IsInstant: false,
    IsNotificationNeeded: false,
    IsPinNeeded: false,
    IsRestricted: false,
    IsStartOfValidityNeeded: false,
    IsSwiftCodeNeeded: false,
    IsSwitchNumberNeeded: false,
    IsUrgentRequestPossible: false,
    Name: null,
    NoOfAddressLines: 0,
    OwnerNameLengthMax: 0,
    PinCaption: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.PaymentTransaction

AccountService.PaymentTransaction = function AccountService_PaymentTransaction() {
}
AccountService.PaymentTransaction.prototype = {
    IDMMSITransaction: null,
    IDMMSITXRequest: null,
    IDMMCustomer: null,
    IDMMAccount: null,
    ExtAdditionalData: null,
    IDMMSITransactionType: null,
    IDMMSIType: null,
    IDMMSITransactionState: null,
    Description: null,
    ExtReference: null,
    OrderedAmount: null,
    IsTransient: false,
    IsSuccess: false,
    ShouldRedirect: false,
    ExtTime: null,
    ExtAuthCode: null,
    ExtAccountNumber: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.PaymentInstrument

AccountService.PaymentInstrument = function AccountService_PaymentInstrument() {
}
AccountService.PaymentInstrument.prototype = {
    AccountOwner: null,
    Address: null,
    City: null,
    DisplayLabel: null,
    IDMMCountry: null,
    IDMMSIClass: null,
    IDMMSIInstruction: null,
    IDMMSIType: null,
    InactivityReason: null,
    IsActive: false,
    IsDefaultForPayments: false,
    IsDefaultForReceipts: false,
    IsForPayments: false,
    IsForReceipts: false,
    IsRedirectBasedWallet: false,
    IsSameAsMainAddress: false,
    IsUrgentByDefault: false,
    MMSITypeName: null,
    PaymentDailyLimit: null,
    PaymentTXLimit: null,
    Postcode: null,
    ReceiptDailyLimit: null,
    ReceiptTXLimit: null,
    State: null,
    VerificationStatus: 0,
    EndOfValidityYear: null,
    EndOfValidityMonth: null,
    StartOfValidityYear: null,
    StartOfValidityMonth: null,
    CardIssueNumber: null,
    IsCVV2Needed: false
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.RedirectBasedWalletRequest

AccountService.RedirectBasedWalletRequest = function AccountService_RedirectBasedWalletRequest() {
}
AccountService.RedirectBasedWalletRequest.prototype = {
    IsPost: false,
    Parameters: null,
    Url: null,
    UrlWithParameters: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.SettlementInstructionTransactionStates

AccountService.SettlementInstructionTransactionStates = function AccountService_SettlementInstructionTransactionStates() {
}


AccountService.AccountPreferences.createClass('AccountService.AccountPreferences');
AccountService.AccountService.createClass('AccountService.AccountService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
AccountService.AccountDetails.createClass('AccountService.AccountDetails');
AccountService.RedirectBasedWalletRequestParameter.createClass('AccountService.RedirectBasedWalletRequestParameter');
AccountService.PaymentType.createClass('AccountService.PaymentType');
AccountService.PaymentTransaction.createClass('AccountService.PaymentTransaction');
AccountService.PaymentInstrument.createClass('AccountService.PaymentInstrument');
AccountService.RedirectBasedWalletRequest.createClass('AccountService.RedirectBasedWalletRequest');
AccountService.SettlementInstructionTransactionStates.createClass('AccountService.SettlementInstructionTransactionStates');
AccountService.AccountPreferences.plainText = 'PLAIN';
AccountService.AccountPreferences.html = 'HTML';
AccountService.AccountPreferences.dontSend = 'NOSEND';
AccountService.AccountPreferences.defaultType = null;
AccountService.AccountService._serviceName$1 = 'AccountService';
AccountService.AccountService._log$1 = Framework.Logger.getLog(AccountService.AccountService._serviceName$1);
AccountService.SettlementInstructionTransactionStates.enqueued = 'Q';
AccountService.SettlementInstructionTransactionStates.authorised = 'A';
AccountService.SettlementInstructionTransactionStates.cancelled = 'C';
AccountService.SettlementInstructionTransactionStates.sentToExecution = 'S';
AccountService.SettlementInstructionTransactionStates.executedSuccessfully = 'X';
AccountService.SettlementInstructionTransactionStates.failed = 'F';
AccountService.SettlementInstructionTransactionStates.inDoubt = 'D';
AccountService.SettlementInstructionTransactionStates.referral = 'R';
AccountService.SettlementInstructionTransactionStates.successfullyExecutedManually = 'M';
AccountService.SettlementInstructionTransactionStates.reconciledAsAuthorised = '+';
AccountService.SettlementInstructionTransactionStates.reconciledAsDeclined = '-';
AccountService.SettlementInstructionTransactionStates.referralRejectedByTheOperator = 'L';
AccountService.SettlementInstructionTransactionStates.referralConfirmedByTheOperator = 'O';
AccountService.SettlementInstructionTransactionStates.failedAfterReferral = 'J';
AccountService.SettlementInstructionTransactionStates.queryingTheOutcomeOfTheTransaction = '?';
AccountService.SettlementInstructionTransactionStates.waitingForThe2ndAuthorisation = '2';
AccountService.SettlementInstructionTransactionStates.referredBecauseRisky = 'Y';
AccountService.SettlementInstructionTransactionStates.successfulFundsNotReleased = 'H';
AccountService.SettlementInstructionTransactionStates.failedFundsNotReleased = 'E';
AccountService.SettlementInstructionTransactionStates.readyForNotification = 'W';
AccountService.SettlementInstructionTransactionStates.notificationInProgress = 'N';
AccountService.SettlementInstructionTransactionStates.readyForRedirection = 'W';
AccountService.SettlementInstructionTransactionStates.inRedirection = 'I';
AccountService.SettlementInstructionTransactionStates.verifying = 'V';
AccountService.SettlementInstructionTransactionStates.reversed = 'Z';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('FixedOddsBettingService');

////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.IBetPlacementStateChangedListener

FixedOddsBettingService.IBetPlacementStateChangedListener = function() { };
FixedOddsBettingService.IBetPlacementStateChangedListener.prototype = {
    onBetPlacementStateChanged : null
}
FixedOddsBettingService.IBetPlacementStateChangedListener.createInterface('FixedOddsBettingService.IBetPlacementStateChangedListener');


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.IBettingPreferencesChangedListener

FixedOddsBettingService.IBettingPreferencesChangedListener = function() { };
FixedOddsBettingService.IBettingPreferencesChangedListener.prototype = {
    onBettingPreferencesChanged : null
}
FixedOddsBettingService.IBettingPreferencesChangedListener.createInterface('FixedOddsBettingService.IBettingPreferencesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.OverrideToShowConfirmation

FixedOddsBettingService.OverrideToShowConfirmation = function() { };
FixedOddsBettingService.OverrideToShowConfirmation.prototype = {
    overrideToShowConfirmation: 1, 
    overrideToNotShowConfirmation: 2, 
    notOverride: 3
}
FixedOddsBettingService.OverrideToShowConfirmation.createEnum('FixedOddsBettingService.OverrideToShowConfirmation', false);


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.IOddsTypeChangedListener

FixedOddsBettingService.IOddsTypeChangedListener = function() { };
FixedOddsBettingService.IOddsTypeChangedListener.prototype = {
    onOddsTypeChanged : null
}
FixedOddsBettingService.IOddsTypeChangedListener.createInterface('FixedOddsBettingService.IOddsTypeChangedListener');


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetPlacementState

FixedOddsBettingService.BetPlacementState = function FixedOddsBettingService_BetPlacementState() {
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetTerminatedState

FixedOddsBettingService.BetTerminatedState = function FixedOddsBettingService_BetTerminatedState() {
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.CalculatedBet

FixedOddsBettingService.CalculatedBet = function FixedOddsBettingService_CalculatedBet(potentialReturn, totalStake, unitCount, IDFOBetType) {
    this.PotentialReturn = potentialReturn;
    this.TotalStake = totalStake;
    this.UnitCount = unitCount;
    this.IDFOBetType = IDFOBetType;
}
FixedOddsBettingService.CalculatedBet.equals = function FixedOddsBettingService_CalculatedBet$equals(calculatedBet1, calculatedBet2) {
    if (!calculatedBet1) {
        return !calculatedBet2;
    }
    else if (!calculatedBet2) {
        return false;
    }
    if (calculatedBet1.PotentialReturn !== calculatedBet2.PotentialReturn) {
        return false;
    }
    if (calculatedBet1.TotalStake !== calculatedBet2.TotalStake) {
        return false;
    }
    if (calculatedBet1.IDFOBetType !== calculatedBet2.IDFOBetType) {
        return false;
    }
    if (calculatedBet1.UnitCount !== calculatedBet2.UnitCount) {
        return false;
    }
    return true;
}
FixedOddsBettingService.CalculatedBet.prototype = {
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: 0,
    IDFOBetType: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetInbound

FixedOddsBettingService.BetInbound = function FixedOddsBettingService_BetInbound(betLegs, IDFOBetType, betTypeName, IDFOMultiRacePool, isPool, winStake, placeStake, showStake) {
    this.BetLegs = [];
    this.BetLegs = betLegs;
    this.IDFOBetType = IDFOBetType;
    this.BetTypeName = betTypeName;
    this.IDFOMultiRacePool = IDFOMultiRacePool;
    this.IsPool = isPool;
    this.WinStake = winStake;
    this.PlaceStake = placeStake;
    this.ShowStake = showStake;
}
FixedOddsBettingService.BetInbound.prototype = {
    IDFOBetType: null,
    BetTypeName: null,
    IDFOMultiRacePool: null,
    IsPool: false,
    WinStake: null,
    PlaceStake: null,
    ShowStake: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetLeg

FixedOddsBettingService.BetLeg = function FixedOddsBettingService_BetLeg(handicap, upperBand, lowerBand, IDFOPriceType, IDFOSelection, priceDown, priceUp, eachWayReduction, eachWayPlaceTerms, isTrap, systemTag, interrelationTag, IDFOEventScorecast) {
    this.Handicap = handicap;
    this.UpperBand = upperBand;
    this.LowerBand = lowerBand;
    this.IDFOPriceType = IDFOPriceType;
    this.IDFOSelection = IDFOSelection;
    this.PriceDown = priceDown;
    this.PriceUp = priceUp;
    this.EachWayReduction = eachWayReduction;
    this.EachWayPlaceTerms = eachWayPlaceTerms;
    this.IsTrap = isTrap;
    this.SystemTag = systemTag;
    this.InterrelationTag = interrelationTag;
    this.IDFOEventScorecast = IDFOEventScorecast;
}
FixedOddsBettingService.BetLeg.createFromSelection = function FixedOddsBettingService_BetLeg$createFromSelection(selection, systemTag, interrelationTag) {
    return new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, selection.PriceDown, selection.PriceUp, selection.EachWayReduction[selection.ActiveEachWay], selection.EachWayPlaceTerms[selection.ActiveEachWay], selection.IsTrap, systemTag, interrelationTag, selection.IDFOEventScorecast);
}
FixedOddsBettingService.BetLeg.create = function FixedOddsBettingService_BetLeg$create(betLeg) {
    return new FixedOddsBettingService.BetLeg(betLeg.Handicap, betLeg.UpperBand, betLeg.LowerBand, betLeg.IDFOPriceType, betLeg.IDFOSelection, betLeg.PriceDown, betLeg.PriceUp, betLeg.EachWayReduction, betLeg.EachWayPlaceTerms, betLeg.IsTrap, betLeg.SystemTag, betLeg.InterrelationTag, betLeg.IDFOEventScorecast);
}
FixedOddsBettingService.BetLeg.prototype = {
    Handicap: null,
    UpperBand: null,
    LowerBand: null,
    IDFOPriceType: null,
    IDFOSelection: null,
    PriceDown: null,
    PriceUp: null,
    EachWayReduction: null,
    EachWayPlaceTerms: null,
    IsTrap: false,
    SystemTag: null,
    InterrelationTag: null,
    IDFOEventScorecast: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetSlipInbound

FixedOddsBettingService.BetSlipInbound = function FixedOddsBettingService_BetSlipInbound(isFree, bets) {
    this.Bets = [];
    this.IsFree = isFree;
    this.Bets = bets;
}
FixedOddsBettingService.BetSlipInbound.prototype = {
    IsFree: false
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetSlipOutbound

FixedOddsBettingService.BetSlipOutbound = function FixedOddsBettingService_BetSlipOutbound() {
}
FixedOddsBettingService.BetSlipOutbound.prototype = {
    Bets: null,
    IsFree: false,
    IDFOBetSlip: null,
    ExternalReference: null,
    Status: null,
    TopupAmount: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetOutbound

FixedOddsBettingService.BetOutbound = function FixedOddsBettingService_BetOutbound() {
    this.BetLegs = [];
}
FixedOddsBettingService.BetOutbound.prototype = {
    IDFOBetType: null,
    IDFOMultiRacePool: null,
    IsPool: false,
    WinStake: null,
    PlaceStake: null,
    ShowStake: null,
    ExternalReference: null,
    MaxTakeout: null,
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: 0
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetType

FixedOddsBettingService.BetType = function FixedOddsBettingService_BetType() {
}
FixedOddsBettingService.BetType.prototype = {
    IDFOBetType: null,
    Name: null,
    IsEachWayAllowed: false
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetSlipStatus

FixedOddsBettingService.BetSlipStatus = function FixedOddsBettingService_BetSlipStatus() {
}
FixedOddsBettingService.BetSlipStatus.isConfirmationRequired = function FixedOddsBettingService_BetSlipStatus$isConfirmationRequired(betSlipStatus) {
    return betSlipStatus.State === 1;
}
FixedOddsBettingService.BetSlipStatus.isPreProcess = function FixedOddsBettingService_BetSlipStatus$isPreProcess(betSlipStatus) {
    return !betSlipStatus.DetailedState;
}
FixedOddsBettingService.BetSlipStatus.isAccepted = function FixedOddsBettingService_BetSlipStatus$isAccepted(betSlipStatus) {
    return betSlipStatus.State === 2;
}
FixedOddsBettingService.BetSlipStatus.isAcceptable = function FixedOddsBettingService_BetSlipStatus$isAcceptable(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.acceptable);
}
FixedOddsBettingService.BetSlipStatus.isRejected = function FixedOddsBettingService_BetSlipStatus$isRejected(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.rejected);
}
FixedOddsBettingService.BetSlipStatus.isPriceChanged = function FixedOddsBettingService_BetSlipStatus$isPriceChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.priceChanged);
}
FixedOddsBettingService.BetSlipStatus.isHandicapChanged = function FixedOddsBettingService_BetSlipStatus$isHandicapChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.handicapChanged);
}
FixedOddsBettingService.BetSlipStatus.isBandChanged = function FixedOddsBettingService_BetSlipStatus$isBandChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.bandChanged);
}
FixedOddsBettingService.BetSlipStatus.isReoffered = function FixedOddsBettingService_BetSlipStatus$isReoffered(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.reoffered);
}
FixedOddsBettingService.BetSlipStatus.isReofferTimeout = function FixedOddsBettingService_BetSlipStatus$isReofferTimeout(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.reofferTimeout);
}
FixedOddsBettingService.BetSlipStatus.isTopupRequired = function FixedOddsBettingService_BetSlipStatus$isTopupRequired(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.topupRequired);
}
FixedOddsBettingService.BetSlipStatus.isMaxTakeoutViolation = function FixedOddsBettingService_BetSlipStatus$isMaxTakeoutViolation(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.maxTakeoutViolation);
}
FixedOddsBettingService.BetSlipStatus.isWaiting = function FixedOddsBettingService_BetSlipStatus$isWaiting(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.waiting);
}
FixedOddsBettingService.BetSlipStatus.isEachWayChanged = function FixedOddsBettingService_BetSlipStatus$isEachWayChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.eachWayChanged);
}
FixedOddsBettingService.BetSlipStatus.isAbortProcessing = function FixedOddsBettingService_BetSlipStatus$isAbortProcessing(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.abortProcessing);
}
FixedOddsBettingService.BetSlipStatus.isSecurityCodeRequiredForTopup = function FixedOddsBettingService_BetSlipStatus$isSecurityCodeRequiredForTopup(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.securityCodeRequiredForTopup);
}
FixedOddsBettingService.BetSlipStatus.prototype = {
    State: 0,
    DetailedState: 0,
    StatusCode: null,
    StatusText: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetTypesAndReturns

FixedOddsBettingService.BetTypesAndReturns = function FixedOddsBettingService_BetTypesAndReturns() {
    this.AllowedBetTypes = [];
    this.PotentialReturns = new FixedOddsBettingService.PotentialReturn();
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.PotentialReturn

FixedOddsBettingService.PotentialReturn = function FixedOddsBettingService_PotentialReturn() {
    this.PerBetType = {};
    this.PerSelection = {};
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.PriceType

FixedOddsBettingService.PriceType = function FixedOddsBettingService_PriceType() {
}
FixedOddsBettingService.PriceType.getValidPriceTypesForSingle = function FixedOddsBettingService_PriceType$getValidPriceTypesForSingle() {
    return FixedOddsBettingService.PriceType._validPriceTypesForSingle;
}
FixedOddsBettingService.PriceType.isValidForSingle = function FixedOddsBettingService_PriceType$isValidForSingle(IDFOPriceType) {
    return FixedOddsBettingService.PriceType._validPriceTypesForSingle.contains(IDFOPriceType);
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.FixedOddsBettingPreferences

FixedOddsBettingService.FixedOddsBettingPreferences = function FixedOddsBettingService_FixedOddsBettingPreferences(oddsType, isBetConfirmationScreenShownBeforePlacement, isBetConfirmationScreenShownAfterPlacement, isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted) {
    this.OddsType = oddsType;
    this.IsBetConfirmationScreenShownBeforePlacement = isBetConfirmationScreenShownBeforePlacement;
    this.IsBetConfirmationScreenShownAfterPlacement = isBetConfirmationScreenShownAfterPlacement;
    this.IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted = isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted;
}
FixedOddsBettingService.FixedOddsBettingPreferences.equals = function FixedOddsBettingService_FixedOddsBettingPreferences$equals(preferences1, preferences2) {
    if (!preferences1 && !preferences2) {
        return true;
    }
    if (!preferences1 && preferences2) {
        return false;
    }
    if (preferences1 && !preferences2) {
        return false;
    }
    if (!String.equals(preferences1.OddsType, preferences2.OddsType, true)) {
        return false;
    }
    if (preferences1.IsBetConfirmationScreenShownBeforePlacement !== preferences2.IsBetConfirmationScreenShownBeforePlacement) {
        return false;
    }
    if (preferences1.IsBetConfirmationScreenShownAfterPlacement !== preferences2.IsBetConfirmationScreenShownAfterPlacement) {
        return false;
    }
    if (preferences1.IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted !== preferences2.IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted) {
        return false;
    }
    if (preferences1.BetGracePeriod !== preferences2.BetGracePeriod) {
        return false;
    }
    return true;
}
FixedOddsBettingService.FixedOddsBettingPreferences.isOddsTypeValid = function FixedOddsBettingService_FixedOddsBettingPreferences$isOddsTypeValid(oddsType) {
    if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.american, oddsType, true) || String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.decimals, oddsType, true) || String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.fractions, oddsType, true)) {
        return true;
    }
    return false;
}
FixedOddsBettingService.FixedOddsBettingPreferences.prototype = {
    OddsType: null,
    IsBetConfirmationScreenShownBeforePlacement: false,
    IsBetConfirmationScreenShownAfterPlacement: false,
    IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted: false,
    BetGracePeriod: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.FixedOddsBettingService

FixedOddsBettingService.FixedOddsBettingService = function FixedOddsBettingService_FixedOddsBettingService() {
    this._areasWhereBetPlacementStays$1 = [ 'betting' ];
    this._betPlacementStateChangedListeners$1 = new Framework.ListenerInvoker(false);
    this._oddsTypeChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._bettingPreferencesChangedListeners$1 = new Framework.ListenerInvoker(true);
    FixedOddsBettingService.FixedOddsBettingService.constructBase(this);
    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('ctor');
}
FixedOddsBettingService.FixedOddsBettingService.adjustBetSlipCalculationsForFreeBet = function FixedOddsBettingService_FixedOddsBettingService$adjustBetSlipCalculationsForFreeBet(betSlipCalculation, isFree) {
    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('AdjustBetSlipCalculationsForFreeBet');
    if (isFree) {
        FixedOddsBettingService.FixedOddsBettingService._adjustCalculatedBetDictionary$1(betSlipCalculation.PerSelection);
        FixedOddsBettingService.FixedOddsBettingService._adjustCalculatedBetDictionary$1(betSlipCalculation.PerBetType);
    }
    return betSlipCalculation;
}
FixedOddsBettingService.FixedOddsBettingService._adjustCalculatedBetDictionary$1 = function FixedOddsBettingService_FixedOddsBettingService$_adjustCalculatedBetDictionary$1(calculatedBets) {
    var $dict1 = calculatedBets;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        var calculation = entry.value;
        if (calculation.PotentialReturn > 0) {
            calculation.PotentialReturn -= calculation.TotalStake;
        }
    }
}
FixedOddsBettingService.FixedOddsBettingService._adjustBetSlipOutboundForFreeBet$1 = function FixedOddsBettingService_FixedOddsBettingService$_adjustBetSlipOutboundForFreeBet$1(betSlipOutbound, isFree) {
    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('AdjustBetSlipOutboundForFreeBet');
    if (isFree) {
        for (var i = 0; i < betSlipOutbound.Bets.length; i++) {
            betSlipOutbound.Bets[i].PotentialReturn -= betSlipOutbound.Bets[i].WinStake + (betSlipOutbound.Bets[i].PlaceStake || 0);
        }
    }
    return betSlipOutbound;
}
FixedOddsBettingService.FixedOddsBettingService._getSimpleSelectionKey$1 = function FixedOddsBettingService_FixedOddsBettingService$_getSimpleSelectionKey$1(IDFOSelection) {
    return IDFOSelection.toString();
}
FixedOddsBettingService.FixedOddsBettingService._getScorecastSelectionKey$1 = function FixedOddsBettingService_FixedOddsBettingService$_getScorecastSelectionKey$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
    return String.format('{0}-{1}-{2}', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
}
FixedOddsBettingService.FixedOddsBettingService._getSelectionKey$1 = function FixedOddsBettingService_FixedOddsBettingService$_getSelectionKey$1(selection) {
    return (!selection.IDFOEventScorecast) ? FixedOddsBettingService.FixedOddsBettingService._getSimpleSelectionKey$1(selection.IDFOSelection) : FixedOddsBettingService.FixedOddsBettingService._getScorecastSelectionKey$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS);
}
FixedOddsBettingService.FixedOddsBettingService.prototype = {
    _isBetConfirmationScreenShownBeforePlacementOverride$1: 0,
    _isSecondConfirmation$1: false,
    _selections$1: null,
    
    get_selections: function FixedOddsBettingService_FixedOddsBettingService$get_selections() {
        return this._selections$1;
    },
    
    _betSlipCalculation$1: null,
    
    get_betSlipCalculation: function FixedOddsBettingService_FixedOddsBettingService$get_betSlipCalculation() {
        return this._betSlipCalculation$1;
    },
    
    _betSlipInbound$1: null,
    
    get_betSlip: function FixedOddsBettingService_FixedOddsBettingService$get_betSlip() {
        return this._betSlipInbound$1;
    },
    
    _betSlipOutbound$1: null,
    
    get_betSlipOutbound: function FixedOddsBettingService_FixedOddsBettingService$get_betSlipOutbound() {
        return this._betSlipOutbound$1;
    },
    
    _betPlacementState$1: 0,
    
    get_betPlacementState: function FixedOddsBettingService_FixedOddsBettingService$get_betPlacementState() {
        return this._betPlacementState$1;
    },
    
    _betTerminatedState$1: 0,
    
    get_betTerminatedState: function FixedOddsBettingService_FixedOddsBettingService$get_betTerminatedState() {
        return this._betTerminatedState$1;
    },
    
    _gracePeriodRemaining$1: null,
    
    get_gracePeriodRemaining: function FixedOddsBettingService_FixedOddsBettingService$get_gracePeriodRemaining() {
        return this._gracePeriodRemaining$1 || 0;
    },
    
    decreaseGracePeriodRemaining: function FixedOddsBettingService_FixedOddsBettingService$decreaseGracePeriodRemaining() {
        this._gracePeriodRemaining$1--;
    },
    
    _getState$1: function FixedOddsBettingService_FixedOddsBettingService$_getState$1() {
        return { preferences: this._preferences$1, selections: this._selections$1, betSlipCalculation: this._betSlipCalculation$1, betSlipInbound: this._betSlipInbound$1, betSlipOutbound: this._betSlipOutbound$1, betPlacementState: this._betPlacementState$1, betTerminatedState: this._betTerminatedState$1, isSecondConfirmation: this._isSecondConfirmation$1, gracePeriodRemaining: this._gracePeriodRemaining$1, isBetConfirmationScreenShownBeforePlacementOverride: this._isBetConfirmationScreenShownBeforePlacementOverride$1 };
    },
    
    _setState$1: function FixedOddsBettingService_FixedOddsBettingService$_setState$1(state) {
        this._preferences$1 = state['preferences'];
        this._selections$1 = state['selections'];
        this._betSlipCalculation$1 = state['betSlipCalculation'];
        this._betSlipInbound$1 = state['betSlipInbound'];
        this._betSlipOutbound$1 = state['betSlipOutbound'];
        this._betPlacementState$1 = state['betPlacementState'];
        this._betTerminatedState$1 = state['betTerminatedState'];
        this._isSecondConfirmation$1 = state['isSecondConfirmation'];
        this._gracePeriodRemaining$1 = state['gracePeriodRemaining'];
        this._isBetConfirmationScreenShownBeforePlacementOverride$1 = state['isBetConfirmationScreenShownBeforePlacementOverride'];
    },
    
    _updateBetPlacementState$1: function FixedOddsBettingService_FixedOddsBettingService$_updateBetPlacementState$1(betPlacementState, fireBetPlacementStateChangedEventUnconditionally, betTerminatedState) {
        this._betTerminatedState$1 = (betPlacementState === FixedOddsBettingService.BetPlacementState.rejected && betTerminatedState === FixedOddsBettingService.BetTerminatedState.notApplicableState) ? ((String.isNullOrEmpty(this._betSlipOutbound$1.Status.StatusText)) ? FixedOddsBettingService.BetTerminatedState.generalRejection : FixedOddsBettingService.BetTerminatedState.displayStatusRejection) : betTerminatedState;
        if (this._betPlacementState$1 !== betPlacementState) {
            this._betPlacementState$1 = betPlacementState;
            this._fireBetPlacementStateChangedEvent$1(this._betPlacementState$1);
        }
        else if (fireBetPlacementStateChangedEventUnconditionally) {
            this._fireBetPlacementStateChangedEvent$1(this._betPlacementState$1);
        }
    },
    
    _checkIfBetRejectedButStillValid$1: function FixedOddsBettingService_FixedOddsBettingService$_checkIfBetRejectedButStillValid$1() {
        if (this._betSlipOutbound$1.Status.State === FixedOddsBettingService.BetPlacementState.rejected && !FixedOddsBettingService.BetSlipStatus.isAbortProcessing(this._betSlipOutbound$1.Status) && !FixedOddsBettingService.BetSlipStatus.isMaxTakeoutViolation(this._betSlipOutbound$1.Status) && !FixedOddsBettingService.BetSlipStatus.isReofferTimeout(this._betSlipOutbound$1.Status) && this._betSlipOutbound$1.Status.DetailedState !== FixedOddsBettingService.BetSlipStatus.rejected) {
            return true;
        }
        return false;
    },
    
    _adjustBetSlipCalculation$1: function FixedOddsBettingService_FixedOddsBettingService$_adjustBetSlipCalculation$1() {
        for (var i = 0; i < this._betSlipOutbound$1.Bets.length; i++) {
            this._betSlipCalculation$1[i].TotalStake = this._betSlipOutbound$1.Bets[i].TotalStake;
            this._betSlipCalculation$1[i].PotentialReturn = this._betSlipOutbound$1.Bets[i].PotentialReturn;
        }
    },
    
    _adjustBetSlipInbound$1: function FixedOddsBettingService_FixedOddsBettingService$_adjustBetSlipInbound$1() {
        for (var i = 0; i < this._betSlipOutbound$1.Bets.length; i++) {
            this._betSlipInbound$1.Bets[i].PlaceStake = this._betSlipOutbound$1.Bets[i].PlaceStake;
            this._betSlipInbound$1.Bets[i].WinStake = this._betSlipOutbound$1.Bets[i].WinStake;
            this._betSlipInbound$1.Bets[i].ShowStake = this._betSlipOutbound$1.Bets[i].ShowStake;
            for (var j = 0; j < this._betSlipOutbound$1.Bets[i].BetLegs.length; j++) {
                if (!this._betSlipInbound$1.Bets[i].BetLegs[j].IDFOEventScorecast) {
                    var selection = this._selections$1[FixedOddsBettingService.FixedOddsBettingService._getSimpleSelectionKey$1(this._betSlipInbound$1.Bets[i].BetLegs[j].IDFOSelection)];
                    if (this._betSlipInbound$1.Bets[i].BetLegs[j].UpperBand !== this._betSlipOutbound$1.Bets[i].BetLegs[j].UpperBand) {
                        selection.SelectionName = selection.SelectionName.replace(this._betSlipInbound$1.Bets[i].BetLegs[j].UpperBand.toString(), this._betSlipOutbound$1.Bets[i].BetLegs[j].UpperBand.toString());
                    }
                    if (this._betSlipInbound$1.Bets[i].BetLegs[j].LowerBand !== this._betSlipOutbound$1.Bets[i].BetLegs[j].LowerBand) {
                        selection.SelectionName = selection.SelectionName.replace(this._betSlipInbound$1.Bets[i].BetLegs[j].LowerBand.toString(), this._betSlipOutbound$1.Bets[i].BetLegs[j].LowerBand.toString());
                    }
                }
                var betLeg = FixedOddsBettingService.BetLeg.create(this._betSlipOutbound$1.Bets[i].BetLegs[j]);
                this._betSlipInbound$1.Bets[i].BetLegs[j] = betLeg;
            }
        }
    },
    
    onPageWillChange: function FixedOddsBettingService_FixedOddsBettingService$onPageWillChange() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('OnPageWillChange');
        this._environment.storeState(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, this._getState$1());
    },
    
    _accountService$1: null,
    
    setAccountService: function FixedOddsBettingService_FixedOddsBettingService$setAccountService(accountService) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetAccountService');
        this._accountService$1 = accountService;
    },
    
    _navigationService$1: null,
    
    setNavigationService: function FixedOddsBettingService_FixedOddsBettingService$setNavigationService(navigationService) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    _userService$1: null,
    
    setUserService: function FixedOddsBettingService_FixedOddsBettingService$setUserService(userService) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetUserService');
        this._userService$1 = userService;
        this._userService$1.registerUserChangedListener(this);
    },
    
    onUserChanged: function FixedOddsBettingService_FixedOddsBettingService$onUserChanged(eventSource) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('OnUserChanged');
        if (this._userService$1.isLoggedIn()) {
            this.fetchPreferences();
        }
    },
    
    init: function FixedOddsBettingService_FixedOddsBettingService$init(environment, parameters) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        FixedOddsBettingService.FixedOddsBettingService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(FixedOddsBettingService.FixedOddsBettingService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
        else {
            var oddsType = FixedOddsBettingService.FixedOddsBettingPreferences.fractions;
            var isBetConfirmationScreenShownBeforePlacement = true;
            var isBetConfirmationScreenShownAfterPlacement = true;
            var isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted = false;
            if (!String.isNullOrEmpty(parameters['default-odds-type'])) {
                oddsType = parameters['default-odds-type'];
            }
            if (!String.isNullOrEmpty(parameters['is-bet-confirmation-screen-shown-before-placement'])) {
                isBetConfirmationScreenShownBeforePlacement = Boolean.parse(parameters['is-bet-confirmation-screen-shown-before-placement']);
            }
            if (!String.isNullOrEmpty(parameters['is-bet-confirmation-screen-shown-after-placement'])) {
                isBetConfirmationScreenShownAfterPlacement = Boolean.parse(parameters['is-bet-confirmation-screen-shown-after-placement']);
            }
            if (!String.isNullOrEmpty(parameters['is-reoffer-for-bets-with-in-running-selections-automatically-accepted'])) {
                isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted = Boolean.parse(parameters['is-reoffer-for-bets-with-in-running-selections-automatically-accepted']);
            }
            this._preferences$1 = new FixedOddsBettingService.FixedOddsBettingPreferences(oddsType, isBetConfirmationScreenShownAfterPlacement, isBetConfirmationScreenShownAfterPlacement, isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted);
        }
        if (!String.isNullOrEmpty(parameters['areas-where-bet-placement-stays'])) {
            this._areasWhereBetPlacementStays$1 = parameters['areas-where-bet-placement-stays'].toString().toLowerCase().split(',');
        }
    },
    
    start: function FixedOddsBettingService_FixedOddsBettingService$start() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('Start');
        if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.start) {
            this._startInternalPlaceBetSlip$1();
        }
    },
    
    registerBetPlacementStateChangedListener: function FixedOddsBettingService_FixedOddsBettingService$registerBetPlacementStateChangedListener(betPlacementStateChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RegisterBetPlacementStateChangedListener');
        this._betPlacementStateChangedListeners$1.registerListener(betPlacementStateChangedListener);
    },
    
    unregisterBetPlacementStateChangedListener: function FixedOddsBettingService_FixedOddsBettingService$unregisterBetPlacementStateChangedListener(betPlacementStateChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('UnregisterBetPlacementStateChangedListener');
        this._betPlacementStateChangedListeners$1.unregisterListener(betPlacementStateChangedListener);
    },
    
    _fireBetPlacementStateChangedEvent$1: function FixedOddsBettingService_FixedOddsBettingService$_fireBetPlacementStateChangedEvent$1(placementState) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FireBetPlacementStateChangedEvent');
        this._betPlacementStateChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBetPlacementStateChanged();
        }));
    },
    
    registerOddsTypeChangedListener: function FixedOddsBettingService_FixedOddsBettingService$registerOddsTypeChangedListener(oddsTypeChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RegisterOddsTypeChangedListener');
        this._oddsTypeChangedListeners$1.registerListener(oddsTypeChangedListener);
    },
    
    unregisterOddsTypeChangedListener: function FixedOddsBettingService_FixedOddsBettingService$unregisterOddsTypeChangedListener(oddsTypeChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('UnregisterOddsTypeChangedListener');
        this._oddsTypeChangedListeners$1.unregisterListener(oddsTypeChangedListener);
    },
    
    _fireOddsTypeChangedEvent$1: function FixedOddsBettingService_FixedOddsBettingService$_fireOddsTypeChangedEvent$1() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FireOddsTypeChangedEvent');
        this._oddsTypeChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onOddsTypeChanged(this);
        }));
    },
    
    registerBettingPreferencesChangedListener: function FixedOddsBettingService_FixedOddsBettingService$registerBettingPreferencesChangedListener(bettingPreferencesChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RegisterBettingPreferencesChangedListener');
        this._bettingPreferencesChangedListeners$1.registerListener(bettingPreferencesChangedListener);
    },
    
    unregisterBettingPreferencesChangedListener: function FixedOddsBettingService_FixedOddsBettingService$unregisterBettingPreferencesChangedListener(bettingPreferencesChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('UnregisterBettingPreferencesChangedListener');
        this._bettingPreferencesChangedListeners$1.unregisterListener(bettingPreferencesChangedListener);
    },
    
    _fireBettingPreferencesChangedEvent$1: function FixedOddsBettingService_FixedOddsBettingService$_fireBettingPreferencesChangedEvent$1() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FireBettingPreferencesChangedEvent');
        this._bettingPreferencesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBettingPreferencesChanged();
        }));
    },
    
    getBetHistoryDetails: function FixedOddsBettingService_FixedOddsBettingService$getBetHistoryDetails(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, betStateTypes, betOutcomeTypes) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('GetBetHistoryDetails from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}] betStateTypes=[{6}] betOutcomeTypes=[{7}]', from, to, pageNumber, pageSize, orderBy, orderDesc, betStateTypes, betOutcomeTypes));
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetBetHistoryDetails', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, betStateTypes: betStateTypes, betOutcomeTypes: betOutcomeTypes }, successCallback, Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetBetHistoryDetails exception' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBetHistoryDetailsWithNumberOfRecords: function FixedOddsBettingService_FixedOddsBettingService$getBetHistoryDetailsWithNumberOfRecords(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, betStateTypes, betOutcomeTypes, numberOfRecords) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('GetBetHistoryDetailsWithNumberOfRecords  pageNumber=[{0}] pageSize=[{1}] orderBy=[{2}] orderDesc=[{3}] betStateTypes=[{4}] betOutcomeTypes=[{5}] numberOfRecords = [{6}]', pageNumber, pageSize, orderBy, orderDesc, betStateTypes, betOutcomeTypes, numberOfRecords));
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetBetHistoryDetailsWithNumberOfRecords', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, betStateTypes: betStateTypes, betOutcomeTypes: betOutcomeTypes, numberOfRecords: numberOfRecords }, successCallback, Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetBetHistoryDetailsWithNumberOfRecords exception' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    placeBetSlip: function FixedOddsBettingService_FixedOddsBettingService$placeBetSlip(selections, betSlipCalculation, betSlip, isBetConfirmationScreenShownBeforePlacementOverride) {
        this.resetBetSlip();
        this._selections$1 = Framework.JsonUtil.deserialize(Framework.JsonUtil.serialize(selections));
        this._betSlipInbound$1 = new FixedOddsBettingService.BetSlipInbound(betSlip.IsFree, betSlip.Bets.clone());
        this._betSlipCalculation$1 = betSlipCalculation.clone();
        this._isBetConfirmationScreenShownBeforePlacementOverride$1 = isBetConfirmationScreenShownBeforePlacementOverride;
        if (this._areasWhereBetPlacementStays$1.contains(this._navigationService$1.getPageArea().toLowerCase())) {
            this._startInternalPlaceBetSlip$1();
        }
        else {
            this._betPlacementState$1 = FixedOddsBettingService.BetPlacementState.start;
            this._navigationService$1.goTo(this._areasWhereBetPlacementStays$1[0], this._navigationService$1.getPageFilter());
        }
    },
    
    _startInternalPlaceBetSlip$1: function FixedOddsBettingService_FixedOddsBettingService$_startInternalPlaceBetSlip$1() {
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.start, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        if ((this._preferences$1.IsBetConfirmationScreenShownBeforePlacement && this._isBetConfirmationScreenShownBeforePlacementOverride$1 !== FixedOddsBettingService.OverrideToShowConfirmation.overrideToNotShowConfirmation) || this._isBetConfirmationScreenShownBeforePlacementOverride$1 === FixedOddsBettingService.OverrideToShowConfirmation.overrideToShowConfirmation) {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        }
        else {
            this._gracePeriodRemaining$1 = this._preferences$1.BetGracePeriod || 0;
            this._makeBetSlipCall$1('');
        }
    },
    
    confirmBetSlip: function FixedOddsBettingService_FixedOddsBettingService$confirmBetSlip(securityCode) {
        this._makeBetSlipCall$1(securityCode);
    },
    
    _makeBetSlipCall$1: function FixedOddsBettingService_FixedOddsBettingService$_makeBetSlipCall$1(securityCode) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('ConfirmBetSlip');
        this._gracePeriodRemaining$1 = this._preferences$1.BetGracePeriod || 0;
        if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore || this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.start) {
            this._serverPlaceBetSlip$1();
        }
        else {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.waiting, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
            this._adjustBetSlipCalculation$1();
            this._adjustBetSlipInbound$1();
            if (this._isSecondConfirmation$1) {
                this._serverPlaceBetSlip$1();
            }
            else {
                this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'ConfirmBetSlipUsingConfirmations', { IDFOBetSlip: this._betSlipOutbound$1.IDFOBetSlip, betSlipStatus: this._betSlipOutbound$1.Status, rejectOnChanges: true, securityCode: securityCode }, Delegate.create(this, function(result) {
                    this._isSecondConfirmation$1 = true;
                    this._handleBetPlacementSuccess$1(result);
                }), Delegate.create(this, function(exception) {
                    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('ConfirmBetSlipUsingConfirmations exception' + exception.message);
                    this._handleBetPlacementException$1(exception);
                }));
            }
        }
    },
    
    _serverPlaceBetSlip$1: function FixedOddsBettingService_FixedOddsBettingService$_serverPlaceBetSlip$1() {
        this._isSecondConfirmation$1 = false;
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.waiting, false, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'PlaceBetSlip', { betSlip: this._betSlipInbound$1 }, Delegate.create(this, function(result) {
            this._handleBetPlacementSuccess$1(result);
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('PlaceBetSlip exception' + exception.message);
            this._handleBetPlacementException$1(exception);
        }));
    },
    
    rejectBetSlip: function FixedOddsBettingService_FixedOddsBettingService$rejectBetSlip() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RejectBetSlip');
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'RejectBetSlip', { IDFOBetSlip: this._betSlipOutbound$1.IDFOBetSlip, betSlipStatus: this._betSlipOutbound$1.Status }, Delegate.create(this, function(result) {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.rejected, true, FixedOddsBettingService.BetTerminatedState.manualRejection);
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RejectBetSlip exception' + exception.message);
            this._handleBetPlacementException$1(exception);
        }));
    },
    
    resetBetSlip: function FixedOddsBettingService_FixedOddsBettingService$resetBetSlip() {
        this._selections$1 = {};
        this._betPlacementState$1 = FixedOddsBettingService.BetPlacementState.none;
        this._betTerminatedState$1 = FixedOddsBettingService.BetTerminatedState.notApplicableState;
        this._betSlipInbound$1 = null;
        this._betSlipOutbound$1 = null;
        this._isSecondConfirmation$1 = false;
        this._betSlipCalculation$1 = [];
        this._gracePeriodRemaining$1 = 0;
    },
    
    gracePeriodTimedOut: function FixedOddsBettingService_FixedOddsBettingService$gracePeriodTimedOut() {
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.rejected, true, FixedOddsBettingService.BetTerminatedState.gracePeriodTimeoutRejection);
    },
    
    _getBetSlipStatusInternal$1: function FixedOddsBettingService_FixedOddsBettingService$_getBetSlipStatusInternal$1() {
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetBetSlipStatus', { IDFOBetSlip: this._betSlipOutbound$1.IDFOBetSlip }, Delegate.create(this, function(result) {
            this._betSlipOutbound$1.Status = result;
            this._updateBetPlacementState$1(this._betSlipOutbound$1.Status.State, false, FixedOddsBettingService.BetTerminatedState.notApplicableState);
            if (this._betSlipOutbound$1.Status.State === FixedOddsBettingService.BetPlacementState.waiting) {
                window.setTimeout(Delegate.create(this, this._getBetSlipStatusInternal$1), 5000);
            }
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetBetSlipStatus exception' + exception.message);
            this._handleBetPlacementException$1(exception);
        }));
    },
    
    _handleBetPlacementException$1: function FixedOddsBettingService_FixedOddsBettingService$_handleBetPlacementException$1(exception) {
        this._userService$1.handleSessionTimeout(exception);
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.failed, true, (exception && Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') ? FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure : FixedOddsBettingService.BetTerminatedState.generalFailure);
    },
    
    checkBetSlipStatusForSessionTimeout: function FixedOddsBettingService_FixedOddsBettingService$checkBetSlipStatusForSessionTimeout() {
        if (this._userService$1.isLoggedIn() && this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.failed && this._betTerminatedState$1 === FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure) {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore, false, FixedOddsBettingService.BetTerminatedState.notApplicableState);
            return true;
        }
        else {
            return false;
        }
    },
    
    _handleBetPlacementSuccess$1: function FixedOddsBettingService_FixedOddsBettingService$_handleBetPlacementSuccess$1(result) {
        this._betSlipOutbound$1 = FixedOddsBettingService.FixedOddsBettingService._adjustBetSlipOutboundForFreeBet$1(result, this._betSlipInbound$1.IsFree);
        var placementState = (this._isSecondConfirmation$1 && this._checkIfBetRejectedButStillValid$1()) ? FixedOddsBettingService.BetPlacementState.confirmationRequired : this._betSlipOutbound$1.Status.State;
        this._updateBetPlacementState$1(placementState, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.placed) {
            this._accountService$1.fetchAccountsDetails();
        }
        else if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.waiting) {
            this._getBetSlipStatusInternal$1();
        }
    },
    
    _preferences$1: null,
    
    _updateLocalPreferences$1: function FixedOddsBettingService_FixedOddsBettingService$_updateLocalPreferences$1(preferences, firePreferencesChangedEvent) {
        if (!FixedOddsBettingService.FixedOddsBettingPreferences.equals(this._preferences$1, preferences)) {
            if (firePreferencesChangedEvent) {
                this._fireBettingPreferencesChangedEvent$1();
            }
            var oldOddsType = this._preferences$1.OddsType;
            this._preferences$1 = preferences;
            if (!String.equals(oldOddsType, preferences.OddsType, true)) {
                this._fireOddsTypeChangedEvent$1();
            }
        }
    },
    
    setOddsType: function FixedOddsBettingService_FixedOddsBettingService$setOddsType(oddsType) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('SetOddsType oddsType=[{0}]', oddsType));
        if (String.equals(this._preferences$1.OddsType, oddsType, true)) {
            return;
        }
        if (FixedOddsBettingService.FixedOddsBettingPreferences.isOddsTypeValid(oddsType)) {
            this._preferences$1.OddsType = oddsType;
            this._fireOddsTypeChangedEvent$1();
        }
        else {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('SetOddsType invalid oddsType=[{0}]', oddsType));
        }
    },
    
    isOddsTypeValid: function FixedOddsBettingService_FixedOddsBettingService$isOddsTypeValid(oddsType) {
        return FixedOddsBettingService.FixedOddsBettingPreferences.isOddsTypeValid(oddsType.toUpperCase());
    },
    
    getPreferences: function FixedOddsBettingService_FixedOddsBettingService$getPreferences() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetPreferences');
        return this._preferences$1;
    },
    
    fetchPreferences: function FixedOddsBettingService_FixedOddsBettingService$fetchPreferences() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FetchPreferences');
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetPreferences', {}, Delegate.create(this, function(result) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetPreferences successfull');
            if (result) {
                this._updateLocalPreferences$1(result, true);
            }
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetPreferences exception' + exception.message);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    setPreferences: function FixedOddsBettingService_FixedOddsBettingService$setPreferences(successCallback, failureCallback, preferences) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('SetPreferences preferences=[{0}]', Framework.DictionaryUtil.dumpObjectToString(preferences)));
        if (!FixedOddsBettingService.FixedOddsBettingPreferences.equals(this._preferences$1, preferences)) {
            this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'SetPreferences', { fixedOddsBettingPreferences: preferences }, Delegate.create(this, function(result) {
                preferences.BetGracePeriod = this._preferences$1.BetGracePeriod;
                this._updateLocalPreferences$1(preferences, false);
                successCallback.invoke(result);
            }), Delegate.create(this, function(exception) {
                FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetPreferences exception' + exception.message);
                failureCallback.invoke(exception);
                this._userService$1.handleSessionTimeout(exception);
            }));
        }
        else {
            successCallback.invoke(null);
        }
    },
    
    formatOdds: function FixedOddsBettingService_FixedOddsBettingService$formatOdds(IDFOPriceType, priceUp, priceDown) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('FormatOdds IDFOPriceType=[{0}] priceUp=[{1}] priceDown=[{2}]', IDFOPriceType, priceUp, priceDown));
        if ('SP' === IDFOPriceType) {
            return 'SP';
        }
        if ('WPD' === IDFOPriceType || 'PPD' === IDFOPriceType || 'SPD' === IDFOPriceType) {
            return 'DIV';
        }
        if ((!priceUp) || (!priceDown)) {
            return '-';
        }
        if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.american, this._preferences$1.OddsType, true)) {
            return String.format('{0} {1}', (priceUp > priceDown) ? '+' : '-', (priceUp > priceDown) ? 100 * priceUp / priceDown : 100 * priceDown / priceUp);
        }
        if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.decimals, this._preferences$1.OddsType, true)) {
            return (((priceUp + priceDown) / priceDown)).toFixed(2);
        }
        if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.fractions, this._preferences$1.OddsType, true)) {
            return (priceUp === priceDown) ? 'EVS' : String.format('{0}/{1}', priceUp, priceDown);
        }
        return String.Empty;
    },
    
    shouldPlacementStayInCurrentArea: function FixedOddsBettingService_FixedOddsBettingService$shouldPlacementStayInCurrentArea() {
        return this._areasWhereBetPlacementStays$1.contains(this._navigationService$1.getPageArea().toLowerCase());
    }
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.Selection

FixedOddsBettingService.Selection = function FixedOddsBettingService_Selection() {
}
FixedOddsBettingService.Selection.createSelection = function FixedOddsBettingService_Selection$createSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, IsTrapBettingOptionOn, HADValue, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, FixedOddsPriceTypes, selectionHashCode, isTradable) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = IDFOPriceType;
    if (Framework.ScriptSharpQuirks.isNumberNull(activePriceType)) {
        result.ActivePriceType = -1;
        for (var i = 0; i < FixedOddsBettingService.PriceType.getValidPriceTypesForSingle().length; i++) {
            result.ActivePriceType = IDFOPriceType.indexOf(FixedOddsBettingService.PriceType.getValidPriceTypesForSingle()[i]);
            if (result.ActivePriceType >= 0) {
                break;
            }
        }
    }
    else {
        result.ActivePriceType = activePriceType;
    }
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket;
    result.MarketName = marketName;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = IsTrapBettingOptionOn;
    result.IsTrap = false;
    result.HADValue = HADValue;
    result.Handicap = handicap;
    result.UpperBand = upperBand;
    result.LowerBand = lowerBand;
    var filteredEachWayReduction = [];
    var filteredEachWayPlaceTerms = [];
    for (var i = 0; i < eachWayReduction.length; i++) {
        if (!(eachWayReduction[i] === 1 && eachWayPlaceTerms[i] === 1)) {
            filteredEachWayReduction.add(eachWayReduction[i]);
            filteredEachWayPlaceTerms.add(eachWayPlaceTerms[i]);
        }
    }
    result.EachWayReduction = filteredEachWayReduction;
    result.EachWayPlaceTerms = filteredEachWayPlaceTerms;
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection;
    result.SelectionName = selectionName;
    result.PriceUp = priceUp;
    result.PriceDown = priceDown;
    result.ActiveBetTypes = activeBetTypes;
    result.FixedOddsPriceTypes = FixedOddsPriceTypes;
    result.SelectionHashCode = selectionHashCode;
    result.IsTradable = isTradable;
    return result;
}
FixedOddsBettingService.Selection.createScorecastSelection = function FixedOddsBettingService_Selection$createScorecastSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS, selectionHashCode, isTradable) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = IDFOPriceType;
    result.ActivePriceType = 0;
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket1GS;
    result.MarketName = marketName1GS;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = false;
    result.IsTrap = false;
    result.EachWayReduction = [];
    result.EachWayPlaceTerms = [];
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection1GS;
    result.SelectionName = selectionName1GS;
    result.PriceUp = priceUp1GS;
    result.PriceDown = priceDown1GS;
    result.IDFOEventScorecast = IDFOEventScorecast;
    result.IDFOMarketCS = IDFOMarketCS;
    result.MarketNameCS = marketNameCS;
    result.IDFOSelectionCS = IDFOSelectionCS;
    result.SelectionNameCS = selectionNameCS;
    result.PriceUpCS = priceUpCS;
    result.PriceDownCS = priceDownCS;
    result.FixedOddsPriceTypes = [];
    result.SelectionHashCode = selectionHashCode;
    result.IsTradable = isTradable;
    return result;
}
FixedOddsBettingService.Selection.createSectionsListSelection = function FixedOddsBettingService_Selection$createSectionsListSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, HADValue, handicap, upperBand, lowerBand, IDFOSelection, selectionName, priceUp, priceDown) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = IDFOPriceType;
    if (Framework.ScriptSharpQuirks.isNumberNull(activePriceType)) {
        result.ActivePriceType = -1;
        for (var i = 0; i < FixedOddsBettingService.PriceType.getValidPriceTypesForSingle().length; i++) {
            result.ActivePriceType = IDFOPriceType.indexOf(FixedOddsBettingService.PriceType.getValidPriceTypesForSingle()[i]);
            if (result.ActivePriceType >= 0) {
                break;
            }
        }
    }
    else {
        result.ActivePriceType = activePriceType;
    }
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket;
    result.MarketName = marketName;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = false;
    result.IsTrap = false;
    result.HADValue = HADValue;
    result.Handicap = handicap;
    result.UpperBand = upperBand;
    result.LowerBand = lowerBand;
    result.EachWayReduction = [];
    result.EachWayPlaceTerms = [];
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection;
    result.SelectionName = selectionName;
    result.PriceUp = priceUp;
    result.PriceDown = priceDown;
    result.ActiveBetTypes = null;
    result.FixedOddsPriceTypes = [];
    result.SelectionHashCode = null;
    result.IsTradable = false;
    return result;
}
FixedOddsBettingService.Selection.createRacePoolSelection = function FixedOddsBettingService_Selection$createRacePoolSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, IDFOSelection, selectionName) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = [ IDFOPriceType ];
    result.ActivePriceType = 0;
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket;
    result.MarketName = marketName;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = false;
    result.IsTrap = true;
    result.HADValue = null;
    result.Handicap = null;
    result.UpperBand = null;
    result.LowerBand = null;
    result.EachWayReduction = [];
    result.EachWayPlaceTerms = [];
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection;
    result.SelectionName = selectionName;
    result.PriceUp = null;
    result.PriceDown = null;
    result.ActiveBetTypes = null;
    result.FixedOddsPriceTypes = [];
    result.SelectionHashCode = null;
    result.IsTradable = false;
    return result;
}
FixedOddsBettingService.Selection.prototype = {
    IDFOPriceType: null,
    ActivePriceType: 0,
    IDFOEvent: null,
    EventName: null,
    IDFOMarket: null,
    MarketName: null,
    MTag: null,
    TTagLeft: null,
    TTagRight: null,
    CTag: null,
    IsTrapBettingOptionOn: false,
    IsTrap: false,
    HADValue: null,
    Handicap: null,
    UpperBand: null,
    LowerBand: null,
    EachWayReduction: null,
    EachWayPlaceTerms: null,
    ActiveEachWay: 0,
    IDFOSelection: null,
    SelectionName: null,
    PriceUp: null,
    PriceDown: null,
    IDFOEventScorecast: null,
    IDFOMarketCS: null,
    MarketNameCS: null,
    IDFOSelectionCS: null,
    SelectionNameCS: null,
    PriceUpCS: null,
    PriceDownCS: null,
    IsActive: true,
    ActiveBetTypes: null,
    SelectionHashCode: null,
    IsTradable: false,
    FixedOddsPriceTypes: null
}


FixedOddsBettingService.BetPlacementState.createClass('FixedOddsBettingService.BetPlacementState');
FixedOddsBettingService.BetTerminatedState.createClass('FixedOddsBettingService.BetTerminatedState');
FixedOddsBettingService.CalculatedBet.createClass('FixedOddsBettingService.CalculatedBet');
FixedOddsBettingService.BetInbound.createClass('FixedOddsBettingService.BetInbound');
FixedOddsBettingService.BetLeg.createClass('FixedOddsBettingService.BetLeg');
FixedOddsBettingService.BetSlipInbound.createClass('FixedOddsBettingService.BetSlipInbound');
FixedOddsBettingService.BetSlipOutbound.createClass('FixedOddsBettingService.BetSlipOutbound');
FixedOddsBettingService.BetOutbound.createClass('FixedOddsBettingService.BetOutbound');
FixedOddsBettingService.BetType.createClass('FixedOddsBettingService.BetType');
FixedOddsBettingService.BetSlipStatus.createClass('FixedOddsBettingService.BetSlipStatus');
FixedOddsBettingService.BetTypesAndReturns.createClass('FixedOddsBettingService.BetTypesAndReturns');
FixedOddsBettingService.PotentialReturn.createClass('FixedOddsBettingService.PotentialReturn');
FixedOddsBettingService.PriceType.createClass('FixedOddsBettingService.PriceType');
FixedOddsBettingService.FixedOddsBettingPreferences.createClass('FixedOddsBettingService.FixedOddsBettingPreferences');
FixedOddsBettingService.FixedOddsBettingService.createClass('FixedOddsBettingService.FixedOddsBettingService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
FixedOddsBettingService.Selection.createClass('FixedOddsBettingService.Selection');
FixedOddsBettingService.BetPlacementState.none = -2;
FixedOddsBettingService.BetPlacementState.start = -1;
FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore = 0;
FixedOddsBettingService.BetPlacementState.confirmationRequired = 1;
FixedOddsBettingService.BetPlacementState.placed = 2;
FixedOddsBettingService.BetPlacementState.acceptable = 3;
FixedOddsBettingService.BetPlacementState.rejected = 4;
FixedOddsBettingService.BetPlacementState.waiting = 5;
FixedOddsBettingService.BetPlacementState.failed = 6;
FixedOddsBettingService.BetTerminatedState.notApplicableState = -1;
FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure = 0;
FixedOddsBettingService.BetTerminatedState.generalFailure = 1;
FixedOddsBettingService.BetTerminatedState.betFailedMasks = [ FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure, FixedOddsBettingService.BetTerminatedState.generalFailure ];
FixedOddsBettingService.BetTerminatedState.manualRejection = 2;
FixedOddsBettingService.BetTerminatedState.displayStatusRejection = 3;
FixedOddsBettingService.BetTerminatedState.generalRejection = 4;
FixedOddsBettingService.BetTerminatedState.gracePeriodTimeoutRejection = 5;
FixedOddsBettingService.BetTerminatedState.betRejectedMasks = [ FixedOddsBettingService.BetTerminatedState.manualRejection, FixedOddsBettingService.BetTerminatedState.displayStatusRejection, FixedOddsBettingService.BetTerminatedState.generalRejection, FixedOddsBettingService.BetTerminatedState.gracePeriodTimeoutRejection ];
FixedOddsBettingService.BetSlipStatus.accepted = 1;
FixedOddsBettingService.BetSlipStatus.acceptable = 2;
FixedOddsBettingService.BetSlipStatus.rejected = 4;
FixedOddsBettingService.BetSlipStatus.priceChanged = 8;
FixedOddsBettingService.BetSlipStatus.handicapChanged = 16;
FixedOddsBettingService.BetSlipStatus.bandChanged = 32;
FixedOddsBettingService.BetSlipStatus.reoffered = 64;
FixedOddsBettingService.BetSlipStatus.reofferTimeout = 128;
FixedOddsBettingService.BetSlipStatus.topupRequired = 256;
FixedOddsBettingService.BetSlipStatus.maxTakeoutViolation = 512;
FixedOddsBettingService.BetSlipStatus.waiting = 1024;
FixedOddsBettingService.BetSlipStatus.eachWayChanged = 2048;
FixedOddsBettingService.BetSlipStatus.abortProcessing = 4096;
FixedOddsBettingService.BetSlipStatus.securityCodeRequiredForTopup = 16384;
FixedOddsBettingService.BetSlipStatus.confirmationMasks = [ FixedOddsBettingService.BetSlipStatus.priceChanged, FixedOddsBettingService.BetSlipStatus.handicapChanged, FixedOddsBettingService.BetSlipStatus.bandChanged, FixedOddsBettingService.BetSlipStatus.reoffered, FixedOddsBettingService.BetSlipStatus.topupRequired, FixedOddsBettingService.BetSlipStatus.maxTakeoutViolation, FixedOddsBettingService.BetSlipStatus.eachWayChanged, FixedOddsBettingService.BetSlipStatus.abortProcessing, FixedOddsBettingService.BetSlipStatus.securityCodeRequiredForTopup ];
FixedOddsBettingService.PriceType._validPriceTypesForSingle = [ 'AP', 'EP', 'BP', 'CP', 'SC', 'SP', 'WPD' ];
FixedOddsBettingService.FixedOddsBettingPreferences.american = 'AMERICAN';
FixedOddsBettingService.FixedOddsBettingPreferences.decimals = 'DECIMALS';
FixedOddsBettingService.FixedOddsBettingPreferences.fractions = 'FRACTIONS';
FixedOddsBettingService.FixedOddsBettingService._serviceName$1 = 'FixedOddsBettingService';
FixedOddsBettingService.FixedOddsBettingService._log$1 = Framework.Logger.getLog(FixedOddsBettingService.FixedOddsBettingService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BetSlipService');

////////////////////////////////////////////////////////////////////////////////
// BetSlipService.IBetSlipCalculationChangedListener

BetSlipService.IBetSlipCalculationChangedListener = function() { };
BetSlipService.IBetSlipCalculationChangedListener.prototype = {
    onBetSlipCalculationChanged : null
}
BetSlipService.IBetSlipCalculationChangedListener.createInterface('BetSlipService.IBetSlipCalculationChangedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.IAllowedBetTypesChangedListener

BetSlipService.IAllowedBetTypesChangedListener = function() { };
BetSlipService.IAllowedBetTypesChangedListener.prototype = {
    onAllowedBetTypesChanged : null
}
BetSlipService.IAllowedBetTypesChangedListener.createInterface('BetSlipService.IAllowedBetTypesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.IBetSlipSelectionsUpdateListener

BetSlipService.IBetSlipSelectionsUpdateListener = function() { };
BetSlipService.IBetSlipSelectionsUpdateListener.prototype = {
    onBetSlipSelectionsUpdate : null
}
BetSlipService.IBetSlipSelectionsUpdateListener.createInterface('BetSlipService.IBetSlipSelectionsUpdateListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.ISelectionsRemovedListener

BetSlipService.ISelectionsRemovedListener = function() { };
BetSlipService.ISelectionsRemovedListener.prototype = {
    onSelectionsRemoved : null
}
BetSlipService.ISelectionsRemovedListener.createInterface('BetSlipService.ISelectionsRemovedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.ISelectionsAddedListener

BetSlipService.ISelectionsAddedListener = function() { };
BetSlipService.ISelectionsAddedListener.prototype = {
    onSelectionsAdded : null
}
BetSlipService.ISelectionsAddedListener.createInterface('BetSlipService.ISelectionsAddedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.BetSlipService

BetSlipService.BetSlipService = function BetSlipService_BetSlipService() {
    this._currentTimeout$1 = -1;
    this._selectionsAddedListeners$1 = new Framework.ListenerInvoker(true);
    this._selectionsRemovedListeners$1 = new Framework.ListenerInvoker(true);
    this._allowedBetTypesChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._betSlipCalculationChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._betSlipSelectionsUpdateListeners$1 = new Framework.ListenerInvoker(true);
    this._selections$1 = {};
    this._previousSelections$1 = {};
    this._selectionsInterRelationColors$1 = {};
    this._allowedBetTypes$1 = [];
    this._isEachWayPerBetType$1 = {};
    this._stakePerBetType$1 = {};
    this._stakePerSelection$1 = {};
    this._potentialReturns$1 = new FixedOddsBettingService.PotentialReturn();
    this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
    BetSlipService.BetSlipService.constructBase(this);
}
BetSlipService.BetSlipService.prototype = {
    _liveUpdatePeriod$1: 10000,
    _betSlipLiveUpdate$1: true,
    _betSlipUpdateInProgress$1: false,
    
    onPageWillChange: function BetSlipService_BetSlipService$onPageWillChange() {
        this._environment.storeState(BetSlipService.BetSlipService._serviceName$1, this._getState$1());
    },
    
    _accountService$1: null,
    
    setAccountService: function BetSlipService_BetSlipService$setAccountService(accountService) {
        BetSlipService.BetSlipService._log$1.debug('SetAccountService');
        this._accountService$1 = accountService;
    },
    
    _fixedOddsBettingService$1: null,
    
    setFixedOddsBettingService: function BetSlipService_BetSlipService$setFixedOddsBettingService(fixedOddsBettingService) {
        BetSlipService.BetSlipService._log$1.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService$1 = fixedOddsBettingService;
        this._fixedOddsBettingService$1.registerBetPlacementStateChangedListener(this);
    },
    
    onBetPlacementStateChanged: function BetSlipService_BetSlipService$onBetPlacementStateChanged() {
        BetSlipService.BetSlipService._log$1.debug('OnBetPlacementStateChanged');
        if ((this._fixedOddsBettingService$1.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.placed || this._fixedOddsBettingService$1.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.rejected) && !this._retainSelectionsAfterPlacement$1) {
            this.removeAllSelections();
        }
    },
    
    _navigationService$1: null,
    
    setNavigationService: function BetSlipService_BetSlipService$setNavigationService(navigationService) {
        BetSlipService.BetSlipService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    init: function BetSlipService_BetSlipService$init(environment, parameters) {
        BetSlipService.BetSlipService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        BetSlipService.BetSlipService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(BetSlipService.BetSlipService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
        if (Object.keyExists(parameters, 'bet-slip-live-update')) {
            this._betSlipLiveUpdate$1 = Boolean.parse(parameters['bet-slip-live-update']);
        }
    },
    
    start: function BetSlipService_BetSlipService$start() {
        BetSlipService.BetSlipService._log$1.debug('Start');
    },
    
    registerBetSlipSelectionsUpdateListener: function BetSlipService_BetSlipService$registerBetSlipSelectionsUpdateListener(betSlipSelectionsUpdateListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterBetSlipSelectionsUpdatedListener');
        this._betSlipSelectionsUpdateListeners$1.registerListener(betSlipSelectionsUpdateListener);
    },
    
    unregisterBetSlipSelectionsUpdateListener: function BetSlipService_BetSlipService$unregisterBetSlipSelectionsUpdateListener(betSlipSelectionsUpdateListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterBetSlipSelectionsUpdatedListener');
        this._betSlipSelectionsUpdateListeners$1.unregisterListener(betSlipSelectionsUpdateListener);
    },
    
    _fireBetSlipSelectionsUpdateEvent$1: function BetSlipService_BetSlipService$_fireBetSlipSelectionsUpdateEvent$1() {
        BetSlipService.BetSlipService._log$1.debug('FireBetSlipSelectionsUpdatedEvent');
        this._betSlipSelectionsUpdateListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBetSlipSelectionsUpdate(this);
        }));
    },
    
    registerSelectionsAddedListener: function BetSlipService_BetSlipService$registerSelectionsAddedListener(selectionsAddedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterSelectionsAddedListener');
        this._selectionsAddedListeners$1.registerListener(selectionsAddedListener);
    },
    
    unregisterSelectionsAddedListener: function BetSlipService_BetSlipService$unregisterSelectionsAddedListener(selectionsAddedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterSelectionsAddedListener');
        this._selectionsAddedListeners$1.unregisterListener(selectionsAddedListener);
    },
    
    _fireSelectionsAddedEvent$1: function BetSlipService_BetSlipService$_fireSelectionsAddedEvent$1(selection) {
        BetSlipService.BetSlipService._log$1.debug('FireSelectionsAddedEvent');
        this._selectionsAddedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSelectionsAdded(this, selection);
        }));
    },
    
    registerSelectionsRemovedListener: function BetSlipService_BetSlipService$registerSelectionsRemovedListener(selectionsRemovedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterSelectionsRemovedListener');
        this._selectionsRemovedListeners$1.registerListener(selectionsRemovedListener);
    },
    
    unregisterSelectionsRemovedListener: function BetSlipService_BetSlipService$unregisterSelectionsRemovedListener(selectionsRemovedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterSelectionsRemovedListener');
        this._selectionsRemovedListeners$1.unregisterListener(selectionsRemovedListener);
    },
    
    _fireSelectionsRemovedEvent$1: function BetSlipService_BetSlipService$_fireSelectionsRemovedEvent$1(selection) {
        BetSlipService.BetSlipService._log$1.debug('FireSelectionsRemovedEvent');
        this._selectionsRemovedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSelectionsRemoved(this, selection);
        }));
    },
    
    registerAllowedBetTypesChangedListener: function BetSlipService_BetSlipService$registerAllowedBetTypesChangedListener(allowedBetTypesChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterAllowedBetTypesChangedListener');
        this._allowedBetTypesChangedListeners$1.registerListener(allowedBetTypesChangedListener);
    },
    
    unregisterAllowedBetTypesChangedListener: function BetSlipService_BetSlipService$unregisterAllowedBetTypesChangedListener(allowedBetTypesChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterAllowedBetTypesChangedListener');
        this._allowedBetTypesChangedListeners$1.unregisterListener(allowedBetTypesChangedListener);
    },
    
    _fireAllowedBetTypesChangedEvent$1: function BetSlipService_BetSlipService$_fireAllowedBetTypesChangedEvent$1() {
        BetSlipService.BetSlipService._log$1.debug('FireAllowedBetTypesChangedEvent');
        this._allowedBetTypesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onAllowedBetTypesChanged(this);
        }));
    },
    
    registerBetSlipCalculationChangedListener: function BetSlipService_BetSlipService$registerBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterBetSlipCalculationChangedListener');
        this._betSlipCalculationChangedListeners$1.registerListener(betSlipCalculationChangedListener);
    },
    
    unregisterBetSlipCalculationChangedListener: function BetSlipService_BetSlipService$unregisterBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterBetSlipCalculationChangedListener');
        this._betSlipCalculationChangedListeners$1.unregisterListener(betSlipCalculationChangedListener);
    },
    
    _fireBetSlipCalculationChangedEvent$1: function BetSlipService_BetSlipService$_fireBetSlipCalculationChangedEvent$1() {
        BetSlipService.BetSlipService._log$1.debug('FireBetSlipCalculationChangedEvent');
        this._betSlipCalculationChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBetSlipCalculationChanged(this);
        }));
    },
    
    _retainSelectionsAfterPlacement$1: false,
    
    getRetainSelectionsAfterPlacement: function BetSlipService_BetSlipService$getRetainSelectionsAfterPlacement() {
        BetSlipService.BetSlipService._log$1.debug('GetRetainSelectionsAfterPlacement');
        return this._retainSelectionsAfterPlacement$1;
    },
    
    _isFree$1: false,
    
    getIsFree: function BetSlipService_BetSlipService$getIsFree() {
        BetSlipService.BetSlipService._log$1.debug('GetIsFree');
        return this._isFree$1;
    },
    
    getSelections: function BetSlipService_BetSlipService$getSelections() {
        BetSlipService.BetSlipService._log$1.debug('GetSelections');
        if (!this._selections$1) {
            return {};
        }
        return this._selections$1;
    },
    
    getPreviousSelections: function BetSlipService_BetSlipService$getPreviousSelections() {
        BetSlipService.BetSlipService._log$1.debug('GetPreviousSelections');
        if (!this._previousSelections$1) {
            return {};
        }
        return this._previousSelections$1;
    },
    
    clearPreviousSelections: function BetSlipService_BetSlipService$clearPreviousSelections() {
        Object.clearKeys(this._previousSelections$1);
    },
    
    getSelectionsCount: function BetSlipService_BetSlipService$getSelectionsCount() {
        if (!this._selections$1) {
            return 0;
        }
        return Object.getKeyCount(this._selections$1);
    },
    
    getSelectionsInterRelationColors: function BetSlipService_BetSlipService$getSelectionsInterRelationColors() {
        return this._selectionsInterRelationColors$1;
    },
    
    getAllowedBetTypes: function BetSlipService_BetSlipService$getAllowedBetTypes() {
        BetSlipService.BetSlipService._log$1.debug('GetAllowedBetTypes');
        return this._allowedBetTypes$1;
    },
    
    getIsEachWayPerBetType: function BetSlipService_BetSlipService$getIsEachWayPerBetType() {
        BetSlipService.BetSlipService._log$1.debug('GetIsEachWayPerBetType');
        return this._isEachWayPerBetType$1;
    },
    
    getStakePerBetType: function BetSlipService_BetSlipService$getStakePerBetType() {
        BetSlipService.BetSlipService._log$1.debug('GetStakePerBetType');
        return this._stakePerBetType$1;
    },
    
    getStakePerSelection: function BetSlipService_BetSlipService$getStakePerSelection() {
        BetSlipService.BetSlipService._log$1.debug('GetStakePerSelection');
        return this._stakePerSelection$1;
    },
    
    getBetSlipCalculation: function BetSlipService_BetSlipService$getBetSlipCalculation() {
        BetSlipService.BetSlipService._log$1.debug('GetBetSlipCalculation');
        return this._betSlipCalculation$1;
    },
    
    _getBetSlipInbound$1: function BetSlipService_BetSlipService$_getBetSlipInbound$1() {
        var betLegs = this._getBetLegs$1(true, null);
        var betLegsDictionary = {};
        for (var j = 0; j < betLegs.length; j++) {
            if (!betLegs[j].IDFOEventScorecast) {
                betLegsDictionary[this.getSimpleSelectionKey(betLegs[j].IDFOSelection)] = betLegs[j];
            }
            else {
                betLegsDictionary[this._getScorecastLegKey1GS$1(betLegs[j].IDFOEventScorecast, betLegs[j].IDFOSelection, betLegs[j + 1].IDFOSelection)] = betLegs[j];
                betLegsDictionary[this._getScorecastLegKeyCS$1(betLegs[j].IDFOEventScorecast, betLegs[j].IDFOSelection, betLegs[j + 1].IDFOSelection)] = betLegs[j + 1];
                j++;
            }
        }
        var bets = new Array(Object.getKeyCount(this._stakePerBetType$1) + Object.getKeyCount(this._stakePerSelection$1));
        BetSlipService.BetSlipService._log$1.debug(String.format('GetBetSlipInbound total bets=[{0}] stakePerSelection.Count=[{1}]', bets.length, Object.getKeyCount(this._stakePerSelection$1)));
        var i = 0;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var singleSelection = { key: $key2, value: $dict1[$key2] };
            if (Object.keyExists(this._stakePerSelection$1, singleSelection.key)) {
                var selection = singleSelection.value;
                var selectionKey = singleSelection.key;
                var currentBetLeg;
                if (!selection.IDFOEventScorecast) {
                    currentBetLeg = [ betLegsDictionary[selectionKey] ];
                }
                else {
                    currentBetLeg = [ betLegsDictionary[this._getScorecastLegKey1GS$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS)], betLegsDictionary[this._getScorecastLegKeyCS$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS)] ];
                }
                var IDFOMultiRacePool = null;
                var isPool = false;
                var winStake = this._stakePerSelection$1[selectionKey];
                var placeStake = (selection.ActiveEachWay < 0) ? null : winStake;
                var showStake = null;
                bets[i++] = new FixedOddsBettingService.BetInbound(currentBetLeg, 'S', 'Single', IDFOMultiRacePool, isPool, winStake, placeStake, showStake);
            }
        }
        var $dict3 = this._stakePerBetType$1;
        for (var $key4 in $dict3) {
            var stakePerBetTypeEntry = { key: $key4, value: $dict3[$key4] };
            var IDFOBetType = stakePerBetTypeEntry.key;
            var IDFOMultiRacePool = null;
            var isPool = false;
            var winStake = stakePerBetTypeEntry.value;
            var placeStake = (this._isEachWayPerBetType$1[IDFOBetType]) ? winStake : null;
            var showStake = null;
            var forcedIDFOPriceType = BetSlipService.OverridingPriceTypes.priceTypeOverrides[IDFOBetType];
            var multiBetLegs = (String.isNullOrEmpty(forcedIDFOPriceType)) ? betLegs : this._getBetLegs$1(true, forcedIDFOPriceType);
            bets[i++] = new FixedOddsBettingService.BetInbound(multiBetLegs, IDFOBetType, this._getBetTypeName$1(IDFOBetType), IDFOMultiRacePool, isPool, winStake, placeStake, showStake);
        }
        return new FixedOddsBettingService.BetSlipInbound(this._isFree$1, bets);
    },
    
    _recalculateAllowedBetTypesAndReturnsSequence$1: 0,
    _recalculateEWReturnForBetType$1: 0,
    
    _getBetTypeName$1: function BetSlipService_BetSlipService$_getBetTypeName$1(IDFOBetType) {
        for (var i = 0; i < this._allowedBetTypes$1.length; i++) {
            if (!String.compare(IDFOBetType, this._allowedBetTypes$1[i].IDFOBetType, true)) {
                return this._allowedBetTypes$1[i].Name;
            }
        }
        return IDFOBetType;
    },
    
    _getState$1: function BetSlipService_BetSlipService$_getState$1() {
        return { isFree: this._isFree$1, selections: this._selections$1, previousSelections: this._previousSelections$1, allowedBetTypes: this._allowedBetTypes$1, stakePerBetType: this._stakePerBetType$1, stakePerSelection: this._stakePerSelection$1, betSlipCalculation: this._betSlipCalculation$1, isEachWayPerBetType: this._isEachWayPerBetType$1, potentialReturns: this._potentialReturns$1, retainSelectionsAfterPlacement: this._retainSelectionsAfterPlacement$1 };
    },
    
    _setState$1: function BetSlipService_BetSlipService$_setState$1(state) {
        this._isFree$1 = state['isFree'];
        this._selections$1 = state['selections'];
        this._previousSelections$1 = state['previousSelections'];
        this._allowedBetTypes$1 = state['allowedBetTypes'];
        this._stakePerBetType$1 = state['stakePerBetType'];
        this._stakePerSelection$1 = state['stakePerSelection'];
        this._betSlipCalculation$1 = state['betSlipCalculation'];
        this._isEachWayPerBetType$1 = state['isEachWayPerBetType'];
        this._potentialReturns$1 = state['potentialReturns'];
        this._retainSelectionsAfterPlacement$1 = state['retainSelectionsAfterPlacement'];
    },
    
    _getBetLegs$1: function BetSlipService_BetSlipService$_getBetLegs$1(forceEachWay, forcedIDFOPriceType) {
        var result = [];
        var systemTag = null;
        var interrelationTag = null;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var selectionDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var selection = selectionDictionaryEntry.value;
            if (selection.IsActive) {
                var eachWayReduction = null;
                var eachWayPlaceTerms = null;
                if (forceEachWay && selection.EachWayReduction.length > 0) {
                    eachWayReduction = selection.EachWayReduction[0];
                    eachWayPlaceTerms = selection.EachWayPlaceTerms[0];
                }
                if (!forceEachWay && selection.ActiveEachWay >= 0) {
                    eachWayReduction = selection.EachWayReduction[selection.ActiveEachWay];
                    eachWayPlaceTerms = selection.EachWayPlaceTerms[selection.ActiveEachWay];
                }
                result.add(new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, (!String.isNullOrEmpty(forcedIDFOPriceType)) ? forcedIDFOPriceType : selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, selection.PriceDown, selection.PriceUp, eachWayReduction, eachWayPlaceTerms, selection.IsTrap, systemTag, interrelationTag, selection.IDFOEventScorecast));
                if (selection.IDFOEventScorecast) {
                    result.add(new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelectionCS, selection.PriceDownCS, selection.PriceUpCS, eachWayReduction, eachWayPlaceTerms, selection.IsTrap, systemTag, interrelationTag, selection.IDFOEventScorecast));
                }
            }
        }
        return result;
    },
    
    _recalculateAllowedBetTypesAndReturns$1: function BetSlipService_BetSlipService$_recalculateAllowedBetTypesAndReturns$1() {
        if (!this._selections$1 || !Object.getKeyCount(this._selections$1)) {
            this._allowedBetTypes$1 = [];
            this._stakePerBetType$1 = {};
            this._stakePerSelection$1 = {};
            this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
            this._potentialReturns$1 = new FixedOddsBettingService.PotentialReturn();
            this._isEachWayPerBetType$1 = {};
            this._fireAllowedBetTypesChangedEvent$1();
            this._fireBetSlipCalculationChangedEvent$1();
        }
        else {
            this._recalculateAllowedBetTypesAndReturnsSequence$1++;
            var recalculateAllowedBetTypesAndReturnsSequence = this._recalculateAllowedBetTypesAndReturnsSequence$1;
            var betLegs = this._forceFixedOddsPrice$1(this._getBetLegs$1(true, null));
            this._environment.invokeAsync('FixedOddsBettingService', 'GetAllowedBetTypesAndReturns', { bet: new FixedOddsBettingService.BetInbound(betLegs, null, null, null, false, null, null, null), isEWPerBetType: this._isEachWayPerBetType$1 }, Delegate.create(this, function(result) {
                if (recalculateAllowedBetTypesAndReturnsSequence === this._recalculateAllowedBetTypesAndReturnsSequence$1) {
                    var betTypesAndReturns = result;
                    this._allowedBetTypes$1 = betTypesAndReturns.AllowedBetTypes;
                    this._potentialReturns$1 = betTypesAndReturns.PotentialReturns;
                    var $dict1 = this._stakePerBetType$1;
                    for (var $key2 in $dict1) {
                        var stakePerBetTypeEntry = { key: $key2, value: $dict1[$key2] };
                        var clearStake = true;
                        for (var i = 0; i < this._allowedBetTypes$1.length; i++) {
                            if (this._allowedBetTypes$1[i].IDFOBetType === stakePerBetTypeEntry.key) {
                                clearStake = false;
                                if (Object.keyExists(this._isEachWayPerBetType$1, stakePerBetTypeEntry.key) && (this._isEachWayPerBetType$1[stakePerBetTypeEntry.key]) && !this._allowedBetTypes$1[i].IsEachWayAllowed) {
                                    delete this._isEachWayPerBetType$1[stakePerBetTypeEntry.key];
                                }
                                break;
                            }
                        }
                        if (clearStake) {
                            delete this._stakePerBetType$1[stakePerBetTypeEntry.key];
                            delete this._isEachWayPerBetType$1[stakePerBetTypeEntry.key];
                        }
                    }
                    this._fireAllowedBetTypesChangedEvent$1();
                    this._recalculateBetSlip$1();
                }
            }), Delegate.create(this, function(exception) {
                BetSlipService.BetSlipService._log$1.debug('RecalculateAllowedBetTypesAndReturns Cannot recalculate allowed bet types');
            }));
        }
    },
    
    _updateBetSlipSelections$1: function BetSlipService_BetSlipService$_updateBetSlipSelections$1() {
        if (Object.getKeyCount(this._selections$1) && !this._betSlipUpdateInProgress$1) {
            this._betSlipUpdateInProgress$1 = true;
            var selections = new Array(Object.getKeyCount(this._selections$1));
            var index = 0;
            var $dict1 = this._selections$1;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                selections[index++] = entry.value;
            }
            this._environment.invokeAsync('FixedOddsBettingService', 'UpdateBetSlipSelections', { selections: selections }, Delegate.create(this, function(result) {
                this._betSlipUpdateInProgress$1 = false;
                if (result) {
                    var updatedSelections = result;
                    if (updatedSelections.length > 0) {
                        for (var i = 0; i < updatedSelections.length; i++) {
                            var selectionKey = this.getSelectionKey(updatedSelections[i]);
                            if (updatedSelections[i].IDFOSelection === (this._selections$1[selectionKey]).IDFOSelection) {
                                var updatedSelection = null;
                                if (!updatedSelections[i].IDFOEventScorecast) {
                                    updatedSelection = FixedOddsBettingService.Selection.createSelection(updatedSelections[i].IDFOPriceType, updatedSelections[i].ActivePriceType, updatedSelections[i].IDFOEvent, updatedSelections[i].EventName, updatedSelections[i].IDFOMarket, updatedSelections[i].MarketName, updatedSelections[i].MTag, updatedSelections[i].TTagLeft, updatedSelections[i].TTagRight, updatedSelections[i].CTag, updatedSelections[i].IsTrapBettingOptionOn, updatedSelections[i].HADValue, updatedSelections[i].Handicap, updatedSelections[i].UpperBand, updatedSelections[i].LowerBand, updatedSelections[i].EachWayReduction, updatedSelections[i].EachWayPlaceTerms, updatedSelections[i].IDFOSelection, updatedSelections[i].SelectionName, updatedSelections[i].PriceUp, updatedSelections[i].PriceDown, updatedSelections[i].ActiveBetTypes, updatedSelections[i].FixedOddsPriceTypes, updatedSelections[i].SelectionHashCode, updatedSelections[i].IsTradable);
                                }
                                else {
                                    updatedSelection = FixedOddsBettingService.Selection.createScorecastSelection(updatedSelections[i].IDFOPriceType, updatedSelections[i].IDFOEvent, updatedSelections[i].EventName, updatedSelections[i].IDFOMarket, updatedSelections[i].MarketName, updatedSelections[i].MTag, updatedSelections[i].TTagLeft, updatedSelections[i].TTagRight, updatedSelections[i].CTag, updatedSelections[i].IDFOSelection, updatedSelections[i].SelectionName, updatedSelections[i].PriceUp, updatedSelections[i].PriceDown, updatedSelections[i].IDFOEventScorecast, updatedSelections[i].IDFOMarketCS, updatedSelections[i].MarketNameCS, updatedSelections[i].IDFOSelectionCS, updatedSelections[i].SelectionNameCS, updatedSelections[i].PriceUpCS, updatedSelections[i].PriceDownCS, updatedSelections[i].SelectionHashCode, updatedSelections[i].IsTradable);
                                }
                                this._previousSelections$1[selectionKey] = this._selections$1[selectionKey];
                                this._selections$1[selectionKey] = updatedSelection;
                            }
                        }
                        this._recalculateInterrelation$1();
                        this._recalculateAllowedBetTypesAndReturns$1();
                        this._fireBetSlipSelectionsUpdateEvent$1();
                    }
                }
            }), Delegate.create(this, function(ex) {
                BetSlipService.BetSlipService._log$1.debug('UpdateBetSlipSelections error');
            }));
        }
    },
    
    _recalculateBetSlip$1: function BetSlipService_BetSlipService$_recalculateBetSlip$1() {
        var betSlipInbound = this._getBetSlipInbound$1();
        if (!betSlipInbound.Bets.length) {
            this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
            this._fireBetSlipCalculationChangedEvent$1();
        }
        else {
            var adjustedResult = new FixedOddsBettingService.PotentialReturn();
            var hasSP = false;
            var $dict1 = this._selections$1;
            for (var $key2 in $dict1) {
                var selection = { key: $key2, value: $dict1[$key2] };
                var thisSelection = selection.value;
                if (thisSelection.IDFOPriceType[thisSelection.ActivePriceType] === 'SP') {
                    hasSP = true;
                    break;
                }
            }
            for (var i = 0; i < betSlipInbound.Bets.length; i++) {
                var betReturn = 1;
                var unitCount = 1;
                var isEachWay = (betSlipInbound.Bets[i].PlaceStake && betSlipInbound.Bets[i].PlaceStake > 0) ? true : false;
                var selectionKey = '';
                if (betSlipInbound.Bets[i].IDFOBetType === 'S' && i < Object.getKeyCount(this._stakePerSelection$1)) {
                    selectionKey = (betSlipInbound.Bets[i].BetLegs[0].IDFOPriceType === 'SC') ? this.getScorecastSelectionKey(betSlipInbound.Bets[i].BetLegs[0].IDFOEventScorecast, betSlipInbound.Bets[i].BetLegs[0].IDFOSelection, betSlipInbound.Bets[i].BetLegs[1].IDFOSelection) : this.getSimpleSelectionKey(betSlipInbound.Bets[i].BetLegs[0].IDFOSelection);
                    if (Object.keyExists(this._potentialReturns$1.PerSelection, selectionKey)) {
                        var currentSelection = this._selections$1[selectionKey];
                        var currentCalculatedBet = this._potentialReturns$1.PerSelection[selectionKey];
                        unitCount = currentCalculatedBet.UnitCount;
                        if (currentSelection.IDFOPriceType[currentSelection.ActivePriceType] === 'SP') {
                            betReturn = -1;
                        }
                        else {
                            betReturn = currentCalculatedBet.PotentialReturn;
                        }
                        if (isEachWay) {
                            unitCount *= 2;
                            if (currentSelection.IDFOPriceType[currentSelection.ActivePriceType] !== 'SP') {
                                betReturn += ((currentCalculatedBet.PotentialReturn - 1) / currentSelection.EachWayReduction[currentSelection.ActiveEachWay]) + 1;
                            }
                        }
                        if (currentSelection.IDFOPriceType[currentSelection.ActivePriceType] !== 'SP') {
                            betReturn = betSlipInbound.Bets[i].WinStake * betReturn;
                        }
                    }
                    else {
                        betReturn = -2;
                    }
                }
                else {
                    if (Object.keyExists(this._potentialReturns$1.PerBetType, betSlipInbound.Bets[i].IDFOBetType)) {
                        var currentCalculatedBet = this._potentialReturns$1.PerBetType[betSlipInbound.Bets[i].IDFOBetType];
                        betReturn = (hasSP) ? -1 : betSlipInbound.Bets[i].WinStake * currentCalculatedBet.PotentialReturn;
                        unitCount = currentCalculatedBet.UnitCount;
                        if (isEachWay) {
                            unitCount *= 2;
                        }
                    }
                    else {
                        betReturn = -2;
                    }
                }
                var calcBet = new FixedOddsBettingService.CalculatedBet(betReturn, betSlipInbound.Bets[i].WinStake * unitCount, unitCount, betSlipInbound.Bets[i].IDFOBetType);
                if (!String.isNullOrEmpty(selectionKey)) {
                    adjustedResult.PerSelection[selectionKey] = calcBet;
                }
                else {
                    adjustedResult.PerBetType[betSlipInbound.Bets[i].IDFOBetType] = calcBet;
                }
            }
            adjustedResult = (betSlipInbound.IsFree) ? FixedOddsBettingService.FixedOddsBettingService.adjustBetSlipCalculationsForFreeBet(adjustedResult, betSlipInbound.IsFree) : adjustedResult;
            this._betSlipCalculation$1 = adjustedResult;
            this._fireBetSlipCalculationChangedEvent$1();
        }
    },
    
    _recalculateReturnForBetType$1: function BetSlipService_BetSlipService$_recalculateReturnForBetType$1(IDFOBetType, isEachWay) {
        this._recalculateEWReturnForBetType$1++;
        var recalculateEWReturnForBetType = this._recalculateEWReturnForBetType$1;
        var betLegs = this._forceFixedOddsPrice$1(this._getBetLegs$1(true, null));
        this._environment.invokeAsync('FixedOddsBettingService', 'GetReturnForBetType', { bet: new FixedOddsBettingService.BetInbound(betLegs, IDFOBetType, null, null, false, 1, (isEachWay) ? 1 : 0, null) }, Delegate.create(this, function(result) {
            if (recalculateEWReturnForBetType === this._recalculateEWReturnForBetType$1) {
                this._potentialReturns$1.PerBetType[IDFOBetType] = result;
                this._recalculateBetSlip$1();
            }
        }), Delegate.create(this, function(exception) {
            BetSlipService.BetSlipService._log$1.debug('SetIsEachWayPerBetType Cannot recalculate potential return');
        }));
    },
    
    _getKey$1: function BetSlipService_BetSlipService$_getKey$1(IDFOSelection1, IDFOSelection2) {
        return String.format('{0}{1}{2}', IDFOSelection1, BetSlipService.BetSlipService._keySeparator$1, IDFOSelection2);
    },
    
    _getLeft$1: function BetSlipService_BetSlipService$_getLeft$1(key) {
        return key.split(BetSlipService.BetSlipService._keySeparator$1)[0];
    },
    
    _getRight$1: function BetSlipService_BetSlipService$_getRight$1(key) {
        return key.split(BetSlipService.BetSlipService._keySeparator$1)[1];
    },
    
    _compareTags$1: function BetSlipService_BetSlipService$_compareTags$1(event1, market1, mtag1, ttagLeft1, ttagRight1, ctag1, event2, market2, mtag2, ttagLeft2, ttagRight2, ctag2) {
        if (market1 === market2) {
            return 0;
        }
        else if (event1 === event2 && this._compareTag$1(mtag1, mtag2)) {
            return 1;
        }
        else if (event1 !== event2 && (this._compareTag$1(ttagLeft1, ttagRight2) || this._compareTag$1(ttagRight1, ttagLeft2))) {
            return 2;
        }
        else if (event1 !== event2 && this._compareTag$1(ctag1, ctag2)) {
            return 3;
        }
        return -1;
    },
    
    _compareTag$1: function BetSlipService_BetSlipService$_compareTag$1(tag1, tag2) {
        if (String.isNullOrEmpty(tag1) || String.isNullOrEmpty(tag2)) {
            return false;
        }
        var ttagSeparator1 = tag1.indexOf(':');
        var ttagSeparator2 = tag2.indexOf(':');
        if (ttagSeparator1 >= 0 && ttagSeparator2 >= 0) {
            var parts1 = tag1.split(':');
            var parts2 = tag2.split(':');
            if (parts1.length >= 2 && parts2.length >= 2) {
                var comps1 = parts1[0].split('|');
                var comps2 = parts2[0].split('|');
                for (var i = 0; i < comps1.length; i++) {
                    for (var j = 0; j < comps2.length; j++) {
                        if (comps1[i] === comps2[j]) {
                            var deps1 = parts1[1].split(',');
                            var deps2 = parts2[1].split(',');
                            for (var m = 0; m < deps1.length; m++) {
                                for (var n = 0; n < deps2.length; n++) {
                                    if (deps1[m] === '*' || deps2[n] === '*' || deps1[m] === deps2[n]) {
                                        return true;
                                    }
                                }
                            }
                            return false;
                        }
                    }
                }
            }
            return false;
        }
        else if (ttagSeparator1 < 0 && ttagSeparator2 < 0) {
            var tags1 = tag1.split('!');
            var tags2 = tag2.split('!');
            for (var i = 0; i < tags1.length; i++) {
                var parts1 = tags1[i].split('|');
                for (var j = 0; j < tags2.length; j++) {
                    var parts2 = tags2[j].split('|');
                    if (parts1[0] === parts2[0] && parts1.length >= 2 && parts2.length >= 2) {
                        var deps1 = parts1[1].split(',');
                        var deps2 = parts2[1].split(',');
                        for (var m = 0; m < deps1.length; m++) {
                            for (var n = 0; n < deps2.length; n++) {
                                if (deps1[m] === '*' || deps2[n] === '*' || deps1[m] === deps2[n]) {
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
            return false;
        }
        else {
            throw new Error(String.format('Incompatible tags {0} & {1}', tag1, tag2));
        }
    },
    
    _forceFixedOddsPrice$1: function BetSlipService_BetSlipService$_forceFixedOddsPrice$1(betLegs) {
        var $enum1 = betLegs.getEnumerator();
        while ($enum1.moveNext()) {
            var leg = $enum1.get_current();
            if (!leg.IDFOEventScorecast) {
                var thisSelection = this._selections$1[leg.IDFOSelection.toString()];
                if (thisSelection.FixedOddsPriceTypes && thisSelection.FixedOddsPriceTypes.length > 0) {
                    leg.IDFOPriceType = thisSelection.FixedOddsPriceTypes[0];
                }
            }
        }
        return betLegs;
    },
    
    _startBetSlipLiveUpdateTimer$1: function BetSlipService_BetSlipService$_startBetSlipLiveUpdateTimer$1() {
        this._clearBetSlipLiveUpdateTimeout$1();
        this._currentTimeout$1 = window.setTimeout(Delegate.create(this, function() {
            this._updateBetSlipSelections$1();
            this._startBetSlipLiveUpdateTimer$1();
        }), this._liveUpdatePeriod$1);
    },
    
    _clearBetSlipLiveUpdateTimeout$1: function BetSlipService_BetSlipService$_clearBetSlipLiveUpdateTimeout$1() {
        if (this._currentTimeout$1 !== -1) {
            window.clearTimeout(this._currentTimeout$1);
        }
    },
    
    getSimpleSelectionKey: function BetSlipService_BetSlipService$getSimpleSelectionKey(IDFOSelection) {
        return IDFOSelection.toString();
    },
    
    getScorecastSelectionKey: function BetSlipService_BetSlipService$getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        return String.format('{0}-{1}-{2}', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
    },
    
    getSelectionKey: function BetSlipService_BetSlipService$getSelectionKey(selection) {
        return (!selection.IDFOEventScorecast) ? this.getSimpleSelectionKey(selection.IDFOSelection) : this.getScorecastSelectionKey(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS);
    },
    
    _getScorecastLegKey1GS$1: function BetSlipService_BetSlipService$_getScorecastLegKey1GS$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        return this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
    },
    
    _getScorecastLegKeyCS$1: function BetSlipService_BetSlipService$_getScorecastLegKeyCS$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        return String.format('CS-{0}-{1}-{2}', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
    },
    
    checkIfBetSlipHasStake: function BetSlipService_BetSlipService$checkIfBetSlipHasStake() {
        var $dict1 = this._stakePerSelection$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.value && entry.value) {
                return true;
            }
        }
        var $dict3 = this._stakePerBetType$1;
        for (var $key4 in $dict3) {
            var entry = { key: $key4, value: $dict3[$key4] };
            if (entry.value && entry.value) {
                return true;
            }
        }
        return false;
    },
    
    checkIfBetSlipHasCalculation: function BetSlipService_BetSlipService$checkIfBetSlipHasCalculation() {
        if (Object.getKeyCount(this._betSlipCalculation$1.PerBetType) || Object.getKeyCount(this._betSlipCalculation$1.PerSelection)) {
            return true;
        }
        else {
            return false;
        }
    },
    
    setRetainSelectionsAfterPlacement: function BetSlipService_BetSlipService$setRetainSelectionsAfterPlacement(retainSelectionsAfterPlacement) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetRetainSelectionsAfterPlacement retainSelectionsAfterPlacement=[{0}]', retainSelectionsAfterPlacement));
        this._retainSelectionsAfterPlacement$1 = retainSelectionsAfterPlacement;
        this._fireBetSlipCalculationChangedEvent$1();
    },
    
    setIsFree: function BetSlipService_BetSlipService$setIsFree(isFree) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetIsFree isFree=[{0}]', isFree));
        this._isFree$1 = isFree;
        this._recalculateBetSlip$1();
    },
    
    addSelection: function BetSlipService_BetSlipService$addSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, isTrapBettingOptionOn, HADValue, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, fixedOddsPriceTypes, selectionHashCode, isTradable) {
        BetSlipService.BetSlipService._log$1.debug(String.format('AddSelection IDFOPriceType=[{0}] activePriceType=[{1}] IDFOEvent=[{2}] eventName=[{3}] IDFOMarket=[{4}] marketName=[{5}] MTag=[{6}] TTagLeft=[{7}] TTagRight=[{8}] CTag=[{9}] handicap=[{10}] upperBand=[{11}] lowerBand=[{12}] eachWayReduction=[{13}] eachWayPlaceTerms=[{14}] IDFOSelection=[{15}] selectionName=[{16}] priceUp=[{17}] priceDown=[{18}] activeBetTypes=[{19}] fixedOddsPriceTypes=[{20}]', IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, fixedOddsPriceTypes));
        var selection = FixedOddsBettingService.Selection.createSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, isTrapBettingOptionOn, HADValue, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, fixedOddsPriceTypes, selectionHashCode, isTradable);
        this._selections$1[this.getSimpleSelectionKey(IDFOSelection)] = selection;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
        this._fireSelectionsAddedEvent$1([ selection ]);
    },
    
    addScorecastSelection: function BetSlipService_BetSlipService$addScorecastSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS, selectionHashCode, isTradable) {
        BetSlipService.BetSlipService._log$1.debug(String.format('AddScorecastSelection IDFOPriceType=[{0}] IDFOEvent=[{1}] eventName=[{2}] IDFOMarket1GS=[{3}] marketName1GS=[{4}] MTag=[{5}] TTagLeft=[{6}] TTagRight=[{7}] CTag=[{8}] IDFOSelection1GS=[{9}] selectionName1GS=[{10}] priceUp1GS=[{11}] priceDown1GS=[{12}] IDFOEventScorecast=[{13}] IDFOMarketCS=[{14}] marketNameCS=[{15}] IDFOSelectionCS=[{16}] selectionNameCS=[{17}] priceUpCS=[{18}] priceDownCS=[{19}]', IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS));
        var selection = FixedOddsBettingService.Selection.createScorecastSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionNameCS + '/' + selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS, selectionHashCode, isTradable);
        selection.ActiveBetTypes = 'S';
        this._selections$1[this.getScorecastSelectionKey(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS)] = selection;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
        this._fireSelectionsAddedEvent$1([ selection ]);
    },
    
    removeSelection: function BetSlipService_BetSlipService$removeSelection(IDFOSelection) {
        BetSlipService.BetSlipService._log$1.debug(String.format('RemoveSelection IDFOSelection=[{0}]', IDFOSelection));
        var selectionKey = this.getSimpleSelectionKey(IDFOSelection);
        if (Object.keyExists(this._selections$1, selectionKey)) {
            var selection = this._selections$1[selectionKey];
            delete this._selections$1[selectionKey];
            delete this._previousSelections$1[selectionKey];
            delete this._stakePerSelection$1[selectionKey];
            this._recalculateInterrelation$1();
            this._recalculateAllowedBetTypesAndReturns$1();
            this._fireSelectionsRemovedEvent$1([ selection ]);
        }
    },
    
    removeScorecastSelection: function BetSlipService_BetSlipService$removeScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        BetSlipService.BetSlipService._log$1.debug(String.format('RemoveScorecastSelection IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        var selectionKey = this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        if (Object.keyExists(this._selections$1, selectionKey)) {
            var selection = this._selections$1[selectionKey];
            delete this._selections$1[selectionKey];
            delete this._previousSelections$1[selectionKey];
            delete this._stakePerSelection$1[selectionKey];
            this._recalculateInterrelation$1();
            this._recalculateAllowedBetTypesAndReturns$1();
            this._fireSelectionsRemovedEvent$1([ selection ]);
        }
    },
    
    removeAllSelections: function BetSlipService_BetSlipService$removeAllSelections() {
        BetSlipService.BetSlipService._log$1.debug('RemoveAllSelections');
        var selections = new Array(Object.getKeyCount(this._selections$1));
        var i = 0;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            selections[i++] = entry.value;
        }
        this._selections$1 = {};
        this._stakePerBetType$1 = {};
        this._stakePerSelection$1 = {};
        this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
        this._fireSelectionsRemovedEvent$1(selections);
    },
    
    setSimpleSelectionActivity: function BetSlipService_BetSlipService$setSimpleSelectionActivity(IDFOSelection, isActive) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionActivity IDFOSelection=[{0}] isActive=[{1}]', IDFOSelection, isActive));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.IsActive = isActive;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
    },
    
    setScorecastSelectionActivity: function BetSlipService_BetSlipService$setScorecastSelectionActivity(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetScorecastSelectionActivity IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive));
        var selection = this._selections$1[this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS)];
        selection.IsActive = isActive;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
    },
    
    setSimpleSelectionIsTrap: function BetSlipService_BetSlipService$setSimpleSelectionIsTrap(IDFOSelection, isTrap) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionIsTrap IDFOSelection=[{0}] isTrap=[{1}]', IDFOSelection, isTrap));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.IsTrap = isTrap;
    },
    
    setSimpleSelectionPriceType: function BetSlipService_BetSlipService$setSimpleSelectionPriceType(IDFOSelection, activePriceType) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionPriceType IDFOSelection=[{0}] activePriceType=[{1}]', IDFOSelection, activePriceType));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.ActivePriceType = activePriceType;
        this._recalculateBetSlip$1();
    },
    
    setScorecastSelectionPriceType: function BetSlipService_BetSlipService$setScorecastSelectionPriceType(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetScorecastSelectionPriceType IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType));
        var selection = this._selections$1[this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS)];
        selection.ActivePriceType = activePriceType;
        this._recalculateBetSlip$1();
    },
    
    setSimpleSelectionEachWay: function BetSlipService_BetSlipService$setSimpleSelectionEachWay(IDFOSelection, activeEachWay) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionEachWay IDFOSelection=[{0}] activeEachWay=[{1}]', IDFOSelection, activeEachWay));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.ActiveEachWay = activeEachWay;
        this._recalculateBetSlip$1();
    },
    
    clearStakes: function BetSlipService_BetSlipService$clearStakes() {
        BetSlipService.BetSlipService._log$1.debug('ClearStakes');
        this._stakePerBetType$1 = {};
        this._stakePerSelection$1 = {};
        this._recalculateBetSlip$1();
    },
    
    setIsEachWayPerBetType: function BetSlipService_BetSlipService$setIsEachWayPerBetType(IDFOBetType, isEachWay) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetIsEachWayPerBetType IDFOBetType=[{0}] isEachWay=[{1}]', IDFOBetType, isEachWay));
        this._isEachWayPerBetType$1[IDFOBetType] = isEachWay;
        this._recalculateReturnForBetType$1(IDFOBetType, isEachWay);
    },
    
    setStakePerBetType: function BetSlipService_BetSlipService$setStakePerBetType(IDFOBetType, stake, deleteAllPrevious) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetStakePerBetType IDFOBetType=[{0}] stake=[{1}] deleteAllPrevious=[{2}]', IDFOBetType, stake, deleteAllPrevious));
        if (deleteAllPrevious) {
            this._stakePerBetType$1 = {};
        }
        if (isNaN(stake) || !stake) {
            stake = null;
        }
        if (!IDFOBetType && this._allowedBetTypes$1.length > 0) {
            IDFOBetType = this._allowedBetTypes$1[0].IDFOBetType;
        }
        if (stake && IDFOBetType) {
            this._stakePerBetType$1[IDFOBetType] = stake;
        }
        else if (!stake && IDFOBetType) {
            delete this._stakePerBetType$1[IDFOBetType];
        }
        this._recalculateBetSlip$1();
    },
    
    setStakePerSelection: function BetSlipService_BetSlipService$setStakePerSelection(IDFOSelection, winStake) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetStakePerSelection IDFOSelection=[{0}] winStake=[{1}]', IDFOSelection, winStake));
        var selectionKey = this.getSimpleSelectionKey(IDFOSelection);
        if (!winStake || isNaN(winStake) || !winStake) {
            delete this._stakePerSelection$1[selectionKey];
        }
        else {
            this._stakePerSelection$1[selectionKey] = winStake;
        }
        this._recalculateBetSlip$1();
    },
    
    setStakePerScorecastSelection: function BetSlipService_BetSlipService$setStakePerScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, winStake) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetStakePerScorecastSelection IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] winStake=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, winStake));
        var selectionKey = this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        if (!winStake || isNaN(winStake)) {
            delete this._stakePerSelection$1[selectionKey];
        }
        else {
            this._stakePerSelection$1[selectionKey] = winStake;
        }
        this._recalculateBetSlip$1();
    },
    
    changeBetSlipLiveUpdateTimerStatus: function BetSlipService_BetSlipService$changeBetSlipLiveUpdateTimerStatus(enableTimer) {
        if (!this._betSlipLiveUpdate$1) {
            return;
        }
        else if (enableTimer && this._currentTimeout$1 === -1) {
            this._startBetSlipLiveUpdateTimer$1();
        }
        else if (!enableTimer && this._currentTimeout$1 !== -1) {
            this._clearBetSlipLiveUpdateTimeout$1();
            this._currentTimeout$1 = -1;
        }
    },
    
    _recalculateInterrelation$1: function BetSlipService_BetSlipService$_recalculateInterrelation$1() {
        var graph = {};
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var entry1 = { key: $key2, value: $dict1[$key2] };
            var selection1 = entry1.value;
            var IDFOSelection1 = selection1.IDFOSelection;
            var $dict3 = this._selections$1;
            for (var $key4 in $dict3) {
                var entry2 = { key: $key4, value: $dict3[$key4] };
                var selection2 = entry2.value;
                var IDFOSelection2 = selection2.IDFOSelection;
                if (IDFOSelection1 >= IDFOSelection2) {
                    continue;
                }
                var ir = this._compareTags$1(selection1.IDFOEvent, selection1.IDFOMarket, selection1.MTag, selection1.TTagLeft, selection1.TTagRight, selection1.CTag, selection2.IDFOEvent, selection2.IDFOMarket, selection2.MTag, selection2.TTagLeft, selection2.TTagRight, selection2.CTag);
                if (ir >= 0) {
                    graph[this._getKey$1(IDFOSelection1, IDFOSelection2)] = graph[this._getKey$1(IDFOSelection2, IDFOSelection1)] = ir;
                }
            }
        }
        var color = 1;
        var result = {};
        var $dict5 = graph;
        for (var $key6 in $dict5) {
            var entry = { key: $key6, value: $dict5[$key6] };
            var IDFOSelection1 = this._getLeft$1(entry.key);
            var IDFOSelection2 = this._getRight$1(entry.key);
            if (Object.keyExists(result, IDFOSelection1)) {
                result[IDFOSelection2] = result[IDFOSelection1];
            }
            else if (Object.keyExists(result, IDFOSelection2)) {
                result[IDFOSelection1] = result[IDFOSelection2];
            }
            else {
                result[IDFOSelection1] = result[IDFOSelection2] = color++;
            }
        }
        this._selectionsInterRelationColors$1 = result;
    },
    
    isSelectionIn: function BetSlipService_BetSlipService$isSelectionIn(IDFOSelection, IDFOEventScorecast, IDFOSelectionCS) {
        var isIn = false;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var singleSelection = { key: $key2, value: $dict1[$key2] };
            var selection = singleSelection.value;
            if (!selection.IDFOEventScorecast) {
                isIn = (selection.IDFOSelection === IDFOSelection);
                if (isIn) {
                    break;
                }
            }
            else {
                isIn = (selection.IDFOEventScorecast === IDFOEventScorecast && selection.IDFOSelection === IDFOSelection && selection.IDFOSelectionCS === IDFOSelectionCS);
                if (isIn) {
                    break;
                }
            }
        }
        return isIn;
    },
    
    placeBetSlip: function BetSlipService_BetSlipService$placeBetSlip(isBetConfirmationScreenShownBeforePlacementOverride) {
        BetSlipService.BetSlipService._log$1.debug('PlaceBetSlip');
        var sentSelections = {};
        if (Object.getKeyCount(this._stakePerBetType$1) > 0) {
            var $dict1 = this._selections$1;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                sentSelections[entry.key] = entry.value;
            }
        }
        else {
            var $dict3 = this._stakePerSelection$1;
            for (var $key4 in $dict3) {
                var entry = { key: $key4, value: $dict3[$key4] };
                sentSelections[entry.key] = this._selections$1[entry.key];
            }
        }
        var calculatedBet = [];
        var $dict5 = this._selections$1;
        for (var $key6 in $dict5) {
            var singleSelection = { key: $key6, value: $dict5[$key6] };
            if (Object.keyExists(this._stakePerSelection$1, singleSelection.key)) {
                calculatedBet.add(this._betSlipCalculation$1.PerSelection[singleSelection.key]);
            }
        }
        var $dict7 = this._stakePerBetType$1;
        for (var $key8 in $dict7) {
            var stakePerBetTypeEntry = { key: $key8, value: $dict7[$key8] };
            calculatedBet.add(this._betSlipCalculation$1.PerBetType[stakePerBetTypeEntry.key]);
        }
        this._fixedOddsBettingService$1.placeBetSlip(sentSelections, calculatedBet, this._getBetSlipInbound$1(), isBetConfirmationScreenShownBeforePlacementOverride);
    }
}


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.OverridingPriceTypes

BetSlipService.OverridingPriceTypes = function BetSlipService_OverridingPriceTypes() {
}


BetSlipService.BetSlipService.createClass('BetSlipService.BetSlipService', Framework.AbstractService, Framework.IPageWillChangeListener, FixedOddsBettingService.IBetPlacementStateChangedListener);
BetSlipService.OverridingPriceTypes.createClass('BetSlipService.OverridingPriceTypes');
BetSlipService.BetSlipService._serviceName$1 = 'BetSlipService';
BetSlipService.BetSlipService._log$1 = Framework.Logger.getLog(BetSlipService.BetSlipService._serviceName$1);
BetSlipService.BetSlipService._keySeparator$1 = ':';
BetSlipService.OverridingPriceTypes.priceTypeOverrides = { SFC: 'FCD', RFC: 'FCD', CFC: 'FCD', SFC2: 'FCD', RFC2: 'FCD', CFC2: 'FCD', SFC3: 'FCD', RFC3: 'FCD', CFC3: 'FCD', SFCP: 'FCD', RFCP: 'FCD', SFCY: 'FCD', RFCY: 'FCD', SFCL15: 'FCD', RFCL15: 'FCD', EX: 'EPD', REX: 'EPD', CEX: 'EPD', QU: 'QPD', CQU: 'QPD', STC: 'TCD', CTC: 'TCD', STF: 'TPD', CTF: 'TPD' };

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('RacePoolBetSlipService');

////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener

RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener = function() { };
RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener.prototype = {
    onRacePoolBetSlipCalculationChanged : null
}
RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener.createInterface('RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener');


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.IRacePoolSelectionsRemovedListener

RacePoolBetSlipService.IRacePoolSelectionsRemovedListener = function() { };
RacePoolBetSlipService.IRacePoolSelectionsRemovedListener.prototype = {
    onRacePoolSelectionsRemoved : null
}
RacePoolBetSlipService.IRacePoolSelectionsRemovedListener.createInterface('RacePoolBetSlipService.IRacePoolSelectionsRemovedListener');


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.IRacePoolSelectionsAddedListener

RacePoolBetSlipService.IRacePoolSelectionsAddedListener = function() { };
RacePoolBetSlipService.IRacePoolSelectionsAddedListener.prototype = {
    onRacePoolSelectionsAdded : null
}
RacePoolBetSlipService.IRacePoolSelectionsAddedListener.createInterface('RacePoolBetSlipService.IRacePoolSelectionsAddedListener');


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.RacePool

RacePoolBetSlipService.RacePool = function RacePoolBetSlipService_RacePool(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections) {
    this.idfoMarket = IDFOMarket;
    this.idfoPriceType = IDFOPriceType;
    this.racePoolTab = racePoolTab;
    this.minNoSelections = minNoSelections;
    this.selections = {};
    this.selectionsPlaces = {};
    this.isAnyOrderRacePool = false;
}
RacePoolBetSlipService.RacePool.prototype = {
    idfoMarket: null,
    idfoPriceType: null,
    priceTypeName: null,
    idfoBetType: null,
    betTypeName: null,
    racePoolTab: null,
    minNoSelections: null,
    selectionsPlaces: null,
    selections: null,
    unitStake: null,
    calculatedBet: null,
    unscaledCalculatedBet: null,
    isAnyOrderRacePool: false
}


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.RacePoolBetSlipService

RacePoolBetSlipService.RacePoolBetSlipService = function RacePoolBetSlipService_RacePoolBetSlipService() {
    this._racePoolRaceTabsManagers$1 = {};
    this._racePools$1 = {};
    this._racePoolBetSlipCalculationChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._racePoolSelectionsAddedListeners$1 = new Framework.ListenerInvoker(true);
    this._racePoolSelectionsRemovedListeners$1 = new Framework.ListenerInvoker(true);
    RacePoolBetSlipService.RacePoolBetSlipService.constructBase(this);
}
RacePoolBetSlipService.RacePoolBetSlipService.prototype = {
    
    onPageWillChange: function RacePoolBetSlipService_RacePoolBetSlipService$onPageWillChange() {
        this._environment.storeState(RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1, this._getState$1());
    },
    
    _fixedOddsBettingService$1: null,
    
    setFixedOddsBettingService: function RacePoolBetSlipService_RacePoolBetSlipService$setFixedOddsBettingService(fixedOddsBettingService) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService$1 = fixedOddsBettingService;
    },
    
    _userService$1: null,
    
    setUserService: function RacePoolBetSlipService_RacePoolBetSlipService$setUserService(userService) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('SetUserService');
        this._userService$1 = userService;
    },
    
    init: function RacePoolBetSlipService_RacePoolBetSlipService$init(environment, parameters) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        RacePoolBetSlipService.RacePoolBetSlipService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
    },
    
    start: function RacePoolBetSlipService_RacePoolBetSlipService$start() {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('Start');
    },
    
    registerRacePoolBetSlipCalculationChangedListener: function RacePoolBetSlipService_RacePoolBetSlipService$registerRacePoolBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('RegisterRacePoolBetSlipCalculationChangedListener');
        this._racePoolBetSlipCalculationChangedListeners$1.registerListener(betSlipCalculationChangedListener);
    },
    
    unregisterRacePoolBetSlipCalculationChangedListener: function RacePoolBetSlipService_RacePoolBetSlipService$unregisterRacePoolBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('UnregisterRacePoolBetSlipCalculationChangedListener');
        this._racePoolBetSlipCalculationChangedListeners$1.unregisterListener(betSlipCalculationChangedListener);
    },
    
    _fireRacePoolBetSlipCalculationChangedEvent$1: function RacePoolBetSlipService_RacePoolBetSlipService$_fireRacePoolBetSlipCalculationChangedEvent$1(IDFOMarket, IDFOPriceType) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('FireRacePoolBetSlipCalculationChangedEvent');
        this._racePoolBetSlipCalculationChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onRacePoolBetSlipCalculationChanged(IDFOMarket, IDFOPriceType);
        }));
    },
    
    registerRacePoolSelectionsAddedListener: function RacePoolBetSlipService_RacePoolBetSlipService$registerRacePoolSelectionsAddedListener(selectionAddedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('RegisterRacePoolSelectionsAddedListener');
        this._racePoolSelectionsAddedListeners$1.registerListener(selectionAddedListener);
    },
    
    unregisterRacePoolSelectionsAddedListener: function RacePoolBetSlipService_RacePoolBetSlipService$unregisterRacePoolSelectionsAddedListener(selectionAddedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('UnregisterRacePoolSelectionsAddedListener');
        this._racePoolSelectionsAddedListeners$1.unregisterListener(selectionAddedListener);
    },
    
    _fireRacePoolSelectionsAddedEvent$1: function RacePoolBetSlipService_RacePoolBetSlipService$_fireRacePoolSelectionsAddedEvent$1(IDFOMarket, selection, selectionsPlaces) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('FireRacePoolSelectionsAddedEvent');
        this._racePoolSelectionsAddedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onRacePoolSelectionsAdded(IDFOMarket, selection, selectionsPlaces);
        }));
    },
    
    registerRacePoolSelectionsRemovedListener: function RacePoolBetSlipService_RacePoolBetSlipService$registerRacePoolSelectionsRemovedListener(selectionRemovedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('RegisterRacePoolSelectionsRemovedListener');
        this._racePoolSelectionsRemovedListeners$1.registerListener(selectionRemovedListener);
    },
    
    unregisterRacePoolSelectionsRemovedListener: function RacePoolBetSlipService_RacePoolBetSlipService$unregisterRacePoolSelectionsRemovedListener(selectionRemovedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('UnregisterRacePoolSelectionsRemovedListener');
        this._racePoolSelectionsRemovedListeners$1.unregisterListener(selectionRemovedListener);
    },
    
    _fireRacePoolSelectionRemovedEvent$1: function RacePoolBetSlipService_RacePoolBetSlipService$_fireRacePoolSelectionRemovedEvent$1(IDFOMarket, selection, selectionsPlaces) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('FireRacePoolSelectionsRemovedEvent');
        this._racePoolSelectionsRemovedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onRacePoolSelectionsRemoved(IDFOMarket, selection, selectionsPlaces);
        }));
    },
    
    getRacePool: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePool(IDFOMarket, IDFOPriceType) {
        var racePoolKey = this._getRacePoolKey$1(IDFOMarket, IDFOPriceType);
        if (Object.keyExists(this._racePools$1, racePoolKey)) {
            return this._racePools$1[racePoolKey];
        }
        else {
            return null;
        }
    },
    
    getRacePools: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePools() {
        return this._racePools$1;
    },
    
    getRacePoolRaceTabsManager: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePoolRaceTabsManager(IDFOMarket) {
        return this._racePoolRaceTabsManagers$1[this._getRacePoolRaceTabsManagerKey$1(IDFOMarket)];
    },
    
    getRacePoolRaceTabsManagers: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePoolRaceTabsManagers() {
        return this._racePoolRaceTabsManagers$1;
    },
    
    setRacePoolActiveTab: function RacePoolBetSlipService_RacePoolBetSlipService$setRacePoolActiveTab(IDFOMarket, racePoolTab) {
        if (Object.keyExists(this._racePoolRaceTabsManagers$1, this._getRacePoolRaceTabsManagerKey$1(IDFOMarket))) {
            (this._racePoolRaceTabsManagers$1[this._getRacePoolRaceTabsManagerKey$1(IDFOMarket)]).activeRacePoolTab = racePoolTab;
        }
    },
    
    addRacePoolSelection: function RacePoolBetSlipService_RacePoolBetSlipService$addRacePoolSelection(IDFOMarket, IDFOPriceType, racePoolTab, selectionPlace, minNoSelections, IDFOEvent, eventName, marketName, MTag, TTagLeft, TTagRight, CTag, IDFOSelection, selectionName) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (!racePool) {
            racePool = new RacePoolBetSlipService.RacePool(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections);
            this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)] = racePool;
        }
        if (selectionPlace !== RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1 && Object.keyExists(racePool.selectionsPlaces, selectionPlace)) {
            this.removeRacePoolSelection(IDFOMarket, IDFOPriceType, Number.parse((racePool.selectionsPlaces[selectionPlace])[0].toString()), selectionPlace);
        }
        var selection = FixedOddsBettingService.Selection.createRacePoolSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, IDFOSelection, selectionName);
        racePool.selections[this._getRacePoolSelectionKey$1(IDFOSelection)] = selection;
        this._addSelection$1(racePool, selectionPlace, IDFOSelection);
        this._fireRacePoolSelectionsAddedEvent$1(IDFOMarket, [ selection ], [ selectionPlace ]);
        if (selectionPlace === RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1) {
            racePool.isAnyOrderRacePool = true;
        }
        else {
            racePool.isAnyOrderRacePool = false;
        }
        var removedSelections = [];
        var removedSelectionPlaces = [];
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var currentSelectionPlace = entry.key;
            if ((racePool.isAnyOrderRacePool && currentSelectionPlace !== RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1) || (!racePool.isAnyOrderRacePool && currentSelectionPlace === RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1)) {
                var IDFOSelections = entry.value;
                for (var i = 0; i < IDFOSelections.length; i++) {
                    removedSelections.add(racePool.selections[this._getRacePoolSelectionKey$1(Number.parse(IDFOSelections[i].toString()))]);
                    removedSelectionPlaces.add(currentSelectionPlace);
                }
            }
        }
        if (removedSelections.length > 0) {
            this._removeRacePoolSelections$1(IDFOMarket, IDFOPriceType, removedSelections, removedSelectionPlaces);
        }
        else {
            this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'selection');
        }
    },
    
    removeRacePoolSelection: function RacePoolBetSlipService_RacePoolBetSlipService$removeRacePoolSelection(IDFOMarket, IDFOPriceType, IDFOSelection, sectionPlace) {
        if (this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)] && Object.keyExists((this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)]).selections, this._getRacePoolSelectionKey$1(IDFOSelection))) {
            this._removeRacePoolSelections$1(IDFOMarket, IDFOPriceType, [ (this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)]).selections[this._getRacePoolSelectionKey$1(IDFOSelection)] ], [ sectionPlace ]);
        }
    },
    
    checkRacePoolSelections: function RacePoolBetSlipService_RacePoolBetSlipService$checkRacePoolSelections(IDFOMarket, IDFOPriceType) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (!racePool) {
            return 'skip';
        }
        else if (!this._racePoolHasValidSelections$1(racePool)) {
            return 'Please complete making your selections for ' + this._getRacePoolName$1(racePool) + ' (or clear its form if you don\'t want to place it)';
        }
        else if (!this._racePoolHasStake$1(racePool)) {
            return 'Please enter a stake greater than zero for ' + this._getRacePoolName$1(racePool) + ' (or clear its form if you don\'t want to place it)';
        }
        else {
            return '';
        }
    },
    
    placeRacePoolBetSlip: function RacePoolBetSlipService_RacePoolBetSlipService$placeRacePoolBetSlip(IDFOMarket, IDFOPriceTypes) {
        var calculatedBets = [];
        var selections = {};
        var racePools = [];
        var $enum1 = IDFOPriceTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var priceType = $enum1.get_current();
            var racePool = this.getRacePool(IDFOMarket, priceType);
            calculatedBets.add(racePool.calculatedBet);
            racePools.add(racePool);
            var $dict2 = racePool.selections;
            for (var $key3 in $dict2) {
                var entry = { key: $key3, value: $dict2[$key3] };
                if (!Object.keyExists(selections, entry.key)) {
                    selections[entry.key] = entry.value;
                }
            }
        }
        this._fixedOddsBettingService$1.placeBetSlip(selections, calculatedBets, this._getBetSlipInbound$1(racePools), FixedOddsBettingService.OverrideToShowConfirmation.notOverride);
        var $enum4 = IDFOPriceTypes.getEnumerator();
        while ($enum4.moveNext()) {
            var priceType = $enum4.get_current();
            this.removeAllRacePoolSelections(IDFOMarket, priceType);
        }
    },
    
    setRacePoolStake: function RacePoolBetSlipService_RacePoolBetSlipService$setRacePoolStake(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections, unitStake, racePoolName) {
        var racePool = this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)];
        if (!racePool) {
            racePool = new RacePoolBetSlipService.RacePool(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections);
            this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)] = racePool;
        }
        racePool.unitStake = unitStake;
        racePool.betTypeName = racePoolName;
        this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'stake');
    },
    
    addTabToRacePoolRaceTabsManager: function RacePoolBetSlipService_RacePoolBetSlipService$addTabToRacePoolRaceTabsManager(IDFOMarket, racePoolTab) {
        var key = this._getRacePoolRaceTabsManagerKey$1(IDFOMarket);
        if (!Object.keyExists(this._racePoolRaceTabsManagers$1, key)) {
            this._racePoolRaceTabsManagers$1[key] = new RacePoolBetSlipService.RacePoolRaceTabsManager(IDFOMarket);
        }
        if (!(this._racePoolRaceTabsManagers$1[key]).racePoolTabs.contains(racePoolTab)) {
            (this._racePoolRaceTabsManagers$1[key]).racePoolTabs.add(racePoolTab);
        }
    },
    
    removeAllRacePoolSelections: function RacePoolBetSlipService_RacePoolBetSlipService$removeAllRacePoolSelections(IDFOMarket, IDFOPriceType) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        var selections = [];
        var selectionsPlaces = [];
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var currentSelectionPlace = entry.key;
            if (racePool.selectionsPlaces[currentSelectionPlace]) {
                var currentIDFOSelections = racePool.selectionsPlaces[currentSelectionPlace];
                for (var i = 0; i < currentIDFOSelections.length; i++) {
                    selections.add(racePool.selections[currentIDFOSelections[i].toString()]);
                    selectionsPlaces.add(currentSelectionPlace);
                }
            }
        }
        delete this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)];
        this._fireRacePoolSelectionRemovedEvent$1(IDFOMarket, selections, selectionsPlaces);
    },
    
    _getRacePoolKey$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolKey$1(IDFOMarket, IDFOPriceType) {
        return String.format('{0}-{1}', IDFOMarket, IDFOPriceType);
    },
    
    _getRacePoolRaceTabsManagerKey$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolRaceTabsManagerKey$1(IDFOMarket) {
        return IDFOMarket.toString();
    },
    
    _getRacePoolSelectionKey$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolSelectionKey$1(IDFOSelection) {
        return IDFOSelection.toString();
    },
    
    _addSelection$1: function RacePoolBetSlipService_RacePoolBetSlipService$_addSelection$1(racePool, selectionPlace, IDFOSelection) {
        if (!Object.keyExists(racePool.selectionsPlaces, selectionPlace) || !racePool.selectionsPlaces[selectionPlace]) {
            racePool.selectionsPlaces[selectionPlace] = [];
        }
        var selectionsPlaces = racePool.selectionsPlaces[selectionPlace];
        if (!selectionsPlaces.contains(IDFOSelection)) {
            selectionsPlaces.add(IDFOSelection);
        }
    },
    
    _removeSelection$1: function RacePoolBetSlipService_RacePoolBetSlipService$_removeSelection$1(racePool, selectionPlace, IDFOSelection) {
        if (Object.keyExists(racePool.selectionsPlaces, selectionPlace)) {
            var selectionsPlaces = racePool.selectionsPlaces[selectionPlace];
            if (selectionsPlaces && selectionsPlaces.contains(IDFOSelection)) {
                selectionsPlaces.remove(IDFOSelection);
                if (!selectionsPlaces.length) {
                    delete racePool.selectionsPlaces[selectionPlace];
                }
            }
        }
    },
    
    _getRacePoolBetLegs$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolBetLegs$1(racePool) {
        var betLegs = [];
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var placeEntry = { key: $key2, value: $dict1[$key2] };
            var currentSelectionPlace = placeEntry.key;
            var IDFOSelections = placeEntry.value;
            if (IDFOSelections) {
                for (var i = 0; i < IDFOSelections.length; i++) {
                    var selection = racePool.selections[IDFOSelections[i].toString()];
                    var currentBetLeg = new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, selection.PriceDown, selection.PriceUp, null, null, selection.IsTrap, null, null, selection.IDFOEventScorecast);
                    if (currentSelectionPlace === RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1) {
                        betLegs.add(currentBetLeg);
                    }
                    else {
                        betLegs[Number.parse(currentSelectionPlace)] = currentBetLeg;
                    }
                }
            }
        }
        return betLegs;
    },
    
    _getBetSlipInbound$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getBetSlipInbound$1(racePools) {
        var bets = [];
        var $enum1 = racePools.getEnumerator();
        while ($enum1.moveNext()) {
            var racePool = $enum1.get_current();
            var betLegs = this._getRacePoolBetLegs$1(racePool);
            racePool.idfoBetType = this._getRacePoolBetType$1(racePool);
            bets.add(new FixedOddsBettingService.BetInbound(betLegs, racePool.idfoBetType, racePool.betTypeName, null, false, racePool.unitStake, null, null));
        }
        return new FixedOddsBettingService.BetSlipInbound(false, bets);
    },
    
    _recalculateRacePoolBetReturn$1: function RacePoolBetSlipService_RacePoolBetSlipService$_recalculateRacePoolBetReturn$1(IDFOMarket, IDFOPriceType) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (!Object.getKeyCount(racePool.selections) && !this._racePoolHasStake$1(racePool)) {
            delete this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)];
        }
        else if (this._racePoolHasValidSelections$1(racePool) && this._racePoolHasStake$1(racePool)) {
            var betSlipInbound = this._getBetSlipInbound$1([ racePool ]);
            this._environment.invokeAsync('FixedOddsBettingService', 'CalculateBetSlip', { betSlip: betSlipInbound }, Delegate.create(this, function(result) {
                var returnedCalculation = result;
                for (var i = 0; i < betSlipInbound.Bets.length; i++) {
                    returnedCalculation[i].IDFOBetType = betSlipInbound.Bets[i].IDFOBetType;
                }
                if (returnedCalculation[0]) {
                    racePool.unscaledCalculatedBet = returnedCalculation[0];
                }
                else {
                    racePool.unscaledCalculatedBet = null;
                    racePool.calculatedBet = null;
                    racePool.idfoBetType = '';
                }
                this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'recalculation');
            }), Delegate.create(this, function(exception) {
                if (racePool.unscaledCalculatedBet || racePool.calculatedBet) {
                    racePool.unscaledCalculatedBet = null;
                    racePool.calculatedBet = null;
                    racePool.idfoBetType = '';
                    this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'recalculation');
                }
            }));
        }
    },
    
    _recalculateRacePoolBetSlip$1: function RacePoolBetSlipService_RacePoolBetSlipService$_recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, changeAgent) {
        var recalculate = false;
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (changeAgent === 'selection' && this._racePoolHasStake$1(racePool) && this._racePoolHasValidSelections$1(racePool)) {
            recalculate = true;
        }
        else if (changeAgent === 'recalculation') {
            recalculate = true;
        }
        else if (changeAgent === 'stake') {
            recalculate = true;
        }
        if ((!recalculate && changeAgent === 'selection') || (!racePool.unscaledCalculatedBet && changeAgent === 'recalculation')) {
            if (racePool.unscaledCalculatedBet || racePool.calculatedBet) {
                racePool.unscaledCalculatedBet = null;
                racePool.calculatedBet = null;
                racePool.idfoBetType = '';
                this._fireRacePoolBetSlipCalculationChangedEvent$1(IDFOMarket, IDFOPriceType);
            }
        }
        else {
            if ((!racePool.unscaledCalculatedBet && changeAgent !== 'recalculation') || (changeAgent === 'selection')) {
                this._recalculateRacePoolBetReturn$1(IDFOMarket, IDFOPriceType);
            }
            else {
                racePool.calculatedBet = new FixedOddsBettingService.CalculatedBet(racePool.unscaledCalculatedBet.PotentialReturn, racePool.unitStake * racePool.unscaledCalculatedBet.UnitCount, racePool.unscaledCalculatedBet.UnitCount, racePool.unscaledCalculatedBet.IDFOBetType);
                this._fireRacePoolBetSlipCalculationChangedEvent$1(IDFOMarket, IDFOPriceType);
            }
        }
    },
    
    _racePoolHasStake$1: function RacePoolBetSlipService_RacePoolBetSlipService$_racePoolHasStake$1(racePool) {
        return (racePool && racePool.unitStake) ? true : false;
    },
    
    _racePoolHasValidSelections$1: function RacePoolBetSlipService_RacePoolBetSlipService$_racePoolHasValidSelections$1(racePool) {
        return !String.isNullOrEmpty(this._getRacePoolBetType$1(racePool));
    },
    
    _getState$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getState$1() {
        return { racePools: this._racePools$1, racePoolRaceTabsManagers: this._racePoolRaceTabsManagers$1 };
    },
    
    _setState$1: function RacePoolBetSlipService_RacePoolBetSlipService$_setState$1(state) {
        this._racePools$1 = state['racePools'];
        this._racePoolRaceTabsManagers$1 = state['racePoolRaceTabsManagers'];
    },
    
    _removeRacePoolSelections$1: function RacePoolBetSlipService_RacePoolBetSlipService$_removeRacePoolSelections$1(IDFOMarket, IDFOPriceType, selections, selectionsPlaces) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        var selectionsToCheck = [];
        if (racePool) {
            for (var i = 0; i < selections.length; i++) {
                this._removeSelection$1(racePool, selectionsPlaces[i], selections[i].IDFOSelection);
                selectionsToCheck.add(Number.parse(this._getRacePoolSelectionKey$1(selections[i].IDFOSelection)));
            }
            for (var i = 0; i < selectionsToCheck.length; i++) {
                var remove = true;
                var $dict1 = racePool.selectionsPlaces;
                for (var $key2 in $dict1) {
                    var selectionPlaceEntry = { key: $key2, value: $dict1[$key2] };
                    if (selectionPlaceEntry.value && (selectionPlaceEntry.value).contains(selectionsToCheck[i])) {
                        remove = false;
                    }
                }
                if (remove) {
                    delete racePool.selections[selectionsToCheck[i].toString()];
                }
            }
            this._fireRacePoolSelectionRemovedEvent$1(IDFOMarket, selections, selectionsPlaces);
            this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'selection');
        }
    },
    
    _getRacePoolBetType$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolBetType$1(racePool) {
        var betLegs = 0;
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var selectionPlaceEntry = { key: $key2, value: $dict1[$key2] };
            if (selectionPlaceEntry.value && (selectionPlaceEntry.value).length > 0) {
                var IDFOSelections = (selectionPlaceEntry.value);
                betLegs += IDFOSelections.length;
            }
        }
        var isAnyBet = racePool.isAnyOrderRacePool;
        var IDFOBetType = '';
        switch (racePool.idfoPriceType) {
            case 'FCD':
                switch (betLegs) {
                    case 0:
                    case 1:
                        break;
                    case 2:
                        IDFOBetType = (isAnyBet) ? 'RFC' : 'SFC';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CFC' : '';
                        break;
                }
                break;
            case 'EPD':
                switch (betLegs) {
                    case 0:
                    case 1:
                        break;
                    case 2:
                        IDFOBetType = (isAnyBet) ? 'REX' : 'EX';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CEX' : '';
                        break;
                }
                break;
            case 'QPD':
                switch (betLegs) {
                    case 0:
                    case 1:
                        break;
                    case 2:
                        IDFOBetType = (isAnyBet) ? 'QU' : 'QU';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CQU' : '';
                        break;
                }
                break;
            case 'TCD':
                switch (betLegs) {
                    case 0:
                    case 1:
                    case 2:
                        break;
                    case 3:
                        IDFOBetType = (isAnyBet) ? 'CTC' : 'STC';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CTC' : '';
                        break;
                }
                break;
            case 'TPD':
                switch (betLegs) {
                    case 0:
                    case 1:
                    case 2:
                        break;
                    case 3:
                        IDFOBetType = (isAnyBet) ? 'CTF' : 'STF';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CTF' : '';
                        break;
                }
                break;
        }
        return IDFOBetType;
    },
    
    _getRacePoolName$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolName$1(racePool) {
        var racePoolName = '';
        switch (racePool.idfoPriceType) {
            case 'FCD':
                racePoolName = 'Forecast';
                break;
            case 'TCD':
                racePoolName = 'Tricast';
                break;
            case 'EPD':
                racePoolName = 'Exacta';
                break;
            case 'TPD':
                racePoolName = 'Trifecta';
                break;
            case 'QPD':
                racePoolName = 'Quinella';
                break;
        }
        return racePoolName;
    }
}


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.RacePoolRaceTabsManager

RacePoolBetSlipService.RacePoolRaceTabsManager = function RacePoolBetSlipService_RacePoolRaceTabsManager(IDFOMarket) {
    this.idfoMarket = IDFOMarket;
    this.activeRacePoolTab = 'win';
    this.racePoolTabs = [];
}
RacePoolBetSlipService.RacePoolRaceTabsManager.prototype = {
    idfoMarket: null,
    racePoolTabs: null,
    activeRacePoolTab: null
}


RacePoolBetSlipService.RacePool.createClass('RacePoolBetSlipService.RacePool');
RacePoolBetSlipService.RacePoolBetSlipService.createClass('RacePoolBetSlipService.RacePoolBetSlipService', Framework.AbstractService, Framework.IPageWillChangeListener);
RacePoolBetSlipService.RacePoolRaceTabsManager.createClass('RacePoolBetSlipService.RacePoolRaceTabsManager');
RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1 = 'RacePoolBetSlipService';
RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1 = 'any';
RacePoolBetSlipService.RacePoolBetSlipService._log$1 = Framework.Logger.getLog(RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BettingNavigationService');

////////////////////////////////////////////////////////////////////////////////
// BettingNavigationService.INextOfMarketGroupLoadedListener

BettingNavigationService.INextOfMarketGroupLoadedListener = function() { };
BettingNavigationService.INextOfMarketGroupLoadedListener.prototype = {
    onNextOfMarketGroupLoaded : null
}
BettingNavigationService.INextOfMarketGroupLoadedListener.createInterface('BettingNavigationService.INextOfMarketGroupLoadedListener');


////////////////////////////////////////////////////////////////////////////////
// BettingNavigationService.BettingNavigationService

BettingNavigationService.BettingNavigationService = function BettingNavigationService_BettingNavigationService() {
    this._validNavigationTypeActions$1 = new Array(0);
    this._validPageAreas$1 = [ 'betting' ];
    this._nextOffMarketGroupLoadedListners$1 = new Framework.ListenerInvoker(true);
    BettingNavigationService.BettingNavigationService.constructBase(this);
    BettingNavigationService.BettingNavigationService._log$1.debug('ctor');
}
BettingNavigationService.BettingNavigationService.prototype = {
    _defaultPageArea$1: 'betting',
    _nextOffMarketGroupID$1: null,
    _navigationService$1: null,
    
    setNavigationService: function BettingNavigationService_BettingNavigationService$setNavigationService(navigationService) {
        BettingNavigationService.BettingNavigationService._log$1.debug('NavigationService');
        this._navigationService$1 = navigationService;
    },
    
    init: function BettingNavigationService_BettingNavigationService$init(environment, parameters) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        BettingNavigationService.BettingNavigationService.callBase(this, 'init', [ environment, parameters ]);
        if (!String.isNullOrEmpty(parameters['default-page-area'])) {
            this._defaultPageArea$1 = (parameters['default-page-area']).toLowerCase();
        }
        if (!String.isNullOrEmpty(parameters['valid-page-areas'])) {
            this._validPageAreas$1 = (parameters['valid-page-areas']).toLowerCase().split(',');
        }
        if (!String.isNullOrEmpty(parameters['valid-navigation-type-actions'])) {
            this._validNavigationTypeActions$1 = (parameters['valid-navigation-type-actions']).toUpperCase().split(',');
        }
    },
    
    start: function BettingNavigationService_BettingNavigationService$start() {
        BettingNavigationService.BettingNavigationService._log$1.debug('Start');
    },
    
    get_nextOffMarketGroupID: function BettingNavigationService_BettingNavigationService$get_nextOffMarketGroupID() {
        return this._nextOffMarketGroupID$1;
    },
    set_nextOffMarketGroupID: function BettingNavigationService_BettingNavigationService$set_nextOffMarketGroupID(value) {
        this._nextOffMarketGroupID$1 = value;
        return value;
    },
    
    get_activeMarketGroup: function BettingNavigationService_BettingNavigationService$get_activeMarketGroup() {
        if (this._navigationService$1.getPageFilter()[BettingNavigationService.BettingNavigationService.marketGroup]) {
            return this._navigationService$1.getPageFilter()[BettingNavigationService.BettingNavigationService.marketGroup];
        }
        if (!String.isNullOrEmpty(this.get_nextOffMarketGroupID())) {
            return this.get_nextOffMarketGroupID();
        }
        return null;
    },
    
    _goTo$1: function BettingNavigationService_BettingNavigationService$_goTo$1(pageFilter) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('GoTo pageFilter=[{0}]', Framework.DictionaryUtil.dumpToString(pageFilter)));
        var pageArea = this._navigationService$1.getPageArea();
        if (!this._validPageAreas$1.contains(pageArea.toLowerCase())) {
            pageArea = this._defaultPageArea$1;
        }
        this._navigationService$1.goTo(pageArea, pageFilter);
    },
    
    _calculateBONavigation$1: function BettingNavigationService_BettingNavigationService$_calculateBONavigation$1(pageFilter) {
        if (Object.keyExists(pageFilter, BettingNavigationService.BettingNavigationService.boNavigation)) {
            return (pageFilter[BettingNavigationService.BettingNavigationService.boNavigation]).split(',');
        }
        else {
            return [];
        }
    },
    
    _setBONavigation$1: function BettingNavigationService_BettingNavigationService$_setBONavigation$1(level, IDFWBONavigation, pageFilter) {
        if (!pageFilter) {
            pageFilter = this._navigationService$1.getPageFilter();
        }
        var oldBONavigation = this._calculateBONavigation$1(pageFilter);
        var newBONavigation = String.Empty;
        if (oldBONavigation.length < level) {
            throw new Error(String.format('Level [{0}] too large, current level is only [{1}]', level, oldBONavigation.length));
        }
        for (var i = 0; i < level; i++) {
            newBONavigation += oldBONavigation[i] + (((i < level - 1) || !String.isNullOrEmpty(IDFWBONavigation)) ? ',' : '');
        }
        if (!String.isNullOrEmpty(IDFWBONavigation)) {
            newBONavigation += IDFWBONavigation;
        }
        pageFilter[BettingNavigationService.BettingNavigationService.boNavigation] = newBONavigation;
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        return pageFilter;
    },
    
    getBONavigation: function BettingNavigationService_BettingNavigationService$getBONavigation() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetBONavigation');
        return this._calculateBONavigation$1(this._navigationService$1.getPageFilter());
    },
    
    getValidNavigationTypeActions: function BettingNavigationService_BettingNavigationService$getValidNavigationTypeActions() {
        return this._validNavigationTypeActions$1;
    },
    
    getLastNodeInNavigation: function BettingNavigationService_BettingNavigationService$getLastNodeInNavigation() {
        if ((this.getBONavigation()) && (this.getBONavigation().length > 1)) {
            return this.getBONavigation()[this.getBONavigation().length - 1];
        }
        return 'top';
    },
    
    getNodeFromXML: function BettingNavigationService_BettingNavigationService$getNodeFromXML(node) {
        if (!node) {
            return null;
        }
        var returnNode = new BettingNavigationService.BoNavigationNode();
        returnNode.id = node.selectSingleNode('idfwbonavigation').text;
        returnNode.navigationTypes = node.selectSingleNode('idfwbonavigationtype').text;
        return returnNode;
    },
    
    setBONavigation: function BettingNavigationService_BettingNavigationService$setBONavigation(level, IDFWBONavigation) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetBONavigation level=[{0}] IDFWBONavigation=[{1}]', level, IDFWBONavigation));
        var pageFilter = this._setBONavigation$1(level, IDFWBONavigation, null);
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    setBONavigationLevels: function BettingNavigationService_BettingNavigationService$setBONavigationLevels(IDFWBONavigationLevels) {
        BettingNavigationService.BettingNavigationService._log$1.debug('SetBONavigationLevels');
        var pageFilter = null;
        for (var level = 0; level < IDFWBONavigationLevels.length; level++) {
            pageFilter = this._setBONavigation$1(level, IDFWBONavigationLevels[level], pageFilter);
        }
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getMarketGroup: function BettingNavigationService_BettingNavigationService$getMarketGroup() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetMarketGroup');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
    },
    
    setMarketGroup: function BettingNavigationService_BettingNavigationService$setMarketGroup(level, IDFWMarketGroup) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetMarketGroup level=[{0}] IDFWMarketGroup=[{1}]', level, IDFWMarketGroup));
        var pageFilter = this._navigationService$1.getPageFilter();
        var oldBONavigation = this._calculateBONavigation$1(pageFilter);
        var newBONavigation = String.Empty;
        for (var i = 0; i < Math.min(level, oldBONavigation.length); i++) {
            newBONavigation += oldBONavigation[i] + ((i < level - 1) ? ',' : '');
        }
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        pageFilter[BettingNavigationService.BettingNavigationService.boNavigation] = newBONavigation;
        pageFilter[BettingNavigationService.BettingNavigationService.marketGroup] = IDFWMarketGroup;
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    fireNextOfMarketGroupLoadedEvent: function BettingNavigationService_BettingNavigationService$fireNextOfMarketGroupLoadedEvent(marketgroup) {
        BettingNavigationService.BettingNavigationService._log$1.debug('FireNextOfMarketGroupLoaded');
        this._nextOffMarketGroupID$1 = marketgroup;
        this._nextOffMarketGroupLoadedListners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onNextOfMarketGroupLoaded(marketgroup);
        }));
    },
    
    registerNextOfMarketGroupLoadedListener: function BettingNavigationService_BettingNavigationService$registerNextOfMarketGroupLoadedListener(nextOfMarketGroupLoadedListener) {
        BettingNavigationService.BettingNavigationService._log$1.debug('RegisterNextOfMarketGroupLoadedListener');
        this._nextOffMarketGroupLoadedListners$1.registerListener(nextOfMarketGroupLoadedListener);
    },
    
    getMarketFromMarketGroup: function BettingNavigationService_BettingNavigationService$getMarketFromMarketGroup() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetMarketFromMarketGroup');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
    },
    
    setMarketFromMarketGroup: function BettingNavigationService_BettingNavigationService$setMarketFromMarketGroup(IDFOMarket) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetMarketFromMarketGroup IDFOMarket=[{0}]', IDFOMarket));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        if (String.isNullOrEmpty(IDFOMarket)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup] = IDFOMarket;
        }
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getEvent: function BettingNavigationService_BettingNavigationService$getEvent() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetEvent');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.event];
    },
    
    setEvent: function BettingNavigationService_BettingNavigationService$setEvent(IDFOEvent, IDFOMarket, IDFWMarketGroup) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetEvent IDFOEvent=[{0}] IDFOMarket=[{1}] IDFWMarketGroup=[{2}] ', IDFOEvent, IDFOMarket, IDFWMarketGroup));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        if (!String.isNullOrEmpty(IDFOMarket)) {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup] = IDFOMarket;
        }
        if (!String.isNullOrEmpty(IDFWMarketGroup)) {
            pageFilter[BettingNavigationService.BettingNavigationService.marketGroup] = IDFWMarketGroup;
        }
        pageFilter[BettingNavigationService.BettingNavigationService.event] = IDFOEvent;
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getMarketFromEvent: function BettingNavigationService_BettingNavigationService$getMarketFromEvent() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetMarketFromEvent');
        var pageFilter = this._navigationService$1.getPageFilter();
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        return pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
    },
    
    setMarketFromEvent: function BettingNavigationService_BettingNavigationService$setMarketFromEvent(IDFOMarket) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetMarketFromEvent IDFOMarket=[{0}]', IDFOMarket));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        if (String.isNullOrEmpty(IDFOMarket)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent] = IDFOMarket;
        }
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getEventScorecastFromEvent: function BettingNavigationService_BettingNavigationService$getEventScorecastFromEvent() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetEventScorecastFromEvent');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
    },
    
    setEventScorecastFromEvent: function BettingNavigationService_BettingNavigationService$setEventScorecastFromEvent(IDFOEventScorecast) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetEventScorecastFromEvent IDFOEventScorecast=[{0}]', IDFOEventScorecast));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        if (String.isNullOrEmpty(IDFOEventScorecast)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent] = IDFOEventScorecast;
        }
        this._goTo$1(pageFilter);
    },
    
    getSearchPhrase: function BettingNavigationService_BettingNavigationService$getSearchPhrase() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetPhrase');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.phrase];
    },
    
    setSearchPhrase: function BettingNavigationService_BettingNavigationService$setSearchPhrase(phrase, pageArea, action) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetPhrase phrase=[{0}]', phrase));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.boNavigation];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        pageFilter[BettingNavigationService.BettingNavigationService.phrase] = phrase;
        pageFilter[NavigationService.NavigationService.action] = action;
        this._navigationService$1.goTo(pageArea, pageFilter);
    },
    
    getNavigationTypes: function BettingNavigationService_BettingNavigationService$getNavigationTypes() {
        var pageFilter = this._navigationService$1.getPageFilter();
        if (!pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes]) {
            return null;
        }
        return (pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes]).toUpperCase();
    },
    
    removeInvalidNavigationTypes: function BettingNavigationService_BettingNavigationService$removeInvalidNavigationTypes(navigationTypesAsString) {
        if (!navigationTypesAsString) {
            return String.Empty;
        }
        var navigationTypes = navigationTypesAsString.split(',');
        var returnValue = '';
        for (var count = 0; count < navigationTypes.length; count++) {
            if (this.getValidNavigationTypeActions().contains(navigationTypes[count])) {
                if ((count > 0) && (returnValue.length > 0)) {
                    returnValue += ',';
                }
                returnValue += navigationTypes[count];
            }
        }
        return returnValue;
    },
    
    setNavigationTypes: function BettingNavigationService_BettingNavigationService$setNavigationTypes(navigationTypes) {
        var clonedPageFilter = {};
        var _pageFilter = this._navigationService$1.getPageFilter();
        var $dict1 = _pageFilter;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (String.compare(entry.key, BettingNavigationService.BettingNavigationService.navigationTypes, true)) {
                clonedPageFilter[entry.key] = entry.value;
            }
        }
        if (navigationTypes) {
            navigationTypes = navigationTypes.toUpperCase();
            clonedPageFilter[BettingNavigationService.BettingNavigationService.navigationTypes] = navigationTypes;
        }
        this._goTo$1(clonedPageFilter);
    },
    
    loadNextOffMarketGroupID: function BettingNavigationService_BettingNavigationService$loadNextOffMarketGroupID(bonavigationid, navigationtype) {
        var url = '/cache/boyleSportsNextOffMarketGroup/${region}/${language}/${navigationtype}/${bonavigationid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${navigationtype}', navigationtype);
        url = url.replace('${bonavigationid}', bonavigationid);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                var nextOffMarketGroupID = contentRequest.responseXML.selectSingleNode('/MarketGroup/idfwmarketgroup').text;
                this.fireNextOfMarketGroupLoadedEvent(nextOffMarketGroupID);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    loadAndSetNavigationFromMarket: function BettingNavigationService_BettingNavigationService$loadAndSetNavigationFromMarket(navigationid, marketID, pageFilter, callback) {
        var url = '/cache/boNavigationLookupWithMarket/${region}/${language}/${bonavigationid}/${marketid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${bonavigationid}', this.getLastNodeInNavigation());
        url = url.replace('${marketid}', marketID);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                callback.invoke(pageFilter, contentRequest.responseXML);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    loadAndSetNavigationFromMarketGroup: function BettingNavigationService_BettingNavigationService$loadAndSetNavigationFromMarketGroup(navigationid, marketgroupID, pageFilter, callback) {
        var url = '/cache/boNavigationLookupWithMarketGroup/${region}/${language}/${bonavigationid}/${marketgroupid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${bonavigationid}', navigationid);
        url = url.replace('${marketgroupid}', marketgroupID);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                callback.invoke(pageFilter, contentRequest.responseXML);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    loadAndSetNavigationFromEventID: function BettingNavigationService_BettingNavigationService$loadAndSetNavigationFromEventID(navigationid, eventID, pageFilter, callback) {
        var url = '/cache/boNavigationLookupWithEvent/${region}/${language}/${bonavigationid}/${eventid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${bonavigationid}', this.getLastNodeInNavigation());
        url = url.replace('${eventid}', eventID);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                callback.invoke(pageFilter, contentRequest.responseXML);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    getPageActionFromNavigationTypes: function BettingNavigationService_BettingNavigationService$getPageActionFromNavigationTypes(navigationTypes) {
        return '';
    },
    
    setNavigation: function BettingNavigationService_BettingNavigationService$setNavigation(IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent) {
        this.setNavigationWithAction(IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent, BettingNavigationService.BettingNavigationService._marketGroupListAction$1, null);
    },
    
    setNavigationWithAction: function BettingNavigationService_BettingNavigationService$setNavigationWithAction(IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent, action, navigationTypes) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetNavigation IDFWBONavigation=[{0}] IDFWMarketGroup=[{1}] IDFOMarketFromMarketGroup=[{2}] IDFOEvent=[{3}] IDFOMarketFromEvent=[{4}] IDFOEventScorecastFromEvent=[{5}]', IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent));
        var pageFilter = this._navigationService$1.getPageFilter();
        pageFilter[BettingNavigationService.BettingNavigationService.showAllMarkets] = null;
        if (!IDFWBONavigation) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.boNavigation];
        }
        else {
            var navigation = '';
            for (var i = 0; i < IDFWBONavigation.length; i++) {
                navigation += IDFWBONavigation[i] + ((i < IDFWBONavigation.length - 1) ? ',' : '');
            }
            pageFilter[BettingNavigationService.BettingNavigationService.boNavigation] = navigation;
        }
        if (String.isNullOrEmpty(IDFWMarketGroup)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketGroup] = IDFWMarketGroup;
        }
        if (String.isNullOrEmpty(IDFOMarketFromMarketGroup)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup] = IDFOMarketFromMarketGroup;
        }
        if (String.isNullOrEmpty(IDFOEvent)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.event] = IDFOEvent;
        }
        if (String.isNullOrEmpty(IDFOMarketFromEvent)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent] = IDFOMarketFromEvent;
        }
        if (String.isNullOrEmpty(IDFOEventScorecastFromEvent)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent] = IDFOEventScorecastFromEvent;
        }
        if (String.isNullOrEmpty(action)) {
            delete pageFilter[NavigationService.NavigationService.action];
        }
        else {
            pageFilter[NavigationService.NavigationService.action] = action;
        }
        if (String.isNullOrEmpty(navigationTypes)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes] = navigationTypes.toUpperCase();
        }
        this._goTo$1(pageFilter);
    }
}


////////////////////////////////////////////////////////////////////////////////
// BettingNavigationService.BoNavigationNode

BettingNavigationService.BoNavigationNode = function BettingNavigationService_BoNavigationNode() {
}
BettingNavigationService.BoNavigationNode.prototype = {
    navigationTypes: null,
    id: null
}


BettingNavigationService.BettingNavigationService.createClass('BettingNavigationService.BettingNavigationService', Framework.AbstractService);
BettingNavigationService.BoNavigationNode.createClass('BettingNavigationService.BoNavigationNode');
BettingNavigationService.BettingNavigationService._serviceName$1 = 'BettingNavigationService';
BettingNavigationService.BettingNavigationService._log$1 = Framework.Logger.getLog(BettingNavigationService.BettingNavigationService._serviceName$1);
BettingNavigationService.BettingNavigationService.boNavigation = 'bo-navigation';
BettingNavigationService.BettingNavigationService.marketGroup = 'market-group';
BettingNavigationService.BettingNavigationService.marketFromMarketGroup = 'market-mg';
BettingNavigationService.BettingNavigationService.event = 'event';
BettingNavigationService.BettingNavigationService.marketFromEvent = 'market-e';
BettingNavigationService.BettingNavigationService.eventScorecastFromEvent = 'eventscorecast-e';
BettingNavigationService.BettingNavigationService.phrase = 'phrase';
BettingNavigationService.BettingNavigationService.navigationTypes = 'navigationtypes';
BettingNavigationService.BettingNavigationService.showAllMarkets = 'show-all-markets';
BettingNavigationService.BettingNavigationService._marketGroupListAction$1 = 'market-group-list';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('AbstractMMCoreComponents');

////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.formatDateStyle

AbstractMMCoreComponents.formatDateStyle = function() { };
AbstractMMCoreComponents.formatDateStyle.prototype = {
    user: 0, 
    machine: 1
}
AbstractMMCoreComponents.formatDateStyle.createEnum('AbstractMMCoreComponents.formatDateStyle', false);


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractBetPlacementComponent

AbstractMMCoreComponents.AbstractBetPlacementComponent = function AbstractMMCoreComponents_AbstractBetPlacementComponent() {
    AbstractMMCoreComponents.AbstractBetPlacementComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber = function AbstractMMCoreComponents_AbstractBetPlacementComponent$formatNumber(number) {
    return AbstractMMCoreComponents.CommonBetting.formatNumber(number);
}
AbstractMMCoreComponents.AbstractBetPlacementComponent.formatPotentialReturn = function AbstractMMCoreComponents_AbstractBetPlacementComponent$formatPotentialReturn(bsNumber) {
    switch (bsNumber) {
        case -1:
            return 'N/A';
        case -2:
            return 'ERR';
        default:
            return AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(bsNumber);
    }
}
AbstractMMCoreComponents.AbstractBetPlacementComponent.prototype = {
    _timerId: 0,
    _trackIfOnlyOneSelection: false,
    _showContinueBettingBtn: true,
    _defaultRedirectPageArea: 'homepage',
    _behaviourOnCancel: '',
    _behaviourAfterPlacement: '',
    _autoAccepted: false,
    _betSlipService: null,
    
    setBetSlipService: function AbstractMMCoreComponents_AbstractBetPlacementComponent$setBetSlipService(betSlipService) {
        this._log.debug('SetBetSlipService');
        this._betSlipService = betSlipService;
    },
    
    _fixedOddsBettingService: null,
    
    setFixedOddsBettingService: function AbstractMMCoreComponents_AbstractBetPlacementComponent$setFixedOddsBettingService(fixedOddsBettingService) {
        this._log.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService = fixedOddsBettingService;
    },
    
    onBetPlacementStateChanged: function AbstractMMCoreComponents_AbstractBetPlacementComponent$onBetPlacementStateChanged() {
        this._log.debug('OnBetPlacementStateChanged');
        if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.start) {
            this._navigationService.setAction('bet-placement');
        }
        else {
            this.update();
        }
    },
    
    onOddsTypeChanged: function AbstractMMCoreComponents_AbstractBetPlacementComponent$onOddsTypeChanged(fixedOddsBettingService) {
        this._log.debug('OnOddsTypeChanged');
        this.update();
    },
    
    _accountService: null,
    
    setAccountService: function AbstractMMCoreComponents_AbstractBetPlacementComponent$setAccountService(accountService) {
        this._log.debug('SetAccountService');
        this._accountService = accountService;
    },
    
    onAccountPreferencesChanged: function AbstractMMCoreComponents_AbstractBetPlacementComponent$onAccountPreferencesChanged(eventSource) {
        this._log.debug('OnAccountPreferencesChanged');
        this.update();
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractBetPlacementComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractMMCoreComponents_AbstractBetPlacementComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.update();
    },
    
    _bettingNavigationService: null,
    
    setBettingNavigationService: function AbstractMMCoreComponents_AbstractBetPlacementComponent$setBettingNavigationService(bettingNavigationService) {
        this._log.debug('SetBettingNavigationService');
        this._bettingNavigationService = bettingNavigationService;
    },
    
    init: function AbstractMMCoreComponents_AbstractBetPlacementComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log.debug(String.format('Init componentInstanceName=[{0}]', componentInstanceName));
        if (Object.keyExists(parameters, 'track-if-only-one-selection') && !String.isNullOrEmpty(parameters['track-if-only-one-selection'].toString())) {
            this._trackIfOnlyOneSelection = Boolean.parse(parameters['track-if-only-one-selection'].toString());
        }
        if (Object.keyExists(parameters, 'show-continue-betting-button') && !String.isNullOrEmpty(parameters['show-continue-betting-button'].toString())) {
            this._showContinueBettingBtn = Boolean.parse(parameters['show-continue-betting-button'].toString());
        }
        if (Object.keyExists(parameters, 'default-redirect-page-area')) {
            this._defaultRedirectPageArea = parameters['default-redirect-page-area'];
        }
        if (Object.keyExists(parameters, 'on-cancel-behaviour')) {
            this._behaviourOnCancel = parameters['on-cancel-behaviour'];
        }
        if (Object.keyExists(parameters, 'after-placement-behaviour')) {
            this._behaviourAfterPlacement = parameters['after-placement-behaviour'];
        }
    },
    
    preTransformation: function AbstractMMCoreComponents_AbstractBetPlacementComponent$preTransformation(eventArgs) {
        if (this.get_isComponentVisible() && this.getPrivateDomElement(AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[FixedOddsBettingService.BetPlacementState.placed])) {
            eventArgs.set_cancelUpdate(true);
            if (!this._fixedOddsBettingService.checkBetSlipStatusForSessionTimeout()) {
                this.repaintInner();
            }
        }
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractBetPlacementComponent$renderComplete(eventArgs) {
        this.repaintInner();
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractBetPlacementComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction());
    },
    
    tableDataFront: function AbstractMMCoreComponents_AbstractBetPlacementComponent$tableDataFront() {
        return '\r\n\t\t\t<div class=\'betholder\'>\r\n\t\t\t\t<h4>{3}{4} {0}{1} {2}</h4>\r\n\t\t\t\t<table class=\'betinfo\'>\r\n\t\t\t\t\t<col class=\'colbpmk\' />\r\n\t\t\t\t\t<col class=\'colbpsel\' />\r\n\t\t\t\t\t<col class=\'colbpprc\' />\r\n\t\t\t\t\t<col class=\'colbphcp\' />\r\n\t\t\t\t\t\t<thead>\r\n\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<th>Market</th>\r\n\t\t\t\t\t\t\t<th>Selection</th>\r\n\t\t\t\t\t\t\t<th>Price</th>\r\n\t\t\t\t\t\t\t<th>Hcp</th>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t</thead>';
    },
    
    tableDataMiddle: function AbstractMMCoreComponents_AbstractBetPlacementComponent$tableDataMiddle() {
        return '\r\n\t\t\t<tr>\r\n\t\t\t\t<td>{0}<br />{1}<br />{5}</td>\r\n\t\t\t\t<td><strong>{2}</strong></td>\r\n\t\t\t\t<td>{3}</td>\r\n\t\t\t\t<td>{4}</td>\r\n\t\t\t</tr>';
    },
    
    formattedTableDataMiddle: function AbstractMMCoreComponents_AbstractBetPlacementComponent$formattedTableDataMiddle(selection, selectionName, price, hcapValue, EWTerms) {
        return String.format(this.tableDataMiddle(), unescape(decodeURI(selection.EventName)), unescape(decodeURI(selection.MarketName)), unescape(decodeURI(selectionName)), price, hcapValue, EWTerms);
    },
    
    tableDataBottom: function AbstractMMCoreComponents_AbstractBetPlacementComponent$tableDataBottom() {
        return '\r\n\t\t\t\t</table>\r\n\t\t\t\t<table class=\'money\'>\r\n\t\t\t\t\t<col class=\'coltotal\'/>\r\n\t\t\t\t\t<col class=\'coltotalnum\'/>\r\n\t\t\t\t\t\t<tbody>\r\n\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t<th>Total stake</th>\r\n\t\t\t\t\t\t\t\t<td>{2} {0}</td>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t<th>Estimated return</th>\r\n\t\t\t\t\t\t\t\t<td>{2} {1}</td>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t</tbody>\r\n\t\t\t\t</table>\r\n\t\t\t</div>';
    },
    
    tableDataFinal: function AbstractMMCoreComponents_AbstractBetPlacementComponent$tableDataFinal() {
        return '\r\n\t\t\t\t<table class=\'money fullmoney\'>\r\n\t\t\t\t\t<col class=\'coltotal\'/>\r\n\t\t\t\t\t<col class=\'coltotalnum\'/>\r\n\t\t\t\t\t\t<tbody>\r\n\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t<th>Full stake</th>\r\n\t\t\t\t\t\t\t\t<td>{2} {0}</td>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t<th>Full estimated return</th>\r\n\t\t\t\t\t\t\t\t<td>{2} {1}</td>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t</tbody>\r\n\t\t\t\t</table>\r\n\t\t\t</div>';
    },
    
    updatePotentialReturnType: function AbstractMMCoreComponents_AbstractBetPlacementComponent$updatePotentialReturnType(potentialReturn, currentType) {
        var thisState = 0;
        switch (potentialReturn) {
            case -1:
            case -2:
                thisState = potentialReturn;
                break;
            default:
                thisState = 0;
                break;
        }
        return (thisState < currentType) ? thisState : currentType;
    },
    
    _activateBetPlacementStateDomElement$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_activateBetPlacementStateDomElement$2(betPlacementState) {
        for (var i = -1; i < AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2.length; i++) {
            var domID = (i < 0) ? 'none' : AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[i];
            var betPlacementStateDomElement = this.getPrivateDomElement(domID);
            if (betPlacementStateDomElement) {
                betPlacementStateDomElement.style.display = (betPlacementState === i) ? 'block' : 'none';
            }
        }
        var continueBettingBtn = this.getPrivateDomElement(String.format('{0}-continue-betting', AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[betPlacementState]));
        if (continueBettingBtn && !this._showContinueBettingBtn) {
            continueBettingBtn.style.display = 'none';
        }
        if (betPlacementState === FixedOddsBettingService.BetPlacementState.confirmationRequired && !isNaN(this._fixedOddsBettingService.getPreferences().BetGracePeriod) && this._fixedOddsBettingService.getPreferences().BetGracePeriod > 0 && !this._timerId) {
            this._displayGracePeriodTimer$2(true);
        }
        else if (betPlacementState !== FixedOddsBettingService.BetPlacementState.confirmationRequired) {
            this._displayGracePeriodTimer$2(false);
        }
    },
    
    _getEWData$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_getEWData$2(ewReduction, ewPlaceTerms) {
        if (ewPlaceTerms.length === 1) {
            var ew = String.format('EW 1/{0} 1', ewReduction[0]);
            for (var i = 2; i <= ewPlaceTerms[0]; i++) {
                ew = String.format('{0},{1}', ew, i);
            }
            return ew;
        }
        else {
            return '';
        }
    },
    
    displayConfirmationRequiredBefore: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayConfirmationRequiredBefore() {
        this._log.debug('DisplayConfirmationRequiredBefore');
        var domID = AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore] + '-bet-slip';
        this.updatePrivateDomElement(domID, this.formatBetPlacementBetslip(FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore, null));
        this._bindBehaviors$2(this._domElementId + '-' + domID);
    },
    
    formatChanged: function AbstractMMCoreComponents_AbstractBetPlacementComponent$formatChanged(newValue, oldValue) {
        return String.format('<span style=\'color: red\'>{0}</span> (<del>{1}</del>)', newValue, oldValue);
    },
    
    displayComparedBetslips: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayComparedBetslips() {
        var betSlipOutbound = this._fixedOddsBettingService.get_betSlipOutbound();
        var detailedState = betSlipOutbound.Status.DetailedState;
        var state = this._fixedOddsBettingService.get_betPlacementState();
        if (state === FixedOddsBettingService.BetPlacementState.confirmationRequired) {
            this._log.debug(String.format('DisplayConfirmationRequired detailedState=[{0}]', detailedState));
            for (var i = 0; i < FixedOddsBettingService.BetSlipStatus.confirmationMasks.length; i++) {
                var confirmationMessageDomElement = this.getPrivateDomElement(AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[FixedOddsBettingService.BetPlacementState.confirmationRequired] + '-' + FixedOddsBettingService.BetSlipStatus.confirmationMasks[i]);
                if (confirmationMessageDomElement) {
                    confirmationMessageDomElement.style.display = (!(detailedState & FixedOddsBettingService.BetSlipStatus.confirmationMasks[i])) ? 'none' : 'block';
                }
            }
        }
        else {
            this._log.debug('DisplayPlaced');
            var externalReference = '';
            externalReference += betSlipOutbound.ExternalReference + '/';
            for (var i = 0; i < betSlipOutbound.Bets.length; i++) {
                externalReference += ((i > 0) ? ',' : '') + betSlipOutbound.Bets[i].ExternalReference;
            }
            this.updatePrivateDomElement(AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[state] + '-external-reference', externalReference);
            if (!this._fixedOddsBettingService.getPreferences().IsBetConfirmationScreenShownAfterPlacement) {
                this._activateBetPlacementStateDomElement$2(state);
                this.redirectAfterPlacement();
                return;
            }
        }
        this._autoAccepted = false;
        var domID = AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[state] + '-bet-slip';
        this.updatePrivateDomElement(domID, this.formatBetPlacementBetslip(state, betSlipOutbound));
        this._bindBehaviors$2(this._domElementId + '-' + domID);
        if (FixedOddsBettingService.BetSlipStatus.isTopupRequired(betSlipOutbound.Status)) {
            this.updatePrivateDomElement('topup-amount', String.format('{0}{1}', this._accountService.getCurrencySimbol(), AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(betSlipOutbound.TopupAmount)));
        }
        if (this._autoAccepted) {
            var confirmationMessageDomElement = this.getPrivateDomElement('confirmation-arc');
            if (confirmationMessageDomElement) {
                confirmationMessageDomElement.style.display = 'block';
            }
        }
    },
    
    _checkChangesAndFormatStakes$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_checkChangesAndFormatStakes$2(stakeIn, stakeOut) {
        var stakeIn2 = Number.parse(stakeIn.toFixed(2));
        var stakeOut2 = (Framework.ScriptSharpQuirks.isNumberNull(stakeOut)) ? null : Number.parse(stakeOut.toFixed(2));
        if (!Framework.ScriptSharpQuirks.isNumberNull(stakeOut2) && stakeIn2 !== stakeOut2) {
            return this.formatChanged(AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(stakeOut), AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(stakeIn));
        }
        else if (!Framework.ScriptSharpQuirks.isNumberNull(stakeOut2)) {
            return AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(stakeOut);
        }
        else {
            return AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(stakeIn);
        }
    },
    
    _checkChangesAndFormatReturn$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_checkChangesAndFormatReturn$2(returnIn, returnOut) {
        var returnIn2 = Number.parse(returnIn.toFixed(2));
        var returnOut2 = (Framework.ScriptSharpQuirks.isNumberNull(returnOut)) ? null : Number.parse(returnOut.toFixed(2));
        if (!Framework.ScriptSharpQuirks.isNumberNull(returnOut2) && (returnIn2 !== returnOut2 && returnIn2 > 0)) {
            return this.formatChanged(AbstractMMCoreComponents.AbstractBetPlacementComponent.formatPotentialReturn(returnOut), AbstractMMCoreComponents.AbstractBetPlacementComponent.formatPotentialReturn(returnIn));
        }
        else if (!Framework.ScriptSharpQuirks.isNumberNull(returnOut2)) {
            return AbstractMMCoreComponents.AbstractBetPlacementComponent.formatPotentialReturn(returnOut);
        }
        else {
            return AbstractMMCoreComponents.AbstractBetPlacementComponent.formatPotentialReturn(returnIn);
        }
    },
    
    _checkChangesAndFormatOdds$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_checkChangesAndFormatOdds$2(betLegIn, betLegOut) {
        var priceType = betLegIn.IDFOPriceType;
        if (betLegOut && (betLegIn.PriceUp !== betLegOut.PriceUp || betLegIn.PriceDown !== betLegOut.PriceDown)) {
            return this.formatChanged(this._fixedOddsBettingService.formatOdds(priceType, betLegOut.PriceUp, betLegOut.PriceDown), this._fixedOddsBettingService.formatOdds(priceType, betLegIn.PriceUp, betLegIn.PriceDown));
        }
        else if (betLegOut) {
            return this._fixedOddsBettingService.formatOdds(priceType, betLegOut.PriceUp, betLegOut.PriceDown);
        }
        else {
            return this._fixedOddsBettingService.formatOdds(priceType, betLegIn.PriceUp, betLegIn.PriceDown);
        }
    },
    
    _checkChangesAndFormatHandicap$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_checkChangesAndFormatHandicap$2(HADValue, betLegIn, betLegOut) {
        if (betLegOut && betLegIn.Handicap !== betLegOut.Handicap) {
            return this.formatChanged(this._formatHandicap$2(HADValue, betLegOut.Handicap), this._formatHandicap$2(HADValue, betLegIn.Handicap));
        }
        else if (betLegOut) {
            return this._formatHandicap$2(HADValue, betLegOut.Handicap);
        }
        else {
            return this._formatHandicap$2(HADValue, betLegIn.Handicap);
        }
    },
    
    _formatHandicap$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_formatHandicap$2(HADValue, handicap) {
        if (HADValue === 'A') {
            if (handicap < 0) {
                return String.format(' +{0}', handicap * -1);
            }
            else {
                return String.format(' {0}', handicap * -1);
            }
        }
        else {
            return String.format(' {0}', handicap);
        }
    },
    
    _checkChangesAndFormatEW$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_checkChangesAndFormatEW$2(betLegIn, betLegOut) {
        if (betLegOut && (betLegIn.EachWayReduction !== betLegOut.EachWayReduction || betLegIn.EachWayPlaceTerms !== betLegOut.EachWayPlaceTerms)) {
            return this.formatChanged(this._getEWData$2([ betLegOut.EachWayReduction ], [ betLegOut.EachWayPlaceTerms ]), this._getEWData$2([ betLegIn.EachWayReduction ], [ betLegIn.EachWayPlaceTerms ]));
        }
        else if (betLegOut) {
            return this._getEWData$2([ betLegOut.EachWayReduction ], [ betLegOut.EachWayPlaceTerms ]);
        }
        else {
            return this._getEWData$2([ betLegIn.EachWayReduction ], [ betLegIn.EachWayPlaceTerms ]);
        }
    },
    
    _checkChangesAndFormatBand$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_checkChangesAndFormatBand$2(selectionName, betLegIn, betLegOut) {
        if (betLegOut && (betLegIn.UpperBand !== betLegOut.UpperBand || betLegIn.LowerBand !== betLegOut.LowerBand)) {
            var newSelectionName = selectionName;
            if (betLegIn.UpperBand !== betLegOut.UpperBand) {
                newSelectionName = newSelectionName.replace(betLegIn.UpperBand.toString(), betLegOut.UpperBand.toString());
            }
            if (betLegIn.LowerBand !== betLegOut.LowerBand) {
                newSelectionName = newSelectionName.replace(betLegIn.LowerBand.toString(), betLegOut.LowerBand.toString());
            }
            return this.formatChanged(newSelectionName, selectionName);
        }
        else {
            return selectionName;
        }
    },
    
    formatBetPlacementBetslip: function AbstractMMCoreComponents_AbstractBetPlacementComponent$formatBetPlacementBetslip(placementState, betSlipOutbound) {
        this._log.debug('DisplayBetPlacementBetslip');
        this._activateBetPlacementStateDomElement$2(placementState);
        var content = '';
        var betSlipTotalStake = 0;
        var betSlipPotentialReturn = 0;
        var betSlipPotentialReturnType = 0;
        var betSlipInbound = this._fixedOddsBettingService.get_betSlip();
        var calculatedBetSlip = this._fixedOddsBettingService.get_betSlipCalculation();
        var selections = this._fixedOddsBettingService.get_selections();
        for (var i = 0; i < betSlipInbound.Bets.length; i++) {
            var stake = AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(calculatedBetSlip[i].TotalStake);
            var hcpTitle = '';
            var BSOExternalReference = '';
            var BSOBExternalReference = '';
            try {
                BSOExternalReference = (String.isNullOrEmpty(betSlipOutbound.ExternalReference)) ? '' : betSlipOutbound.ExternalReference;
                BSOBExternalReference = (String.isNullOrEmpty(betSlipOutbound.Bets[i].ExternalReference)) ? '' : betSlipOutbound.Bets[i].ExternalReference;
            }
            catch (error) {
            }
            content += String.format(this.tableDataFront(), this._accountService.getCurrencySimbol(), this._checkChangesAndFormatStakes$2(betSlipInbound.Bets[i].WinStake, (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].WinStake), betSlipInbound.Bets[i].BetTypeName, this.createSpanBetRef(placementState, BSOExternalReference, BSOBExternalReference), this.createFreeSpanBetRef(betSlipInbound.IsFree));
            var betLegs = betSlipInbound.Bets[i].BetLegs;
            for (var j = 0; j < betLegs.length; j++) {
                var key;
                if (!betLegs[j].IDFOEventScorecast) {
                    key = this._betSlipService.getSimpleSelectionKey(betLegs[j].IDFOSelection);
                }
                else {
                    key = this._betSlipService.getScorecastSelectionKey(betLegs[j].IDFOEventScorecast, betLegs[j].IDFOSelection, betLegs[j + 1].IDFOSelection);
                    j++;
                }
                var selection = selections[key];
                var selectionName = this._checkChangesAndFormatBand$2(selection.SelectionName, betSlipInbound.Bets[i].BetLegs[j], (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].BetLegs[j]);
                var price;
                if (!betLegs[j].IDFOEventScorecast) {
                    price = this._checkChangesAndFormatOdds$2(betSlipInbound.Bets[i].BetLegs[j], (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].BetLegs[j]);
                }
                else {
                    price = this._checkChangesAndFormatOdds$2(betSlipInbound.Bets[i].BetLegs[j - 1], (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].BetLegs[j - 1]);
                }
                var hcapValue = (!selection.Handicap) ? '' : this._checkChangesAndFormatHandicap$2(selection.HADValue, betSlipInbound.Bets[i].BetLegs[j], (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].BetLegs[j]);
                var ewTerms = (!betSlipInbound.Bets[i].PlaceStake) ? '' : this._checkChangesAndFormatEW$2(betSlipInbound.Bets[i].BetLegs[j], (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].BetLegs[j]);
                if (!String.isNullOrEmpty(hcapValue)) {
                    hcpTitle = 'Hcp';
                }
                content += this.formattedTableDataMiddle(selection, selectionName, price, hcapValue, ewTerms);
            }
            var betTypePotentialReturn = (!betSlipOutbound) ? calculatedBetSlip[i].PotentialReturn : betSlipOutbound.Bets[i].PotentialReturn;
            content += String.format(this.tableDataBottom(), this._checkChangesAndFormatStakes$2(calculatedBetSlip[i].TotalStake, (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].TotalStake), this._checkChangesAndFormatReturn$2(calculatedBetSlip[i].PotentialReturn, (!betSlipOutbound) ? null : betSlipOutbound.Bets[i].PotentialReturn), (betTypePotentialReturn < 0) ? '' : this._accountService.getCurrencySimbol());
            content = content.replace('[Hcp]', hcpTitle);
            betSlipTotalStake += (!betSlipOutbound) ? calculatedBetSlip[i].TotalStake : betSlipOutbound.Bets[i].TotalStake;
            betSlipPotentialReturn += (betTypePotentialReturn < 0) ? 0 : betTypePotentialReturn;
            betSlipPotentialReturnType = this.updatePotentialReturnType(betTypePotentialReturn, betSlipPotentialReturnType);
            if (betSlipOutbound && calculatedBetSlip && betSlipOutbound.Status.State === FixedOddsBettingService.BetPlacementState.placed && betSlipOutbound.Status.DetailedState === FixedOddsBettingService.BetSlipStatus.accepted && betSlipOutbound.Bets[i].TotalStake !== calculatedBetSlip[i].TotalStake) {
                this._autoAccepted = true;
            }
        }
        if (!this._trackIfOnlyOneSelection || (this._trackIfOnlyOneSelection && betSlipInbound.Bets.length > 1)) {
            content += String.format(this.tableDataFinal(), AbstractMMCoreComponents.AbstractBetPlacementComponent.formatNumber(betSlipTotalStake), AbstractMMCoreComponents.AbstractBetPlacementComponent.formatPotentialReturn((betSlipPotentialReturnType < 0) ? betSlipPotentialReturnType : betSlipPotentialReturn), (betSlipPotentialReturnType < 0) ? '' : this._accountService.getCurrencySimbol());
        }
        return content;
    },
    
    createSpanBetRef: function AbstractMMCoreComponents_AbstractBetPlacementComponent$createSpanBetRef(placementState, outboundExternalRef, outboundIndividualBetExternalRef) {
        return (placementState === FixedOddsBettingService.BetPlacementState.placed) ? String.format('<span class=\'bpbetref\'>Bet ref: {0}/{1}</span>', outboundExternalRef, outboundIndividualBetExternalRef) : '';
    },
    
    createFreeSpanBetRef: function AbstractMMCoreComponents_AbstractBetPlacementComponent$createFreeSpanBetRef(isInboundSlipFree) {
        return (isInboundSlipFree) ? '<span class=\'bpfreebet\'>FREE! </span>' : '';
    },
    
    displayRejected: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayRejected() {
        this._activateBetPlacementStateDomElement$2(FixedOddsBettingService.BetPlacementState.rejected);
        this.displayTerminatedStateMask((this._fixedOddsBettingService.get_betTerminatedState() === FixedOddsBettingService.BetTerminatedState.notApplicableState) ? FixedOddsBettingService.BetTerminatedState.generalRejection : this._fixedOddsBettingService.get_betTerminatedState());
        if (this._fixedOddsBettingService.get_betTerminatedState() === FixedOddsBettingService.BetTerminatedState.displayStatusRejection) {
            this.updatePrivateDomElement(String.format('{0}-{1}-text', AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[this._fixedOddsBettingService.get_betPlacementState()], FixedOddsBettingService.BetTerminatedState.displayStatusRejection), this._fixedOddsBettingService.get_betSlipOutbound().Status.StatusText);
        }
    },
    
    displayWaiting: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayWaiting() {
        this._log.debug('DisplayWaiting');
        this._activateBetPlacementStateDomElement$2(FixedOddsBettingService.BetPlacementState.waiting);
    },
    
    displayFailed: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayFailed() {
        this._activateBetPlacementStateDomElement$2(FixedOddsBettingService.BetPlacementState.failed);
        this.displayTerminatedStateMask((this._fixedOddsBettingService.get_betTerminatedState() === FixedOddsBettingService.BetTerminatedState.notApplicableState) ? FixedOddsBettingService.BetTerminatedState.generalFailure : this._fixedOddsBettingService.get_betTerminatedState());
    },
    
    displayGenericMessage: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayGenericMessage() {
        this._activateBetPlacementStateDomElement$2(FixedOddsBettingService.BetPlacementState.none);
    },
    
    repaintInner: function AbstractMMCoreComponents_AbstractBetPlacementComponent$repaintInner() {
        if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore) {
            this.displayConfirmationRequiredBefore();
        }
        else if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.confirmationRequired || this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.placed) {
            this.displayComparedBetslips();
        }
        else if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.rejected) {
            this.displayRejected();
        }
        else if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.failed) {
            this.displayFailed();
        }
        else if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.waiting) {
            this.displayWaiting();
        }
        else {
            this.displayGenericMessage();
        }
    },
    
    gracePeriodTimer: function AbstractMMCoreComponents_AbstractBetPlacementComponent$gracePeriodTimer() {
        var timer = this.getPrivateDomElement('grace-period-timer');
        if (timer) {
            this._environment.updateDomElementDirect(timer, this._fixedOddsBettingService.get_gracePeriodRemaining().toString());
        }
        this._fixedOddsBettingService.decreaseGracePeriodRemaining();
        if (this._fixedOddsBettingService.get_gracePeriodRemaining() >= 0) {
            this._timerId = window.setTimeout(Delegate.create(this, this.gracePeriodTimer), 1000);
        }
        else {
            this.gracePeriodTimerExpired();
        }
    },
    
    clearGracePeriodTimer: function AbstractMMCoreComponents_AbstractBetPlacementComponent$clearGracePeriodTimer() {
        if (this._timerId) {
            window.clearTimeout(this._timerId);
            this._timerId = 0;
        }
    },
    
    gracePeriodTimerExpired: function AbstractMMCoreComponents_AbstractBetPlacementComponent$gracePeriodTimerExpired() {
        this._fixedOddsBettingService.gracePeriodTimedOut();
    },
    
    displayTerminatedStateMask: function AbstractMMCoreComponents_AbstractBetPlacementComponent$displayTerminatedStateMask(maskId) {
        var maskArray = (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.rejected) ? FixedOddsBettingService.BetTerminatedState.betRejectedMasks : FixedOddsBettingService.BetTerminatedState.betFailedMasks;
        var $enum1 = maskArray.getEnumerator();
        while ($enum1.moveNext()) {
            var mask = $enum1.get_current();
            var domElement = this.getPrivateDomElement(String.format('{0}-{1}', AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2[this._fixedOddsBettingService.get_betPlacementState()], mask));
            if (domElement) {
                domElement.style.display = (maskId === mask) ? 'block' : 'none';
            }
        }
    },
    
    redirectOnCancel: function AbstractMMCoreComponents_AbstractBetPlacementComponent$redirectOnCancel() {
        this.implementRedirectBehaviour(this._behaviourOnCancel);
    },
    
    redirectAfterPlacement: function AbstractMMCoreComponents_AbstractBetPlacementComponent$redirectAfterPlacement() {
        this.implementRedirectBehaviour(this._behaviourAfterPlacement);
    },
    
    redirectToMarket: function AbstractMMCoreComponents_AbstractBetPlacementComponent$redirectToMarket() {
        if (this._bettingNavigationService.getBONavigation().length > 0 || !String.isNullOrEmpty(this._bettingNavigationService.getMarketGroup()) || !String.isNullOrEmpty(this._bettingNavigationService.getMarketFromMarketGroup()) || !String.isNullOrEmpty(this._bettingNavigationService.getEvent()) || !String.isNullOrEmpty(this._bettingNavigationService.getMarketFromEvent()) || !String.isNullOrEmpty(this._bettingNavigationService.getEventScorecastFromEvent())) {
            this._bettingNavigationService.setNavigation(this._bettingNavigationService.getBONavigation(), this._bettingNavigationService.getMarketGroup(), this._bettingNavigationService.getMarketFromMarketGroup(), this._bettingNavigationService.getEvent(), this._bettingNavigationService.getMarketFromEvent(), this._bettingNavigationService.getEventScorecastFromEvent());
            return true;
        }
        else {
            return false;
        }
    },
    
    implementRedirectBehaviour: function AbstractMMCoreComponents_AbstractBetPlacementComponent$implementRedirectBehaviour(behaviour) {
        if (!String.isNullOrEmpty(behaviour) && behaviour === 'nothing') {
        }
        else if (!String.isNullOrEmpty(behaviour) && behaviour === 'back') {
            if (!this._navigationService.goBackAndReport()) {
                this._navigationService.goTo(this._defaultRedirectPageArea, {});
            }
        }
        else if (!String.isNullOrEmpty(behaviour) && behaviour === 'hide') {
            this.hide();
        }
        else {
            var redirect = true;
            if (behaviour === 'market') {
                redirect = !this.redirectToMarket();
            }
            if (redirect) {
                var pageFilter = this._navigationService.getPageFilter();
                if (Object.keyExists(pageFilter, 'action')) {
                    delete pageFilter.action;
                }
                this._navigationService.goTo(this._defaultRedirectPageArea, pageFilter);
            }
        }
    },
    
    _displayGracePeriodTimer$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_displayGracePeriodTimer$2(enableTimer) {
        if (enableTimer) {
            if (this._fixedOddsBettingService.getPreferences().BetGracePeriod > 0) {
                var timerMessage = this.getPrivateDomElement('timer-message');
                if (timerMessage) {
                    timerMessage.style.display = 'block';
                }
                this.gracePeriodTimer();
            }
        }
        else if (this._timerId) {
            window.clearTimeout(this._timerId);
        }
    },
    
    _bindBehaviors$2: function AbstractMMCoreComponents_AbstractBetPlacementComponent$_bindBehaviors$2(domID) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domID), (this));
    },
    
    confirmBetSlipEventHandler: function AbstractMMCoreComponents_AbstractBetPlacementComponent$confirmBetSlipEventHandler(sender, eventArgs) {
        this._log.debug('ConfirmBetSlip');
        var securityCodeCheck = true;
        var securityCode = '';
        if (this._fixedOddsBettingService.get_betSlipOutbound() && FixedOddsBettingService.BetSlipStatus.isSecurityCodeRequiredForTopup(this._fixedOddsBettingService.get_betSlipOutbound().Status)) {
            securityCode = (this.getPrivateDomElement('security-code')).value;
            if (securityCode.length < 3 || securityCode.replace(new RegExp('^[0-9]+$'), '').length > 0 || String.isNullOrEmpty(securityCode)) {
                securityCodeCheck = false;
            }
        }
        if (securityCodeCheck) {
            this.clearGracePeriodTimer();
            this._fixedOddsBettingService.confirmBetSlip(securityCode);
        }
        else {
            alert('Please enter security code');
        }
        window.event.returnValue = false;
    },
    
    rejectBetSlipEventHandler: function AbstractMMCoreComponents_AbstractBetPlacementComponent$rejectBetSlipEventHandler(sender, eventArgs) {
        this._log.debug('RejectBetSlip');
        if (this._fixedOddsBettingService.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore) {
            this._fixedOddsBettingService.resetBetSlip();
            if (this._fixedOddsBettingService.shouldPlacementStayInCurrentArea()) {
                this.hide();
            }
            else {
                this.redirectOnCancel();
            }
        }
        else {
            this.clearGracePeriodTimer();
            this._fixedOddsBettingService.rejectBetSlip();
        }
        window.event.returnValue = false;
    },
    
    continueBettingEventHandler: function AbstractMMCoreComponents_AbstractBetPlacementComponent$continueBettingEventHandler(sender, eventArgs) {
        this._log.debug('ContinueBetting');
        if (this._fixedOddsBettingService.shouldPlacementStayInCurrentArea()) {
            this.hide();
        }
        else {
            this.redirectAfterPlacement();
        }
        window.event.returnValue = false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractBetSlipComponent

AbstractMMCoreComponents.AbstractBetSlipComponent = function AbstractMMCoreComponents_AbstractBetSlipComponent() {
    AbstractMMCoreComponents.AbstractBetSlipComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractBetSlipComponent.prototype = {
    _validationManager: null,
    _showCheckBetslip: false,
    _enableSlipToggling: false,
    _heightThreshold: '-1',
    _expandWhenFirstSelectionAdded: true,
    _autoAdjustHeight: true,
    _updateStakeTextboxOnStateChange: true,
    _doValidation: false,
    _accountService: null,
    
    setAccountService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setAccountService(accountService) {
        this._log.debug('SetAccountService');
        this._accountService = accountService;
    },
    
    onBalanceChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onBalanceChanged(eventSource) {
        this._log.debug('OnBalanceChanged');
        this.toggleFreeBet();
    },
    
    _betSlipService: null,
    
    setBetSlipService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setBetSlipService(betSlipService) {
        this._log.debug('SetBetSlipService');
        this._betSlipService = betSlipService;
    },
    
    onBetSlipSelectionsUpdate: function AbstractMMCoreComponents_AbstractBetSlipComponent$onBetSlipSelectionsUpdate(eventSource) {
        this._log.debug('OnBetSlipSelectionsUpdate');
        if (this.get_isComponentVisible()) {
            this.update();
        }
    },
    
    onSelectionsAdded: function AbstractMMCoreComponents_AbstractBetSlipComponent$onSelectionsAdded(eventSource, selection) {
        this._log.debug('OnSelectionsAdded');
        if (this.get_isComponentVisible()) {
            this.update();
        }
        if (this._expandWhenFirstSelectionAdded && this._betSlipService.getSelectionsCount() === 1) {
            this.expand();
        }
    },
    
    onSelectionsRemoved: function AbstractMMCoreComponents_AbstractBetSlipComponent$onSelectionsRemoved(eventSource, selection) {
        this._log.debug('OnSelectionsRemoved');
        if (this.get_isComponentVisible()) {
            this.update();
        }
        if (this._expandWhenFirstSelectionAdded && !this._betSlipService.getSelectionsCount()) {
            this.collapse();
        }
    },
    
    onAllowedBetTypesChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onAllowedBetTypesChanged(eventSource) {
        this._log.debug('OnAllowedBetTypesChanged');
        if (this.get_isComponentVisible()) {
            this.update();
        }
    },
    
    onBetSlipCalculationChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onBetSlipCalculationChanged(eventSource) {
        this._log.debug('OnBetSlipCalculationChanged');
        if (this.get_isComponentVisible()) {
            this.populateBetSlipCalculation();
        }
    },
    
    _fixedOddsBettingService: null,
    
    setFixedOddsBettingService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setFixedOddsBettingService(fixedOddsBettingService) {
        this._log.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService = fixedOddsBettingService;
    },
    
    onOddsTypeChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onOddsTypeChanged(fixedOddsBettingService) {
        this._log.debug('OnOddsTypeChanged');
        this.update();
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.update();
    },
    
    _userService: null,
    
    setUserService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    init: function AbstractMMCoreComponents_AbstractBetSlipComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._showCheckBetslip = Boolean.parse(parameters['show-check-betslip']);
        this._enableSlipToggling = Boolean.parse(parameters['enable-slip-toggling']);
        this._heightThreshold = parameters['height-threshold'];
        this._expandWhenFirstSelectionAdded = Boolean.parse(parameters['expand-when-first-selection-added']);
        this._autoAdjustHeight = Boolean.parse(parameters['auto-adjust-height']);
        if (!String.isNullOrEmpty(parameters['update-stake-textbox-on-state-change'])) {
            this._updateStakeTextboxOnStateChange = Boolean.parse(parameters['update-stake-textbox-on-state-change']);
        }
        if (!String.isNullOrEmpty(parameters['do-validation'])) {
            this._doValidation = Boolean.parse(parameters['do-validation']);
        }
        this._validationManager = new Framework.Validation.ValidationManager(this._environment);
    },
    
    preTransformation: function AbstractMMCoreComponents_AbstractBetSlipComponent$preTransformation(eventArgs) {
        var xmlBuilder = new AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder(this._betSlipService.getBetSlipCalculation(), this._betSlipService.getSelections(), this._betSlipService.getStakePerSelection(), this._betSlipService.getAllowedBetTypes(), this._betSlipService.getStakePerBetType(), this._betSlipService.getIsEachWayPerBetType(), this._betSlipService.getPreviousSelections(), this._fixedOddsBettingService, this._accountService, this._betSlipService);
        eventArgs.get_contextObject().customXmlDocument = xmlBuilder.getBetSlipXML();
        if (!this.get_isComponentVisible()) {
            this._betSlipService.changeBetSlipLiveUpdateTimerStatus(false);
        }
        else {
            this._betSlipService.changeBetSlipLiveUpdateTimerStatus(true);
        }
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractBetSlipComponent$renderComplete(eventArgs) {
        if (this._doValidation) {
            this._validationManager.clearValidators();
            var $dict1 = this._betSlipService.getSelections();
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var key = entry.key;
                var selection = entry.value;
                var labelElementID = String.format('{0}-{1}-price-type', this._domElementId, selection.IDFOSelection);
                var _validator = new Framework.Validation.RegexValidator('^\\d*(\\.\\d{1,2})?$');
                _validator.set_applyInputParentElementErrorClassOnError(false);
                _validator.inputElementId = String.format('{0}-{1}-unit-stake', this._domElementId, selection.IDFOSelection);
                _validator.errorElementId = String.format('{0}-{1}-unit-stake-error', this._domElementId, selection.IDFOSelection);
                _validator.set_errorLabelClass('LabelError');
                this._validationManager.registerInputForValidation(_validator);
            }
            for (var i = 0; i < this._betSlipService.getAllowedBetTypes().length; i++) {
                var selection = this._betSlipService.getAllowedBetTypes()[i];
                var _validator = new Framework.Validation.RegexValidator('^\\d*(\\.\\d{1,2})?$');
                _validator.set_applyInputParentElementErrorClassOnError(false);
                _validator.inputElementId = String.format('{0}-{1}-unit-stake', this._domElementId, selection.IDFOBetType);
                _validator.errorElementId = String.format('{0}-{1}-unit-stake-error', this._domElementId, selection.IDFOBetType);
                _validator.set_errorLabelClass('LabelError');
                this._validationManager.registerInputForValidation(_validator);
            }
        }
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractBetSlipComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction());
    },
    
    getXsltParameters: function AbstractMMCoreComponents_AbstractBetSlipComponent$getXsltParameters(contextObject) {
        var xsltParameters = AbstractMMCoreComponents.AbstractBetSlipComponent.callBase(this, 'getXsltParameters', [ contextObject ]);
        if (this._showCheckBetslip) {
            xsltParameters['show-check-betslip'] = true;
        }
        if (this._enableSlipToggling) {
            xsltParameters['enable-slip-toggling'] = true;
        }
        xsltParameters['height-threshold'] = this._heightThreshold;
        xsltParameters['retain-after-placement'] = this._betSlipService.getRetainSelectionsAfterPlacement();
        xsltParameters['is-free-bet'] = this._betSlipService.getIsFree();
        xsltParameters['currency-symbol'] = this._accountService.getCurrencySimbol();
        var freeAccount = this._accountService.get_freeAccountDetails();
        xsltParameters['show-free-bet'] = (freeAccount && freeAccount.TradingBalance > 0) ? true : false;
        if (this._betSlipService.getIsFree() && (!freeAccount || freeAccount.TradingBalance <= 0)) {
            this._betSlipService.setIsFree(false);
        }
        return xsltParameters;
    },
    
    toggleEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$toggleEventHandler(sender, eventArgs) {
        this._log.debug('Toggle');
        var betslip = this._environment.getDomElement(this._domElementId);
        if (betslip.className.indexOf('bson') === -1) {
            this.expand();
            this.adjustHeight();
        }
        else {
            this.collapse();
        }
        eventArgs.domElement.blur();
        window.event.returnValue = false;
    },
    
    toggleHelpEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$toggleHelpEventHandler(sender, eventArgs) {
        this._log.debug('ToggleHelp');
        var help = this.getPrivateDomElement('betslip-help');
        if (help) {
            if (help.style.display === 'block') {
                help.style.display = 'none';
            }
            else {
                help.style.display = 'block';
                this.adjustHeight();
            }
        }
        eventArgs.domElement.blur();
        window.event.returnValue = false;
    },
    
    setRetainSelectionsAfterPlacementEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setRetainSelectionsAfterPlacementEventHandler(sender, eventArgs) {
        var retain = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetRetainSelectionsAfterPlacement retainSelectionsAfterPlacement=[{0}]', retain));
        this._betSlipService.setRetainSelectionsAfterPlacement(retain);
    },
    
    setIsFreeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setIsFreeEventHandler(sender, eventArgs) {
        var isFree = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetIsFree isFree=[{0}]', isFree));
        this._betSlipService.setIsFree(isFree);
    },
    
    placeBetEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$placeBetEventHandler(sender, eventArgs) {
        this.placeBet();
    },
    
    checkBetSlipEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$checkBetSlipEventHandler(sender, eventArgs) {
        this._log.debug('CheckBetSlip');
        if (this._userService.isLoggedIn()) {
            this.collapse();
        }
        this.startBetPlacement(true);
    },
    
    validateBetslip: function AbstractMMCoreComponents_AbstractBetSlipComponent$validateBetslip() {
        return this._validationManager.validateAll();
    },
    
    validateStakeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$validateStakeEventHandler(sender, eventArgs) {
        this._validationManager.validateAll();
        window.event.returnValue = false;
    },
    
    removeAllSelectionsEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$removeAllSelectionsEventHandler(sender, eventArgs) {
        this._log.debug('RemoveAllSelections');
        this._betSlipService.removeAllSelections();
        window.event.returnValue = false;
    },
    
    showSelectionInfoOutEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$showSelectionInfoOutEventHandler(sender, eventArgs) {
        this._log.debug('ShowSelectionInfoOut');
        var selectionInfo = this.getPrivateDomElement('selection-info');
        if (selectionInfo) {
            selectionInfo.style.visibility = 'hidden';
        }
    },
    
    showSelectionInfoOverEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$showSelectionInfoOverEventHandler(sender, eventArgs) {
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        this._log.debug(String.format('ShowSelectionInfoOver IDFOSelection=[{0}]', IDFOSelection));
        var key = this._betSlipService.getSimpleSelectionKey(IDFOSelection);
        this.showSelectionInfo(key, eventArgs.parameters.getAsNumber('offset'), eventArgs.domElement);
    },
    
    showScorecastSelectionInfoOverEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$showScorecastSelectionInfoOverEventHandler(sender, eventArgs) {
        var IDFOEventScorecast = eventArgs.parameters.getAsNumber('idfoeventscorecast');
        var IDFOSelection1GS = eventArgs.parameters.getAsNumber('idfoselection1gs');
        var IDFOSelectionCS = eventArgs.parameters.getAsNumber('idfoselectioncs');
        this._log.debug(String.format('ShowScorecastSelectionInfoOver IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        var key = this._betSlipService.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        this.showSelectionInfo(key, eventArgs.parameters.getAsNumber('offset'), eventArgs.domElement);
    },
    
    setSimpleSelectionPriceTypeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionPriceTypeEventHandler(sender, eventArgs) {
        this._log.debug(String.format('SetSimpleSelectionPriceType IDFOSelection=[{0}] activePriceType=[{1}]', eventArgs.parameters.getAsNumber('idfoselection'), Number.parse((eventArgs.domElement).value)));
        this._betSlipService.setSimpleSelectionPriceType(eventArgs.parameters.getAsNumber('idfoselection'), Number.parse((eventArgs.domElement).value));
    },
    
    setSimpleSelectionEachWayClickEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionEachWayClickEventHandler(sender, eventArgs) {
        this.setSimpleSelectionEachWay(eventArgs.parameters.getAsNumber('idfoselection'), ((eventArgs.domElement).checked) ? 0 : -1);
    },
    
    setSimpleSelectionEachWayChangeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionEachWayChangeEventHandler(sender, eventArgs) {
        this.setSimpleSelectionEachWay(eventArgs.parameters.getAsNumber('idfoselection'), Number.parse((eventArgs.domElement).value));
    },
    
    setStakePerSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setStakePerSelectionEventHandler(sender, eventArgs) {
        var stake = (eventArgs.domElement).value;
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        this._log.debug(String.format('SetStakePerSelection stake=[{0}] IDFOSelection=[{1}]', stake, IDFOSelection));
        if (this.isValidStake(stake)) {
            var parsedStake = (isNaN(Number.parse(stake))) ? 0 : Number.parse(stake);
            this._betSlipService.setStakePerSelection(IDFOSelection, parsedStake);
        }
    },
    
    setStakePerScorecastSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setStakePerScorecastSelectionEventHandler(sender, eventArgs) {
        var stake = (eventArgs.domElement).value;
        var IDFOEventScorecast = eventArgs.parameters.getAsNumber('idfoeventscorecast');
        var IDFOSelection1GS = eventArgs.parameters.getAsNumber('idfoselection1gs');
        var IDFOSelectionCS = eventArgs.parameters.getAsNumber('idfoselectioncs');
        this._log.debug(String.format('SetStakePerScorecastSelection stake=[{0}] IDFOEventScorecast=[{1}] IDFOSelection1GS=[{2}] IDFOSelectionCS=[{3}]', stake, IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        if (this.isValidStake(stake)) {
            var parsedStake = (isNaN(Number.parse(stake))) ? 0 : Number.parse(stake);
            this._betSlipService.setStakePerScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, parsedStake);
        }
    },
    
    removeSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$removeSelectionEventHandler(sender, eventArgs) {
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        this._log.debug(String.format('RemoveSelection IDFOSelection=[{0}]', IDFOSelection));
        this._betSlipService.removeSelection(IDFOSelection);
        window.event.returnValue = false;
    },
    
    removeScorecastSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$removeScorecastSelectionEventHandler(sender, eventArgs) {
        var IDFOEventScorecast = eventArgs.parameters.getAsNumber('idfoeventscorecast');
        var IDFOSelection1GS = eventArgs.parameters.getAsNumber('idfoselection1gs');
        var IDFOSelectionCS = eventArgs.parameters.getAsNumber('idfoselectioncs');
        this._log.debug(String.format('RemoveScorecastSelection IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        this._betSlipService.removeScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        window.event.returnValue = false;
    },
    
    setIsEachWayPerBetTypeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setIsEachWayPerBetTypeEventHandler(sender, eventArgs) {
        var IDFOBetType = eventArgs.parameters.getAsString('idfobettype');
        var isEachWay = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetIsEachWayPerBetType IDFOBetType=[{0}] isEachWay=[{1}]', IDFOBetType, isEachWay));
        this._betSlipService.setIsEachWayPerBetType(IDFOBetType, isEachWay);
    },
    
    setStakePerBetTypeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setStakePerBetTypeEventHandler(sender, eventArgs) {
        var stake = (eventArgs.domElement).value;
        var IDFOBetType = eventArgs.parameters.getAsString('idfobettype');
        this._log.debug(String.format('SetStakePerBetType stake=[{0}] IDFOBetType=[{1}]', stake, IDFOBetType));
        if (this.isValidStake(stake)) {
            var parsedStake = (isNaN(Number.parse(stake))) ? 0 : Number.parse(stake);
            this._betSlipService.setStakePerBetType(IDFOBetType, parsedStake, false);
        }
    },
    
    closeBetSlipUpdateMessageBarEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$closeBetSlipUpdateMessageBarEventHandler(sender, eventArgs) {
        this.getPrivateDomElement('betslipchanges').style.display = 'none';
        this._betSlipService.clearPreviousSelections();
        window.event.returnValue = false;
    },
    
    setSimpleSelectionIsTrapEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionIsTrapEventHandler(sender, eventArgs) {
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        var isTrap = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetSimpleSelectionIsTrap IDFOSelection=[{0}] isTrap=[{1}]', IDFOSelection, isTrap));
        this._betSlipService.setSimpleSelectionIsTrap(IDFOSelection, isTrap);
    },
    
    checkBetSlipKeyPressEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$checkBetSlipKeyPressEventHandler(sender, eventArgs) {
        if (window.event.srcElement.tagName.toUpperCase() === 'INPUT') {
            var targetElement = window.event.srcElement;
            if (window.event.keyCode === 13 && targetElement.type.toUpperCase() === 'TEXT') {
                targetElement.blur();
                this.placeBet();
                window.event.returnValue = false;
            }
        }
    },
    
    populateBetSlipCalculation: function AbstractMMCoreComponents_AbstractBetSlipComponent$populateBetSlipCalculation() {
        var betSlipCalculation = this._betSlipService.getBetSlipCalculation();
        var totalStake = 0;
        var totalPotentialReturn = 0;
        var totalPotentialReturnType = 0;
        var $dict1 = this._betSlipService.getSelections();
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var selection = entry.value;
            var unitStakePerSelection = 0;
            if (Object.keyExists(this._betSlipService.getStakePerSelection(), entry.key)) {
                unitStakePerSelection = this._betSlipService.getStakePerSelection()[entry.key];
            }
            var unitStakeInputElement = this.getPrivateDomElement(String.format('{0}-unit-stake', entry.key));
            if (unitStakeInputElement) {
                if (this._updateStakeTextboxOnStateChange && (Number.parse(unitStakeInputElement.value) !== unitStakePerSelection)) {
                    unitStakeInputElement.value = (!unitStakePerSelection) ? '' : unitStakePerSelection.toString();
                }
            }
            var selectionCalculation = (!unitStakePerSelection && !Object.keyExists(betSlipCalculation.PerSelection, entry.key)) ? null : betSlipCalculation.PerSelection[entry.key];
            var totalStakeDomElement = this.getPrivateDomElement(String.format('{0}-total-stake', entry.key));
            if (totalStakeDomElement) {
                var selectionStake = (!selectionCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(selectionCalculation.TotalStake);
                if (totalStakeDomElement.tagName === 'INPUT') {
                    if (selectionStake !== '') {
                        (totalStakeDomElement).value = selectionStake;
                    }
                }
                else {
                    totalStakeDomElement.innerText = selectionStake;
                }
            }
            var potentialReturnDomElement = this.getPrivateDomElement(String.format('{0}-potential-return', entry.key));
            if (potentialReturnDomElement) {
                var selectionReturn = (!selectionCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(selectionCalculation.PotentialReturn);
                if (potentialReturnDomElement.tagName === 'INPUT') {
                    if ((selectionReturn !== '')) {
                        (potentialReturnDomElement).value = selectionReturn;
                    }
                }
                else {
                    potentialReturnDomElement.innerText = selectionReturn;
                }
            }
            if (selectionCalculation) {
                totalStake += selectionCalculation.TotalStake;
                totalPotentialReturn += (selectionCalculation.PotentialReturn < 0) ? 0 : selectionCalculation.PotentialReturn;
                totalPotentialReturnType = AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType(selectionCalculation.PotentialReturn, totalPotentialReturnType);
            }
        }
        var allowedBetTypes = this._betSlipService.getAllowedBetTypes();
        for (var i = 0; i < allowedBetTypes.length; i++) {
            var unitStakePerBetType = 0;
            if (Object.keyExists(this._betSlipService.getStakePerBetType(), allowedBetTypes[i].IDFOBetType)) {
                unitStakePerBetType = this._betSlipService.getStakePerBetType()[allowedBetTypes[i].IDFOBetType];
            }
            var unitStakeInputElement = this.getPrivateDomElement(String.format('{0}-unit-stake', allowedBetTypes[i].IDFOBetType));
            if (unitStakeInputElement) {
                if (this._updateStakeTextboxOnStateChange && (Number.parse(unitStakeInputElement.value) !== unitStakePerBetType)) {
                    unitStakeInputElement.value = (!unitStakePerBetType) ? '' : unitStakePerBetType.toString();
                }
            }
            var betTypeCalculation = (!unitStakePerBetType && !Object.keyExists(betSlipCalculation.PerBetType, allowedBetTypes[i].IDFOBetType)) ? null : betSlipCalculation.PerBetType[allowedBetTypes[i].IDFOBetType];
            var totalStakeDomElement = this.getPrivateDomElement(String.format('{0}-total-stake', allowedBetTypes[i].IDFOBetType));
            if (totalStakeDomElement) {
                var multipleStake = (!betTypeCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatNumber(betTypeCalculation.TotalStake);
                if (totalStakeDomElement.tagName === 'INPUT') {
                    (totalStakeDomElement).value = multipleStake;
                }
                else {
                    totalStakeDomElement.innerText = multipleStake;
                }
            }
            var potentialReturnDomElement = this.getPrivateDomElement(String.format('{0}-potential-return', allowedBetTypes[i].IDFOBetType));
            if (potentialReturnDomElement) {
                var multipleReturn = (!betTypeCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(betTypeCalculation.PotentialReturn);
                if (potentialReturnDomElement.tagName === 'INPUT') {
                    (potentialReturnDomElement).value = multipleReturn;
                }
                else {
                    potentialReturnDomElement.innerText = multipleReturn;
                }
            }
            if (betTypeCalculation) {
                totalStake += betTypeCalculation.TotalStake;
                totalPotentialReturn += (betTypeCalculation.PotentialReturn < 0) ? 0 : betTypeCalculation.PotentialReturn;
                totalPotentialReturnType = AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType(betTypeCalculation.PotentialReturn, totalPotentialReturnType);
            }
        }
        var totalStakeDE = this.getPrivateDomElement('total-stake');
        if (totalStakeDE) {
            var totalBetSlipStake = AbstractMMCoreComponents.CommonBetting.formatNumber(totalStake);
            if (totalStakeDE.tagName === 'INPUT') {
                (totalStakeDE).value = totalBetSlipStake;
            }
            else {
                totalStakeDE.innerText = totalBetSlipStake;
            }
        }
        var potentialReturnDE = this.getPrivateDomElement('potential-return');
        if (potentialReturnDE) {
            var totalReturn = AbstractMMCoreComponents.CommonBetting.formatPotentialReturn((totalPotentialReturnType < 0) ? totalPotentialReturnType : totalPotentialReturn);
            if (potentialReturnDE.tagName === 'INPUT') {
                (potentialReturnDE).value = totalReturn;
            }
            else {
                potentialReturnDE.innerText = totalReturn;
            }
        }
    },
    
    toggleFreeBet: function AbstractMMCoreComponents_AbstractBetSlipComponent$toggleFreeBet() {
        var freeBet = this.getPrivateDomElement('is-free-label');
        var freeAccount = this._accountService.get_freeAccountDetails();
        if (freeAccount) {
            if (freeBet) {
                freeBet.style.display = (freeAccount.TradingBalance > 0) ? 'block' : 'none';
            }
        }
        else {
            if (freeBet) {
                freeBet.style.display = 'none';
            }
        }
        if (freeBet && freeBet.style.display === 'none' && this._betSlipService.getIsFree()) {
            this._betSlipService.setIsFree(false);
        }
    },
    
    setBusyStatus: function AbstractMMCoreComponents_AbstractBetSlipComponent$setBusyStatus(isBusy) {
        (this.getPrivateDomElement('place-bet')).disabled = isBusy;
        this._environment.getDomElement(this._domElementId).style.cursor = (isBusy) ? 'wait' : 'default';
    },
    
    isValidStake: function AbstractMMCoreComponents_AbstractBetSlipComponent$isValidStake(s) {
        return new RegExp('^\\d*(\\.\\d{1,2})?$').test(s);
    },
    
    placeBet: function AbstractMMCoreComponents_AbstractBetSlipComponent$placeBet() {
        this._log.debug('PlaceBet');
        if (this._userService.isLoggedIn()) {
            this.collapse();
        }
        if (this.validateBetslip()) {
            this.startBetPlacement(false);
        }
    },
    
    startBetPlacement: function AbstractMMCoreComponents_AbstractBetSlipComponent$startBetPlacement(checkBets) {
        this._log.debug('StartBetPlacement');
        if (!this._userService.isLoggedIn()) {
            alert(this.getTranslation('error-login'));
        }
        else if (!this._betSlipService.checkIfBetSlipHasStake()) {
            alert(this.getTranslation('error-stake'));
        }
        else if (!this._betSlipService.checkIfBetSlipHasCalculation()) {
            alert(this.getTranslation('error-selection'));
        }
        else {
            this._betSlipService.placeBetSlip((checkBets) ? FixedOddsBettingService.OverrideToShowConfirmation.overrideToShowConfirmation : FixedOddsBettingService.OverrideToShowConfirmation.notOverride);
        }
    },
    
    expand: function AbstractMMCoreComponents_AbstractBetSlipComponent$expand() {
        this._log.debug('Expand');
        var betslip = document.getElementById(this._domElementId);
        var betslipaction = this.getPrivateDomElement('acttogglebody');
        betslip.className = betslip.className.replace('bsoff', 'bson');
        this._environment.updateDomElementDirect(betslipaction, 'close slip');
    },
    
    collapse: function AbstractMMCoreComponents_AbstractBetSlipComponent$collapse() {
        this._log.debug('Collapse');
        var betslip = document.getElementById(this._domElementId);
        var betslipaction = this.getPrivateDomElement('acttogglebody');
        betslip.className = betslip.className.replace('bson', 'bsoff');
        this._environment.updateDomElementDirect(betslipaction, 'reveal slip');
    },
    
    adjustHeight: function AbstractMMCoreComponents_AbstractBetSlipComponent$adjustHeight() {
        if (this._autoAdjustHeight) {
            this._log.debug('AdjustHeight');
            if (this._heightThreshold !== '-1') {
                var betslip = document.getElementById(this._domElementId);
                var bstable = document.getElementById(this._domElementId + '-table');
                var bsbody = document.getElementById(this._domElementId + '-bsbody');
                if (this._heightThreshold === '0') {
                    var nDiff = document.documentElement.clientHeight - (betslip.offsetTop + bsbody.offsetTop + bstable.parentNode.offsetHeight);
                    if (nDiff < 0) {
                        bsbody.style.height = String.format('{0}px', document.documentElement.clientHeight - (betslip.offsetTop + bsbody.offsetTop));
                        bsbody.style.overflow = 'auto';
                    }
                    else if (nDiff > 0) {
                        bsbody.style.height = 'auto';
                        bsbody.style.overflow = 'visible';
                    }
                }
                else if (bsbody.offsetHeight > parseInt(this._heightThreshold)) {
                    bsbody.style.height = this._heightThreshold + 'px';
                    bsbody.style.overflow = 'auto';
                }
                else {
                    bsbody.style.height = 'auto';
                    bsbody.style.overflow = 'visible';
                }
            }
        }
    },
    
    showSelectionInfo: function AbstractMMCoreComponents_AbstractBetSlipComponent$showSelectionInfo(selectionKey, offset, parent) {
        var selection = this._betSlipService.getSelections()[selectionKey];
        if (!selection) {
            return;
        }
        var selectionInfo = this.getPrivateDomElement('selection-info');
        if (selectionInfo) {
            this.updatePrivateDomElement('selection-info-eventname', unescape(selection.EventName));
            this.updatePrivateDomElement('selection-info-marketname', unescape(selection.MarketName));
            this.updatePrivateDomElement('selection-info-selectionname', unescape(selection.SelectionName));
            this.updatePrivateDomElement('selection-info-price', this._fixedOddsBettingService.formatOdds(selection.IDFOPriceType[selection.ActivePriceType], selection.PriceUp, selection.PriceDown));
            this.updatePrivateDomElement('selection-info-handicap', (!selection.Handicap) ? 'N/A' : this.getSelectionHandicap(selection));
            selectionInfo.style.visibility = 'visible';
        }
        var actualOffset = (isNaN(offset)) ? 80 : offset;
        if (parent && selectionInfo) {
            selectionInfo.style.top = (parent.offsetTop + actualOffset).toString() + 'px';
        }
    },
    
    setSimpleSelectionEachWay: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionEachWay(IDFOSelection, activeEachWay) {
        this._log.debug(String.format('SetSimpleSelectionEachWay IDFOSelection=[{0}] activeEachWay=[{1}]', IDFOSelection, activeEachWay));
        this._betSlipService.setSimpleSelectionEachWay(IDFOSelection, activeEachWay);
    },
    
    setSimpleSelectionIsTrap: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionIsTrap(IDFOSelection, isTrap) {
    },
    
    getSelectionHandicap: function AbstractMMCoreComponents_AbstractBetSlipComponent$getSelectionHandicap(selection) {
        var selectionHandicap = '';
        if (selection.Handicap) {
            if (selection.HADValue === 'A') {
                if (selection.Handicap < 0) {
                    selectionHandicap += String.format(' +{0}', selection.Handicap * -1);
                }
                else {
                    selectionHandicap += String.format(' {0}', selection.Handicap * -1);
                }
            }
            else {
                selectionHandicap += String.format(' {0}', selection.Handicap);
            }
        }
        return selectionHandicap;
    },
    
    setSelectionActivity: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSelectionActivity(IDFOSelection, isActive, domElementId) {
        this._log.debug(String.format('SetSelectionActivity IDFOSelection=[{0}] isActive=[{1}] domElementId=[{2}]', IDFOSelection, isActive, domElementId));
        var row = this._environment.getDomElement(domElementId);
        row.className = (isActive) ? 'BSselHi' : 'BSsel';
        this._betSlipService.setSimpleSelectionActivity(IDFOSelection, isActive);
    },
    
    setScorecastSelectionActivity: function AbstractMMCoreComponents_AbstractBetSlipComponent$setScorecastSelectionActivity(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive, domElementId) {
        this._log.debug(String.format('SetSelectionActivity IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}] domElementId=[{4}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive, domElementId));
        var row = this._environment.getDomElement(domElementId);
        row.className = (isActive) ? 'BSselHi' : 'BSsel';
        this._betSlipService.setScorecastSelectionActivity(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive);
    },
    
    setScorecastSelectionPriceType: function AbstractMMCoreComponents_AbstractBetSlipComponent$setScorecastSelectionPriceType(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType) {
        this._log.debug(String.format('SetScorecastSelectionPriceType IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType));
        this._betSlipService.setScorecastSelectionPriceType(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType);
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.CommonBetting

AbstractMMCoreComponents.CommonBetting = function AbstractMMCoreComponents_CommonBetting() {
}
AbstractMMCoreComponents.CommonBetting.checkArrayDifferences = function AbstractMMCoreComponents_CommonBetting$checkArrayDifferences(arr1, arr2) {
    if (!arr1 && !arr2) {
        return false;
    }
    else if (!arr1 || !arr2) {
        return true;
    }
    else {
        if (arr1.length === arr2.length) {
            for (var i = 0; i < arr1.length; i++) {
                if (arr1[i] !== arr2[i]) {
                    return true;
                }
            }
        }
        else {
            return true;
        }
    }
    return false;
}
AbstractMMCoreComponents.CommonBetting.formatEachWayOdds = function AbstractMMCoreComponents_CommonBetting$formatEachWayOdds(ewReduction, ewTerms) {
    var eachWay = String.format('EW 1/{0} 1', ewReduction[0]);
    for (var i = 2; i <= ewTerms[0]; i++) {
        eachWay += String.format(',{0}', i);
    }
    return eachWay;
}
AbstractMMCoreComponents.CommonBetting.formatPriceTypes = function AbstractMMCoreComponents_CommonBetting$formatPriceTypes(IDFOPriceTypes) {
    var priceTypes = '';
    for (var i = 0; i < IDFOPriceTypes.length; i++) {
        priceTypes += String.format(' {0} ', IDFOPriceTypes[i]);
    }
    return priceTypes;
}
AbstractMMCoreComponents.CommonBetting.formatHandicap = function AbstractMMCoreComponents_CommonBetting$formatHandicap(HADValue, handicap) {
    var selectionHandicap = '';
    if (handicap) {
        if (HADValue === 'A') {
            if (handicap < 0) {
                selectionHandicap += String.format(' +{0}', handicap * -1);
            }
            else {
                selectionHandicap += String.format(' {0}', handicap * -1);
            }
        }
        else {
            selectionHandicap += String.format(' {0}', handicap);
        }
    }
    return selectionHandicap;
}
AbstractMMCoreComponents.CommonBetting.formatNumber = function AbstractMMCoreComponents_CommonBetting$formatNumber(number) {
    return (Framework.ScriptSharpQuirks.isNumberNull(number)) ? '' : number.format('N', true);
}
AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType = function AbstractMMCoreComponents_CommonBetting$updatePotentialReturnType(newPotentialReturn, currentType) {
    var thisState = 0;
    switch (newPotentialReturn) {
        case -1:
        case -2:
            thisState = newPotentialReturn;
            break;
        default:
            thisState = 0;
            break;
    }
    return (thisState < currentType) ? thisState : currentType;
}
AbstractMMCoreComponents.CommonBetting.formatPotentialReturn = function AbstractMMCoreComponents_CommonBetting$formatPotentialReturn(potentialReturn) {
    switch (potentialReturn) {
        case -1:
            return 'N/A';
        case -2:
            return 'ERR';
        default:
            return AbstractMMCoreComponents.CommonBetting.formatNumber(potentialReturn);
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractLoginComponent

AbstractMMCoreComponents.AbstractLoginComponent = function AbstractMMCoreComponents_AbstractLoginComponent() {
    AbstractMMCoreComponents.AbstractLoginComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractLoginComponent.prototype = {
    _supportCryptogramLogin: false,
    _enableRememberMe: false,
    
    usernameOnBlurEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$usernameOnBlurEventHandler(sender, eventArgs) {
        this.onUsernameBlur(eventArgs.domElement);
    },
    
    passwordOnBlurEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$passwordOnBlurEventHandler(sender, eventArgs) {
        this.onPasswordBlur(eventArgs.domElement);
    },
    
    usernameOnFocusEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$usernameOnFocusEventHandler(sender, eventArgs) {
        this.onUsernameFocus(eventArgs.domElement);
    },
    
    passwordOnFocusEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$passwordOnFocusEventHandler(sender, eventArgs) {
        this.onPasswordFocus(eventArgs.domElement);
    },
    
    bindGoToBehaviorEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$bindGoToBehaviorEventHandler(sender, eventArgs) {
        new NavigationService.GoToBehavior(eventArgs.domElement, null, this._navigationService);
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractLoginComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
    },
    
    _userService: null,
    
    setUserService: function AbstractMMCoreComponents_AbstractLoginComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    onUserChanged: function AbstractMMCoreComponents_AbstractLoginComponent$onUserChanged(eventSource) {
        this._log.debug('OnUserChanged');
        this.update();
    },
    
    get_usernameTextbox: function AbstractMMCoreComponents_AbstractLoginComponent$get_usernameTextbox() {
        return this._environment.getDomElement(this._domElementId + '.username');
    },
    
    get_passwordTextbox: function AbstractMMCoreComponents_AbstractLoginComponent$get_passwordTextbox() {
        return this._environment.getDomElement(this._domElementId + '.password');
    },
    
    get_rememberMeCheckbox: function AbstractMMCoreComponents_AbstractLoginComponent$get_rememberMeCheckbox() {
        return this._environment.getDomElement(this._domElementId + '.rememberme');
    },
    
    init: function AbstractMMCoreComponents_AbstractLoginComponent$init(environment, componentInstanceName, domElementId, parameters) {
        if (parameters['support-cryptogram-login']) {
            this._supportCryptogramLogin = Boolean.parse(parameters['support-cryptogram-login']);
        }
        if (parameters['enable-remember-me']) {
            this._enableRememberMe = Boolean.parse(parameters['enable-remember-me']);
        }
    },
    
    start: function AbstractMMCoreComponents_AbstractLoginComponent$start() {
        if (this.proceedWithCryptogramLogin()) {
            this._userService.loginWithCryptogram(Delegate.create(this, function(result) {
                this.enable();
                var _filters = this._navigationService.getPageFilter();
                delete _filters.username;
                delete _filters.password;
                this._navigationService.goTo(this._environment.getPageArea(), _filters);
            }), Delegate.create(this, function(exception) {
                var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs();
                eventArgs.parametersDictionary[AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2] = Framework.ExceptionUtil.getExceptionDetails(exception).get_message();
                this.update(this.get_componentElement(), null, this._parameters.get_xsltUrl(), this.getXsltParameters(null), eventArgs);
            }), this._navigationService.getPageFilter()['username'].toString().toLowerCase(), this._navigationService.getPageFilter()['password'].toString().toUpperCase());
        }
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractLoginComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction()) && !this._userService.isLoggedIn();
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractLoginComponent$renderComplete(eventArgs) {
        this.show();
        if (this._enableRememberMe) {
            if (this.isUsernameRemembered()) {
                this.get_rememberMeCheckbox().checked = true;
            }
        }
        if (this.shouldUsernameBeSetAfterInRepaint()) {
            this.setUsernameFromCookie();
        }
        var loginElement = this.getPrivateDomElement('form');
        if (loginElement) {
            var onLoginClickedBehaviour = new Framework.Behavior.ElementBehavior(loginElement);
            onLoginClickedBehaviour.add_onSubmit(Delegate.create(this, function(sender, ea) {
                this.onLoginClicked();
            }));
        }
        if (eventArgs.get_customEventArgs() && eventArgs.get_customEventArgs().parametersDictionary[AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2]) {
            this.enable();
            alert(eventArgs.get_customEventArgs().parametersDictionary[AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2]);
        }
    },
    
    getXsltParameters: function AbstractMMCoreComponents_AbstractLoginComponent$getXsltParameters(contextObject) {
        var xsltParameters = {};
        xsltParameters['component-dom-element-id'] = this._domElementId;
        xsltParameters['component-instance-name'] = this._componentInstanceName;
        xsltParameters['enable-remember-me'] = this._enableRememberMe;
        return xsltParameters;
    },
    
    shouldUsernameBeSetAfterInRepaint: function AbstractMMCoreComponents_AbstractLoginComponent$shouldUsernameBeSetAfterInRepaint() {
        return true;
    },
    
    setUsernameFromCookie: function AbstractMMCoreComponents_AbstractLoginComponent$setUsernameFromCookie() {
        if (!this.get_usernameTextbox()) {
            return;
        }
        if (this._enableRememberMe) {
            if (this.isUsernameRemembered() && (String.isNullOrEmpty(this.get_usernameTextbox().value))) {
                this.get_usernameTextbox().value = Framework.CookieUtil.getCookie('username');
            }
        }
    },
    
    onLoginClicked: function AbstractMMCoreComponents_AbstractLoginComponent$onLoginClicked() {
        if (!this.get_usernameTextbox()) {
            return;
        }
        if (!this.get_passwordTextbox()) {
            return;
        }
        var CheckUsernameBlank = this.get_usernameTextbox().value.trim();
        var CheckPassswordBlank = this.get_passwordTextbox().value.trim();
        if (!CheckUsernameBlank.length || !CheckPassswordBlank.length) {
            window.event.returnValue = false;
            return;
        }
        this.disable();
        if (this.get_rememberMeCheckbox()) {
            if (this.get_rememberMeCheckbox().checked) {
                Framework.CookieUtil.setCookie('username', this.get_usernameTextbox().value);
            }
            else {
                Framework.CookieUtil.clearCookie('username');
            }
        }
        this._userService.login(Delegate.create(this, function(result) {
            this.enable();
        }), Delegate.create(this, function(exception) {
            this.enable();
            alert(Framework.ExceptionUtil.getExceptionDetails(exception).get_message());
        }), this.get_usernameTextbox().value, this.get_passwordTextbox().value);
        window.event.returnValue = false;
    },
    
    onUsernameBlur: function AbstractMMCoreComponents_AbstractLoginComponent$onUsernameBlur(element) {
    },
    
    onUsernameFocus: function AbstractMMCoreComponents_AbstractLoginComponent$onUsernameFocus(element) {
    },
    
    onPasswordBlur: function AbstractMMCoreComponents_AbstractLoginComponent$onPasswordBlur(element) {
    },
    
    onPasswordFocus: function AbstractMMCoreComponents_AbstractLoginComponent$onPasswordFocus(element) {
    },
    
    proceedWithCryptogramLogin: function AbstractMMCoreComponents_AbstractLoginComponent$proceedWithCryptogramLogin() {
        if (!this._supportCryptogramLogin) {
            return false;
        }
        if (!this._navigationService.getPageFilter()['username']) {
            return false;
        }
        if (!this._navigationService.getPageFilter()['password']) {
            return false;
        }
        if (this._userService.isLoggedIn()) {
            return false;
        }
        return true;
    },
    
    isUsernameRemembered: function AbstractMMCoreComponents_AbstractLoginComponent$isUsernameRemembered() {
        return !String.isNullOrEmpty(Framework.CookieUtil.getCookie('username'));
    },
    
    enable: function AbstractMMCoreComponents_AbstractLoginComponent$enable() {
        this._environment.safelyRemoveCssClass(this._domElementId + '-form', 'wait');
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    disable: function AbstractMMCoreComponents_AbstractLoginComponent$disable() {
        this._environment.safelySetCssClass(this._domElementId + '-form', 'wait');
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    show: function AbstractMMCoreComponents_AbstractLoginComponent$show() {
        this._environment.safelySetAndUnsetCssClass(this._domElementId, 'visible', 'invisible');
    },
    
    hide: function AbstractMMCoreComponents_AbstractLoginComponent$hide() {
        this._environment.safelySetAndUnsetCssClass(this._domElementId, 'invisible', 'visible');
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractPaymentTransactionComponent

AbstractMMCoreComponents.AbstractPaymentTransactionComponent = function AbstractMMCoreComponents_AbstractPaymentTransactionComponent() {
    AbstractMMCoreComponents.AbstractPaymentTransactionComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractPaymentTransactionComponent.prototype = {
    _UpdateCreditCardEnabled: false,
    _DisplayDefaultCurrency: false,
    _hideInputsWhenSuccessfulTransaction: false,
    _useDefaultValidation: false,
    _selectedInstrumentSIType: '',
    _validationManager: null,
    regExNumber: '^[1-9]{1}\\d+$',
    regExDecimal: '^[1-9]{1}\\d{1,5}([\\.\\,]{1}\\d{1,2}){0,1}$',
    _accountService: null,
    
    setAccountService: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$setAccountService(accountService) {
        this._log.debug('SetAccountService');
        this._accountService = accountService;
    },
    
    onBalanceChanged: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$onBalanceChanged(eventSource) {
        this._log.debug('OnBalanceChanged');
        if (this._currentStatusArea$2 < 3) {
            this.update();
        }
        if (this._currentStatusArea$2 === 1) {
            this.activateSuccessStatusArea();
        }
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.update();
    },
    
    _userService: null,
    
    setUserService: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    onUserChanged: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$onUserChanged(eventSource) {
        this._log.debug('OnUserChanged');
        this.update();
    },
    
    init: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._UpdateCreditCardEnabled = Boolean.parse(parameters['update-credit-card-enabled']);
        if (Object.keyExists(parameters, 'hide-inputs-when-successful-transaction')) {
            this._hideInputsWhenSuccessfulTransaction = Boolean.parse(parameters['hide-inputs-when-successful-transaction']);
        }
        if (parameters['display-default-currency'] && !String.isNullOrEmpty(parameters['display-default-currency'].toString())) {
            this._DisplayDefaultCurrency = Boolean.parse(parameters['display-default-currency']);
        }
        if (Object.keyExists(parameters, 'use-default-validation')) {
            this._useDefaultValidation = Boolean.parse(parameters['use-default-validation'].toString());
        }
        this._validationManager = new Framework.Validation.ValidationManager(this._environment);
        if (this._useDefaultValidation) {
            this.registerValidators();
        }
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$renderComplete(eventArgs) {
        this.displayRegisteredSettlementInstructions(null);
        var IDMMTXRequest = this._navigationService.getPageFilter()['IDMMTXRequest'];
        if (IDMMTXRequest) {
            this.getTransactionState(IDMMTXRequest);
        }
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction()) && this._userService.isLoggedIn();
    },
    
    getXsltParameters: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$getXsltParameters(contextObject) {
        var xsltParameters = {};
        xsltParameters['component-instance-name'] = this._componentInstanceName;
        xsltParameters['component-dom-element-id'] = this._domElementId;
        xsltParameters['is-deposit'] = this.isDeposit();
        if (this._accountService.get_accountsDetails()) {
            xsltParameters['display-currency'] = this._getAcctCurrency$2();
        }
        return xsltParameters;
    },
    
    beginPaymentTransactionEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$beginPaymentTransactionEventHandler(sender, eventArgs) {
        this.setStatusArea(-1);
        var active = -1;
        var paymentInstructions = document.getElementsByName('IDMMSIInstruction');
        for (var i = 0; i < paymentInstructions.length; i++) {
            if ((paymentInstructions[i]).checked) {
                active = parseInt((paymentInstructions[i]).value);
            }
        }
        if (active === -1) {
            alert(this.getTranslation('translate-no-selection'));
        }
        else {
            var cvv2 = this.getPrivateDomElement(active + '-cvv2number');
            var cvv2Value = '';
            if (this.isDeposit() && cvv2) {
                cvv2Value = (cvv2).value;
                if (!cvv2Value.length) {
                    alert(this.getTranslation('translate-please-enter-cvv2'));
                    return;
                }
                else if (isNaN(Number.parse(cvv2Value))) {
                    alert(this.getTranslation('translate-please-enter-valid-cvv2'));
                    return;
                }
            }
            this.beginPaymentTransaction((this.getPrivateDomElement('Password')).value, active, (this.getPrivateDomElement('Amount')).value, cvv2Value);
        }
    },
    
    paymentMethodListEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$paymentMethodListEventHandler(sender, eventArgs) {
        this.goToPaymentMethodList();
        window.event.returnValue = false;
    },
    
    goRegisterCardEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegisterCardEventHandler(sender, eventArgs) {
        this.goRegister('register-card');
        window.event.returnValue = false;
    },
    
    goRegisterChequeEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegisterChequeEventHandler(sender, eventArgs) {
        this.goRegister('register-cheque');
        window.event.returnValue = false;
    },
    
    goRegisterBankTransferEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegisterBankTransferEventHandler(sender, eventArgs) {
        var pageFilter = this._navigationService.getPageFilter();
        pageFilter['action'] = 'register-bank-transfer';
        pageFilter['idmmsitype'] = eventArgs.parameters.getAsString('idmmsitype');
        this._navigationService.goTo(this._navigationService.getPageArea(), pageFilter);
        window.event.returnValue = false;
    },
    
    goRegisterRedirectBasedWalletEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegisterRedirectBasedWalletEventHandler(sender, eventArgs) {
        this.goRegisterRedirectBasedWallet(eventArgs.parameters.getAsString('idmmsitype'));
        window.event.returnValue = false;
    },
    
    goToAreaEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goToAreaEventHandler(sender, eventArgs) {
        this.goToArea(eventArgs.parameters.getAsString('area'), eventArgs.parameters.getAsString('filter'));
    },
    
    formSubmitEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$formSubmitEventHandler(sender, eventArgs) {
        window.event.returnValue = false;
    },
    
    clickPaymentInstrumentEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$clickPaymentInstrumentEventHandler(sender, eventArgs) {
        this._log.debug('ClickPaymentInstrument');
        this._selectedInstrumentSIType = eventArgs.parameters.getAsString('idmmsitype');
        var inputs = this.getPrivateDomElement('deposit-form').getElementsByTagName('INPUT');
        for (var i = 0; i < inputs.length; i++) {
            if (inputs[i].getAttribute('type') !== 'radio' || inputs[i].getAttribute('name') !== 'IDMMSIInstruction') {
                continue;
            }
            if (inputs[i].parentNode.parentNode.className.indexOf('cur') === -1) {
                if (inputs[i] !== eventArgs.domElement) {
                    continue;
                }
                inputs[i].parentNode.parentNode.className += ' cur';
                var cvv2spans = inputs[i].parentNode.parentNode.getElementsByTagName('SPAN');
                if (cvv2spans.length > 0) {
                    if (this.isDeposit()) {
                        cvv2spans[0].style.display = 'inline';
                    }
                }
            }
            else {
                if (inputs[i] === eventArgs.domElement) {
                    continue;
                }
                inputs[i].parentNode.parentNode.className = inputs[i].parentNode.parentNode.className.replace('cur', '');
                var cvv2spans = inputs[i].parentNode.parentNode.getElementsByTagName('SPAN');
                if (cvv2spans.length > 0) {
                    cvv2spans[0].style.display = 'none';
                }
            }
        }
    },
    
    showCreditCardDetailsPanelEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$showCreditCardDetailsPanelEventHandler(sender, eventArgs) {
        var div = this.getPrivateDomElement(String.format('{0}-creditcarddetails', eventArgs.parameters.getAsString('instructionno')));
        if (div.style.display === 'block') {
            eventArgs.domElement.style.display = 'block';
            div.style.display = 'none';
        }
        else {
            eventArgs.domElement.style.display = 'none';
            div.style.display = 'block';
        }
        window.event.returnValue = false;
    },
    
    updateCreditCardDetailsEventHandler: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$updateCreditCardDetailsEventHandler(sender, eventArgs) {
        var IDMMSIInstruction = eventArgs.parameters.getAsNumber('idmmsiinstruction');
        var newExpiryMonth = 0;
        var newExpiryYear = 0;
        var newIssueNumber = null;
        var newStartOfValidityMonth = null;
        var newStartOfValidityYear = null;
        var newExpiryYearDropDown = this.getPrivateDomElement(String.format('{0}-expiry-year-select', IDMMSIInstruction));
        var newExpiryMonthDropDown = this.getPrivateDomElement(String.format('{0}-expiry-month-select', IDMMSIInstruction));
        newExpiryMonth = Number.parse(newExpiryMonthDropDown.value);
        newExpiryYear = Number.parse(newExpiryYearDropDown.value);
        var issueNumberElement = this.getPrivateDomElement(String.format('{0}-issuenumber-input', IDMMSIInstruction));
        if (issueNumberElement) {
            newIssueNumber = Number.parse((issueNumberElement).value);
            if (isNaN(newIssueNumber)) {
                alert('Invalid Issue Number');
                return;
            }
        }
        var startOfValidityYearDropDown = this.getPrivateDomElement(String.format('{0}-validity-year-select', IDMMSIInstruction));
        var startOfValidityMonthDropDown = this.getPrivateDomElement(String.format('{0}-validity-month-select', IDMMSIInstruction));
        if (startOfValidityYearDropDown && startOfValidityMonthDropDown) {
            newStartOfValidityMonth = Number.parse((startOfValidityMonthDropDown).value);
            newStartOfValidityYear = Number.parse((startOfValidityYearDropDown).value);
        }
        try {
            var dict = {};
            dict['IDMMSIInstruction'] = IDMMSIInstruction;
            dict['ExpiryMonth'] = newExpiryMonth;
            dict['ExpiryYear'] = newExpiryYear;
            dict['StartOfValidityMonth'] = newStartOfValidityMonth;
            dict['StartOfValidityYear'] = newStartOfValidityYear;
            dict['CardIssueNumber'] = newIssueNumber;
            this._accountService.updateCreditCardDetails(Delegate.create(this, function(o) {
                alert('Credit Card Updated');
                this.update();
            }), Delegate.create(this, function(ex) {
                if (ex.message.indexOf('|') !== -1) {
                    alert(ex.message.substr(ex.message.indexOf('|') + 1));
                }
                else {
                    this._log.debug(ex.message);
                    alert('Credit Card Update Failed.');
                }
            }), dict);
        }
        catch (e) {
            alert(e.message);
            return;
        }
        window.event.returnValue = false;
    },
    
    _getAcctCurrency$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_getAcctCurrency$2() {
        if (this._DisplayDefaultCurrency) {
            var ret = this._accountService.getCurrencySimbol();
            if (!String.isNullOrEmpty(ret)) {
                return ' (' + ret + ')';
            }
        }
        return '';
    },
    
    _currentStatusArea$2: 0,
    
    isDeposit: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$isDeposit() {
        return 'deposit' === this._navigationService.getAction();
    },
    
    getCVV2LabelText: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$getCVV2LabelText() {
        return 'CVV2:';
    },
    
    setStatusArea: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$setStatusArea(statusArea) {
        if (this._currentStatusArea$2 > -1) {
            this.getPrivateDomElement('status-' + AbstractMMCoreComponents.AbstractPaymentTransactionComponent._statusArea[this._currentStatusArea$2]).style.display = 'none';
        }
        this._currentStatusArea$2 = statusArea;
        if (this._currentStatusArea$2 > -1) {
            this.getPrivateDomElement('status-' + AbstractMMCoreComponents.AbstractPaymentTransactionComponent._statusArea[this._currentStatusArea$2]).style.display = 'block';
        }
    },
    
    activateTransientStatusArea: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$activateTransientStatusArea() {
        this.setStatusArea(0);
    },
    
    activateSuccessStatusArea: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$activateSuccessStatusArea() {
        this.setStatusArea(1);
    },
    
    activateSuccessStatusAreaWithInfo: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$activateSuccessStatusAreaWithInfo(transaction) {
        this.setStatusArea(1);
        if (transaction) {
            var txinfo = this.getPrivateDomElement('status-success-txref');
            if (txinfo && transaction.IDMMSITransaction.toString() !== '') {
                txinfo.style.display = 'block';
                this.updatePrivateDomElement('status-success-txref-id', transaction.IDMMSITransaction.toString());
            }
        }
    },
    
    activateApprovalStatusArea: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$activateApprovalStatusArea(transaction) {
        this.setStatusArea(3);
        if (transaction) {
            var txinfo = this.getPrivateDomElement('status-approval-txref');
            if (txinfo && transaction.IDMMSITransaction.toString() !== '') {
                txinfo.style.display = 'block';
                this.updatePrivateDomElement('status-approval-txref-id', transaction.IDMMSITransaction.toString());
            }
        }
    },
    
    activateFailedStatusArea: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$activateFailedStatusArea(description, extAdditionalData, extReference) {
        this.setStatusArea(2);
        var txmessage = this.getPrivateDomElement('status-failed-0');
        if (txmessage) {
            txmessage.style.display = 'block';
        }
        var prefix = String.format('{0}-status-{1}-', this._domElementId, AbstractMMCoreComponents.AbstractPaymentTransactionComponent._statusArea[2]);
        this._environment.updateDomElement(prefix + '0', description);
        this._environment.updateDomElement(prefix + '1-ifneeded', extAdditionalData);
        this._environment.updateDomElement(prefix + '2', extReference);
    },
    
    activateFailedStatusAreaWithInfo: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$activateFailedStatusAreaWithInfo(transaction) {
        this.setStatusArea(2);
        if (transaction) {
            var txinfo = this.getPrivateDomElement('status-failed-txref');
            if (txinfo && transaction.IDMMSITransaction.toString() !== '') {
                txinfo.style.display = 'block';
                this.updatePrivateDomElement('status-failed-txref-id', transaction.IDMMSITransaction.toString());
            }
            var txmessage = this.getPrivateDomElement('status-failed-0');
            if (txmessage && transaction.Description !== '') {
                txmessage.style.display = 'block';
                this.updatePrivateDomElement('status-failed-0', transaction.Description);
            }
        }
    },
    
    displayRegisteredSettlementInstructions: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$displayRegisteredSettlementInstructions(selectedIDMMSIInstruction) {
        this._log.debug('DisplayRegisteredSettlementInstructions');
        this._accountService.getRegisteredSettlementInstructions(Delegate.create(this, function(result) {
            this._log.debug('Rendering Registered Settlement Instructions');
            var instructions = result;
            this.getPrivateDomElement('deposit-form').style.display = (!instructions.length) ? 'none' : 'block';
            var _selectedInstrument = 0;
            if (!instructions.length) {
                this.getPrivateDomElement('links').style.display = 'block';
                this.disable();
                document.getElementById(this._domElementId).style.cursor = 'default';
                this.goToPaymentMethodList();
            }
            else {
                instructions.sort(Delegate.create(this, function(pi1, pi2) {
                    return this.paymentInstrumentCompareCallback(pi1, pi2);
                }));
                var tableContent = new StringBuilder();
                for (var i = 0; i < instructions.length; i++) {
                    var isSelected = (selectedIDMMSIInstruction === instructions[i].IDMMSIInstruction) || (!selectedIDMMSIInstruction && instructions[i].IsDefaultForPayments);
                    if (isSelected) {
                        this._selectedInstrumentSIType = instructions[i].IDMMSIType;
                    }
                    tableContent.append(String.format('\r\n\t\t\t\t\t\t\t\t\t<div class=\"cr {6} {7}\">\r\n\t\t\t\t\t\t\t\t\t\t<label class=\"inline\">\r\n\t\t\t\t\t\t\t\t\t\t\t<input {0}\r\n\t\t\t\t\t\t\t\t\t\t\t\ttype=\"radio\"\r\n\t\t\t\t\t\t\t\t\t\t\t\tname=\"IDMMSIInstruction\"\r\n\t\t\t\t\t\t\t\t\t\t\t\tvalue=\"{1}\"\r\n\t\t\t\t\t\t\t\t\t\t\t\tbehavior.ID=\"ClickPaymentInstrument\"\r\n\t\t\t\t\t\t\t\t\t\t\t\tbehavior.autobind.ClickPaymentInstrument=\"onclick\"\r\n\t\t\t\t\t\t\t\t\t\t\t\tbehavior.autobind.ClickPaymentInstrument.idmmsitype=\"{7}\"\r\n\t\t\t\t\t\t\t\t\t\t\t/>\r\n\t\t\t\t\t\t\t\t\t\t\t{2} ({3})\r\n\t\t\t\t\t\t\t\t\t\t</label>', (isSelected) ? ' checked=\'checked\'' : '', instructions[i].IDMMSIInstruction, instructions[i].MMSITypeName, instructions[i].DisplayLabel, (instructions[i].IDMMSIClass === 'CR') ? 'block' : 'none', this._domElementId, (isSelected) ? 'cur' : '', instructions[i].IDMMSIType.toUpperCase()));
                    if (instructions[i].IDMMSIClass === 'CR') {
                        if (instructions[i].IsCVV2Needed) {
                            tableContent.append(String.format('<span id=\"{1}-{0}-cvv2numberlabel\" style=\"display:{3}\">,\r\n\t\t\t\t\t\t\t\t\t\t<label class=\"inline\" for=\"{1}-{0}-cvv2number\">{2}</label>\r\n\t\t\t\t\t\t\t\t\t\t<input type=\"text\" size=\"3\" maxlength=\"3\" value=\"\" id=\"{1}-{0}-cvv2number\" name=\"{1}-{0}-cvv2number\" /></span>', instructions[i].IDMMSIInstruction, this._domElementId, this.getCVV2LabelText(), (instructions.length === 1 && this.isDeposit()) ? 'inline' : 'none'));
                        }
                        if (this._UpdateCreditCardEnabled) {
                            tableContent.append(String.format('<br>\r\n\t\t\t\t\t\t\t\t\t\t\t<label class=\"inline\">\r\n\t\t\t\t\t\t\t\t\t\t\t\t<a href=\"#\" behavior.ID=\"ShowCreditCardDetailsPanel\" behavior.autobind.ShowCreditCardDetailsPanel=\"onclick\" behavior.ShowCreditCardDetailsPanel.instructionno=\"{0}\">\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t[Click here to update an expired card]\r\n\t\t\t\t\t\t\t\t\t\t\t\t</a>\r\n\t\t\t\t\t\t\t\t\t\t\t</label>', instructions[i].IDMMSIInstruction));
                            tableContent.append(String.format('<div id=\"{0}-{1}-creditcarddetails\" class=\"CreditCardDetails\" style=\"display:none\">', this._domElementId, instructions[i].IDMMSIInstruction));
                            tableContent.append(String.format('<table border=\"0\">\r\n\t\t\t\t\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t\t\t\t\t<td nowrap class=\"left\" style=\"border:0px\">Expiry Date (mm/yyyyy)</td>\r\n\t\t\t\t\t\t\t\t\t\t\t\t<td style=\"border:0px\">\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t<select id=\"{0}-{1}-expiry-month-select\">{2}</select>\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t<select id=\"{0}-{1}-expiry-year-select\">{3}</select>\r\n\t\t\t\t\t\t\t\t\t\t\t\t</td>\r\n\t\t\t\t\t\t\t\t\t\t\t</tr>', this._domElementId, instructions[i].IDMMSIInstruction, this._getExpiryMonthOptions$2(), this._getExpiryYearOptions$2(), this._componentInstanceName));
                            if (instructions[i].CardIssueNumber) {
                                tableContent.append(String.format('<tr>\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t<td nowrap class=\"left\" style=\"border:0px\">Issue Number</td>\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t<td style=\"border:0px\"><span><input class=\"IssueNumberTextField\" type=\"text\" id=\"{0}-{1}-issuenumber-input\"/></span></td>\r\n\t\t\t\t\t\t\t\t\t\t\t\t</tr>', this._domElementId, instructions[i].IDMMSIInstruction));
                            }
                            if (instructions[i].StartOfValidityYear && instructions[i].StartOfValidityMonth) {
                                tableContent.append(String.format('<tr>\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t<td nowrap class=\"left\" style=\"border:0px\">Valid from (mm/yyyy)</td>\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t<td style=\"border:0px\"><select id=\"{0}-{1}-validity-month-select\">{2}</select><select id=\"{0}-{1}-validity-year-select\">{3}</select></td>\r\n\t\t\t\t\t\t\t\t\t\t\t\t</tr>', this._domElementId, instructions[i].IDMMSIInstruction, this._getStartOfValidityMonthOptions$2(), this._getStartOfValidityYearOptions$2()));
                            }
                            tableContent.append(String.format('<tr>\r\n\t\t\t\t\t\t\t\t\t\t\t\t<td style=\"border:0px\">&nbsp;</td>\r\n\t\t\t\t\t\t\t\t\t\t\t\t<td style=\"border:0px\"><input type=\"button\" class=\"CreditCardButton\" id=\"{0}-{1}-expiry-button\" value=\"Update\" behavior.ID=\"UpdateCreditCardDetails\" behavior.autobind.UpdateCreditCardDetails=\"onclick\" behavior.UpdateCreditCardDetails.idmmsiinstruction=\"{1}\"/></td>\r\n\t\t\t\t\t\t\t\t\t\t\t</tr>', this._domElementId, instructions[i].IDMMSIInstruction));
                            tableContent.append('</table></div>');
                        }
                        tableContent.append('</div></div>');
                    }
                    else {
                        tableContent.append('</div>');
                    }
                    if (i < instructions.length - 1) {
                        tableContent.append('<br />');
                    }
                    if (isSelected && instructions[i].IDMMSIClass === 'CR' && instructions[i].IsCVV2Needed) {
                        _selectedInstrument = instructions[i].IDMMSIInstruction;
                    }
                }
                this.updatePrivateDomElement('RegisteredSettlementInstructions', tableContent.toString());
                Framework.Behavior.Binding.BehaviorBinder.autoBind(this.getPrivateDomElement('RegisteredSettlementInstructions'), this);
                var instruments = this.getPrivateDomElement('instruments');
                if (instruments) {
                    instruments.style.display = 'block';
                }
                if (_selectedInstrument > 0) {
                    if (this.isDeposit()) {
                        this.getPrivateDomElement(_selectedInstrument + '-cvv2numberlabel').style.display = 'inline';
                    }
                }
                this._pleaseGoToPaymentForm$2();
                this.enable();
            }
        }), Delegate.create(this, function(exception) {
            this._log.debug('AbstractPaymentTransactionComponent An error occured while invoking GetRegisteredSettlementInstructions');
        }), this.getIDMMSITransactionType());
    },
    
    paymentInstrumentCompareCallback: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$paymentInstrumentCompareCallback(pi1, pi2) {
        return 0;
    },
    
    _pleaseGoToPaymentForm$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_pleaseGoToPaymentForm$2() {
        this._log.debug('GoToPaymentForm');
        var payForm = this.getPrivateDomElement('payform');
        var payLinks = this.getPrivateDomElement('links');
        if (payForm && payLinks) {
            payLinks.style.display = 'none';
            payForm.style.display = 'block';
            payForm.focus();
        }
        var payFormLink = this.getPrivateDomElement('revealpaymentform');
        var payLinksLink = this.getPrivateDomElement('revealpaymentmethodlist');
        if (payFormLink && payLinksLink) {
            if (payLinksLink.parentNode) {
                payLinksLink.parentNode.className = payLinksLink.parentNode.className.replace('cur', '');
                payLinksLink.style.display = 'inline';
            }
            if (payFormLink.parentNode) {
                payFormLink.parentNode.className += ' cur';
                payFormLink.style.display = 'inline';
            }
        }
    },
    
    bindBehaviors: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$bindBehaviors(domID) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domID), (this));
    },
    
    _getStartOfValidityMonthOptions$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_getStartOfValidityMonthOptions$2() {
        var currentTime = new Date();
        var currentMonth = currentTime.getMonth() + 1;
        var builder = new StringBuilder();
        for (var i = 1; i <= 12; i++) {
            builder.appendLine(String.format('<option value=\"{0}\" {1}>{0}</option>', (i < 10) ? '0' + i : i.toString(), (i === currentMonth) ? 'selected' : ''));
        }
        return builder.toString();
    },
    
    _getStartOfValidityYearOptions$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_getStartOfValidityYearOptions$2() {
        var currentTime = new Date();
        var currentYear = currentTime.getFullYear();
        var startYear = currentYear - 4;
        var builder = new StringBuilder();
        for (var i = startYear; i <= currentYear; i++) {
            builder.appendLine(String.format('<option value=\"{0}\" {1}>{0}</option>', (i < 10) ? '0' + i : i.toString(), (i === currentYear) ? 'selected' : ''));
        }
        return builder.toString();
    },
    
    _getExpiryMonthOptions$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_getExpiryMonthOptions$2() {
        var currentTime = new Date();
        var currentMonth = currentTime.getMonth() + 1;
        var builder = new StringBuilder();
        for (var i = 1; i <= 12; i++) {
            builder.appendLine(String.format('<option value=\"{0}\" {1}>{0}</option>', (i < 10) ? '0' + i : i.toString(), (i === currentMonth) ? 'selected' : ''));
        }
        return builder.toString();
    },
    
    _getExpiryYearOptions$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_getExpiryYearOptions$2() {
        var currentTime = new Date();
        var currentYear = currentTime.getFullYear();
        var builder = new StringBuilder();
        for (var i = currentYear; i <= currentYear + 10; i++) {
            builder.appendLine(String.format('<option value=\"{0}\">{0}</option>', i));
        }
        return builder.toString();
    },
    
    getIDMMSITransactionType: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$getIDMMSITransactionType() {
        return (this.isDeposit()) ? 'R' : 'P';
    },
    
    redirect: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$redirect(IDMMSITXRequest) {
        var currentPort = (window.location.port === 80) ? '' : ':' + window.location.port.toString();
        var origurl = document.URL;
        if (origurl.indexOf('IDMMTXRequest') === -1) {
            origurl += String.format('&IDMMTXRequest={0}', IDMMSITXRequest);
        }
        origurl = escape(origurl);
        var returnUrl = String.format('{0}://{1}/Common/Payment/complete.aspx?IDMDLanguage={2}&IDMMTXRequest={3}&origurl={4}', this._environment.getProtocol(), window.location.hostname + currentPort, this._environment.getLanguage(), IDMMSITXRequest, origurl);
        this._accountService.getRBWRequest(Delegate.create(this, function(result) {
            if (!result) {
            }
            else {
                var redirectBasedWalletRequest = result;
                if (redirectBasedWalletRequest.IsPost) {
                    var rbwForm = this.getPrivateDomElement('rbw-form');
                    var $enum1 = redirectBasedWalletRequest.Parameters.getEnumerator();
                    while ($enum1.moveNext()) {
                        var parameter = $enum1.get_current();
                        var inputElement = document.createElement('input');
                        rbwForm.appendChild(inputElement);
                        inputElement.setAttribute('name', parameter.Name);
                        inputElement.setAttribute('value', parameter.Value);
                    }
                    eval(String.format('rbwForm.action = \'{0}\'', redirectBasedWalletRequest.Url));
                    eval('rbwForm.submit()');
                }
                else {
                    window.navigate(redirectBasedWalletRequest.UrlWithParameters);
                }
            }
        }), Delegate.create(this, function(exception) {
        }), IDMMSITXRequest, returnUrl, 'EN', 'Deposit from ' + window.location.hostname);
    },
    
    getTransactionState: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$getTransactionState(IDMMSITXRequest) {
        this._accountService.getSettlementInstructionTransactionState(Delegate.create(this, function(result) {
            var transactionState = result;
            if (transactionState.ShouldRedirect) {
                this.redirect(IDMMSITXRequest);
            }
            else if (transactionState.IsTransient) {
                if (this.isDeposit()) {
                    this.activateTransientStatusArea();
                    window.setTimeout(Delegate.create(this, function() {
                        this.getTransactionState(IDMMSITXRequest);
                    }), 3000);
                }
                else {
                    this.cleanInputs();
                    this.enable();
                    this.hideInputs();
                    this.activateApprovalStatusArea(transactionState);
                }
            }
            else {
                this.enable();
                if (transactionState.IsSuccess) {
                    this.activateSuccessStatusAreaWithInfo(transactionState);
                    this.cleanInputs();
                }
                else {
                    this.activateFailedStatusAreaWithInfo(transactionState);
                }
            }
        }), Delegate.create(this, function(exception) {
        }), IDMMSITXRequest);
    },
    
    cleanInputs: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$cleanInputs() {
        (this.getPrivateDomElement('Amount')).value = String.Empty;
        (this.getPrivateDomElement('Password')).value = String.Empty;
    },
    
    hideInputs: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$hideInputs() {
        if (this._hideInputsWhenSuccessfulTransaction) {
            var oAmountDiv = this.getPrivateDomElement('amount-div');
            var oBettingPasswordDiv = this.getPrivateDomElement('betting-password-div');
            if (oAmountDiv) {
                oAmountDiv.style.display = 'none';
            }
            if (oBettingPasswordDiv) {
                oBettingPasswordDiv.style.display = 'none';
            }
            var oTransactionButton = this.getPrivateDomElement('transaction-button');
            if (oTransactionButton) {
                oTransactionButton.style.display = 'none';
            }
            var oGoBackButton = this.getPrivateDomElement('goback-button');
            if (oGoBackButton) {
                oGoBackButton.style.display = 'block';
            }
        }
    },
    
    goToArea: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goToArea(area, filter) {
        var pageFilter = {};
        pageFilter['action'] = filter;
        this._navigationService.goTo(area, pageFilter);
    },
    
    goRegister: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegister(action) {
        var pageFilter = this._navigationService.getPageFilter();
        pageFilter['action'] = action;
        this._navigationService.goTo(this._navigationService.getPageArea(), pageFilter);
    },
    
    fetchAndOutputPaymentTypesToRegisterHTML: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$fetchAndOutputPaymentTypesToRegisterHTML() {
        this._accountService.getAllowedPaymentTypes(Delegate.create(this, function(result) {
            var htmlToWrite = '';
            var items = '';
            var paymentTypes = result;
            paymentTypes.sort(Delegate.create(this, function(pt1, pt2) {
                return this.paymentTypesCompareCallback(pt1, pt2);
            }));
            var isCardOut = false;
            for (var i = 0; i < paymentTypes.length; i++) {
                if ((this.isDeposit() && !paymentTypes[i].IsForReceipts) || (!this.isDeposit() && !paymentTypes[i].IsForPayments) || !this.isPaymentTypeAllowed(paymentTypes[i])) {
                    continue;
                }
                items += this.adaptPaymentType(paymentTypes[i], isCardOut);
                if (paymentTypes[i].IDMMSIClass.toUpperCase() === 'CR') {
                    isCardOut = true;
                }
            }
            htmlToWrite = String.format(this.instrumentTypesListContainer(), items);
            this.updatePrivateDomElement('availableinstrumenttypes', htmlToWrite);
            Framework.Behavior.Binding.BehaviorBinder.autoBind(this.getPrivateDomElement('availableinstrumenttypes'), this);
        }), Delegate.create(this, function(exception) {
            var message = Framework.ExceptionUtil.getExceptionDetails(exception).get_message();
            if (!message) {
                message = 'Sorry, we could not get the list of available instrument types to register at this moment - please contact customer support for further help.';
            }
            this.activateFailedStatusArea(message, String.Empty, String.Empty);
            document.getElementById(this._domElementId + '-links').style.display = 'none';
        }), this._environment.getLanguage());
    },
    
    isPaymentTypeAllowed: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$isPaymentTypeAllowed(paymentType) {
        return true;
    },
    
    adaptPaymentType: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$adaptPaymentType(paymentType, isCardOut) {
        var result = '';
        var itemTemplate = this.instrumentTypesListItem();
        if (paymentType.IDMMSIClass.toUpperCase() !== 'CR' || (paymentType.IDMMSIClass.toUpperCase() === 'CR' && !isCardOut)) {
            var instrumentName = paymentType.Name;
            var className = paymentType.IDMMSIType.toLowerCase();
            if (String.equals(paymentType.IDMMSIClass, 'CR', true)) {
                instrumentName = 'Credit / debit card';
                className = 'card';
            }
            var behavior = this._instrumentTypeBehavior$2(paymentType.IDMMSIClass, paymentType.IDMMSIType);
            result += String.format(itemTemplate, className, behavior[0], behavior[1], instrumentName);
        }
        return result;
    },
    
    paymentTypesCompareCallback: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$paymentTypesCompareCallback(pt1, pt2) {
        return 0;
    },
    
    _instrumentTypeBehavior$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_instrumentTypeBehavior$2(IDMMSIClass, IDMMSIType) {
        var behaviorID = new Array(2);
        switch (IDMMSIClass) {
            case 'CQ':
                behaviorID[0] = 'GoRegisterCheque';
                break;
            case 'CR':
                behaviorID[0] = 'GoRegisterCard';
                break;
            case 'BT':
                behaviorID[0] = 'GoRegisterBankTransfer';
                behaviorID[1] = String.format('behavior.GoRegisterBankTransfer.idmmsitype=\"{0}\"', IDMMSIType);
                break;
            case 'RW':
                behaviorID[0] = 'GoRegisterRedirectBasedWallet';
                behaviorID[1] = String.format('behavior.GoRegisterRedirectBasedWallet.idmmsitype=\"{0}\"', IDMMSIType);
                break;
        }
        return behaviorID;
    },
    
    _instrumentTypeBehaviorID$2: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$_instrumentTypeBehaviorID$2(IDMMSIClass, IDMMSIType) {
        var behaviorID = '';
        switch (IDMMSIClass) {
            case 'CQ':
                behaviorID = 'GoRegisterCheque';
                break;
            case 'CR':
                behaviorID = 'GoRegisterCard';
                break;
            case 'BT':
                behaviorID = String.format('GoRegisterBankTransfer\" (\'{0}\')', IDMMSIType);
                break;
            case 'RW':
                behaviorID = String.format('GoRegisterRedirectBasedWallet\" behavior. (\'{0}\')', IDMMSIType);
                break;
        }
        return behaviorID;
    },
    
    updateCreditCardDetails: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$updateCreditCardDetails(IDMMSIInstruction) {
        var newExpiryMonth = 0;
        var newExpiryYear = 0;
        var newIssueNumber = null;
        var newStartOfValidityMonth = null;
        var newStartOfValidityYear = null;
        var newExpiryYearDropDown = this.getPrivateDomElement(String.format('{0}-expiry-year-select', IDMMSIInstruction));
        var newExpiryMonthDropDown = this.getPrivateDomElement(String.format('{0}-expiry-month-select', IDMMSIInstruction));
        newExpiryMonth = Number.parse(newExpiryMonthDropDown.value);
        newExpiryYear = Number.parse(newExpiryYearDropDown.value);
        var issueNumberElement = this.getPrivateDomElement(String.format('{0}-issuenumber-input', IDMMSIInstruction));
        if (issueNumberElement) {
            newIssueNumber = Number.parse((issueNumberElement).value);
            if (isNaN(newIssueNumber)) {
                alert('Invalid Issue Number');
                return;
            }
        }
        var startOfValidityYearDropDown = this.getPrivateDomElement(String.format('{0}-validity-year-select', IDMMSIInstruction));
        var startOfValidityMonthDropDown = this.getPrivateDomElement(String.format('{0}-validity-month-select', IDMMSIInstruction));
        if (startOfValidityYearDropDown && startOfValidityMonthDropDown) {
            newStartOfValidityMonth = Number.parse((startOfValidityMonthDropDown).value);
            newStartOfValidityYear = Number.parse((startOfValidityYearDropDown).value);
        }
        try {
            var dict = {};
            dict['IDMMSIInstruction'] = IDMMSIInstruction;
            dict['ExpiryMonth'] = newExpiryMonth;
            dict['ExpiryYear'] = newExpiryYear;
            dict['StartOfValidityMonth'] = newStartOfValidityMonth;
            dict['StartOfValidityYear'] = newStartOfValidityYear;
            dict['CardIssueNumber'] = newIssueNumber;
            this._accountService.updateCreditCardDetails(Delegate.create(this, function(o) {
                alert('Credit Card Updated');
                this.update();
            }), Delegate.create(this, function(ex) {
                if (ex.message.indexOf('|') !== -1) {
                    alert(ex.message.substr(ex.message.indexOf('|') + 1));
                }
                else {
                    this._log.debug(ex.message);
                    alert('Credit Card Update Failed.');
                }
            }), dict);
        }
        catch (e) {
            alert(e.message);
            return;
        }
    },
    
    goRegisterChequeOver: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegisterChequeOver(idmmsitype, siname) {
        this._log.debug('GoRegisterCheque');
        var pageFilter = this._navigationService.getPageFilter();
        pageFilter['action'] = 'register-cheque';
        pageFilter['idmmsitypecq'] = idmmsitype;
        pageFilter['siname'] = siname;
        this._navigationService.goTo(this._navigationService.getPageArea(), pageFilter);
    },
    
    goRegisterRedirectBasedWallet: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goRegisterRedirectBasedWallet(IDMMSIType) {
        this._log.debug('GoRegisterRedirectBasedWallet');
        var redirectBasedWallet = { IDMMSIType: IDMMSIType };
        this._accountService.registerRedirectBasedWallet(Delegate.create(this, function(result) {
            var IDMMSIInstruction = result;
            this._log.debug('GoRegisterRedirectBasedWallet redirect based wallet registration successfull, IDMMSIInstruction=[' + IDMMSIInstruction + ']');
            this.getPrivateDomElement('links').style.display = 'none';
            this.getPrivateDomElement('revealpaymentmethodlist').style.display = 'block';
            this.displayRegisteredSettlementInstructions(IDMMSIInstruction);
        }), Delegate.create(this, function(exception) {
            this._log.debug('GoRegisterRedirectBasedWallet redirect based wallet registration failed');
        }), redirectBasedWallet);
    },
    
    beginPaymentTransaction: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$beginPaymentTransaction(password, IDMMSIInstruction, amount, securityCode1) {
        this._log.debug('BeginPaymentTransaction');
        var securityCode = '';
        var errorAmount = this._environment.getDomElement('errorAmountNoDecimals');
        if (errorAmount) {
            errorAmount.style.display = 'none';
        }
        errorAmount = this._environment.getDomElement('errorAmount2Decimals');
        if (errorAmount) {
            errorAmount.style.display = 'none';
        }
        var ErrorMessageBox = this.getPrivateDomElement('status-failed');
        ErrorMessageBox.style.display = 'none';
        var _isValid;
        if (this._useDefaultValidation) {
            _isValid = this._validationManager.validateAll();
            if (_isValid) {
                var regEx4Amount = '';
                var errorElementId = '';
                switch (this._selectedInstrumentSIType.toUpperCase()) {
                    case 'NT':
                    case 'NTIC':
                        regEx4Amount = this.regExNumber;
                        errorElementId = 'errorAmountNoDecimals';
                        break;
                    case '':
                        break;
                    default:
                        regEx4Amount = this.regExDecimal;
                        errorElementId = 'errorAmount2Decimals';
                        break;
                }
                if (regEx4Amount.length > 0) {
                    var regex = new RegExp(regEx4Amount);
                    _isValid = regex.test(amount);
                    if (!_isValid) {
                        errorAmount = this._environment.getDomElement(errorElementId);
                        if (errorAmount) {
                            errorAmount.style.display = 'block';
                        }
                    }
                }
            }
            if (_isValid) {
                (this.getPrivateDomElement('Amount')).value = amount.toString();
            }
        }
        else {
            _isValid = true;
        }
        if (_isValid) {
            var securityCheck = false;
            if (this.getPrivateDomElement(IDMMSIInstruction + '-cvv2number')) {
                securityCode = (this.getPrivateDomElement(IDMMSIInstruction + '-cvv2number')).value;
                var invalidCode = securityCode.replace(new RegExp('^[0-9]+$'), '');
                if (securityCode.length < 3 || invalidCode.length > 0 || String.isNullOrEmpty(securityCode)) {
                    securityCheck = true;
                }
            }
            if (securityCheck && this.isDeposit()) {
                var cvv2Alert = 'Please enter your security code to continue deposit!';
                var cvv2AlertMessage = this.getPrivateDomElement('cvv2-alert');
                if (cvv2AlertMessage) {
                    cvv2Alert = cvv2AlertMessage.innerHTML.trim();
                }
                alert(cvv2Alert);
            }
            else {
                this.disable();
                document.getElementById(this._domElementId).style.cursor = 'wait';
                this._accountService.beginSettlementInstructionTransaction(Delegate.create(this, function(result) {
                    var IDMMSITXRequest = result;
                    this._log.debug('IDMMSITXRequest = ' + IDMMSITXRequest);
                    this.getTransactionState(IDMMSITXRequest);
                }), Delegate.create(this, function(exception) {
                    this.enable();
                    document.getElementById(this._domElementId).style.cursor = 'default';
                    var message = Framework.ExceptionUtil.getExceptionDetails(exception).get_message();
                    if (!message) {
                        message = 'Deposit Failed - please contact customer support';
                    }
                    this.activateFailedStatusArea(message, String.Empty, String.Empty);
                }), password, this.getIDMMSITransactionType(), IDMMSIInstruction, Number.parse(amount), securityCode);
            }
        }
    },
    
    goToPaymentMethodList: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$goToPaymentMethodList() {
        this._log.debug('GoToPaymentMethodList');
        this.getPrivateDomElement('links').style.display = 'block';
        this.getPrivateDomElement('revealpaymentmethodlist').style.display = 'none';
        this.fetchAndOutputPaymentTypesToRegisterHTML();
        this.getPrivateDomElement('links').focus();
    },
    
    registerValidators: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$registerValidators() {
        this._validationManager.registerMandatoryValidator(this._domElementId + '-Amount', 'lblAmount', 'errorAmount');
        this._validationManager.registerMandatoryValidator(this._domElementId + '-Password', 'lblPaymentPassword', 'errorPaymentPassword');
    },
    
    instrumentTypesListContainer: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$instrumentTypesListContainer() {
        return '\r\n\t\t\t\t<ul class=\"paymentmethods\">\r\n\t\t\t\t{0}\r\n\t\t\t\t</ul>';
    },
    
    instrumentTypesListItem: function AbstractMMCoreComponents_AbstractPaymentTransactionComponent$instrumentTypesListItem() {
        return '\r\n\t\t\t\t<li class=\"{0}\"><a href=\"#\" behavior.ID=\"{1}\" behavior.autobind.{1}=\"onclick\" {2}>\r\n\t\t\t\t\t{3}\r\n\t\t\t\t</a></li>';
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.RowType

AbstractMMCoreComponents.RowType = function AbstractMMCoreComponents_RowType(grouped, firstInGroup, lastInGroup) {
    this.grouped = grouped;
    this.firstInGroup = firstInGroup;
    this.lastInGroup = lastInGroup;
}
AbstractMMCoreComponents.RowType.prototype = {
    grouped: false,
    firstInGroup: false,
    lastInGroup: false
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractStatementComponent

AbstractMMCoreComponents.AbstractStatementComponent = function AbstractMMCoreComponents_AbstractStatementComponent() {
    this._state = AbstractMMCoreComponents.AbstractStatementComponent._DisplayBetHistory;
    this.milliSecondsInADay = 24 * 60 * 60 * 1000;
    this.today = Date.get_today().getTime();
    AbstractMMCoreComponents.AbstractStatementComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractStatementComponent.formatDate = function AbstractMMCoreComponents_AbstractStatementComponent$formatDate(dateTime, style) {
    switch (style) {
        case AbstractMMCoreComponents.formatDateStyle.user:
            return String.format('{0} {1:MMM yyyy}', dateTime.getDate(), dateTime);
        case AbstractMMCoreComponents.formatDateStyle.machine:
        default:
            var retVal = dateTime.format('yyyy/MM/');
            if (dateTime.getDate() < 10) {
                retVal = retVal + '0';
            }
            retVal = retVal + dateTime.getDate();
            return retVal;
    }
}
AbstractMMCoreComponents.AbstractStatementComponent.prototype = {
    betStateTypes: 0,
    betOutcomeTypes: 0,
    showIsFreeInBetHistory: false,
    isFreeIcon: '',
    from: 0,
    to: 0,
    pageNumber: 0,
    pageSize: 5,
    orderBy: 0,
    orderDesc: true,
    isCustomDateRange: false,
    filter: 0,
    filterBetType: 1,
    
    initPosition: function AbstractMMCoreComponents_AbstractStatementComponent$initPosition() {
        this.from = this.todayFrom;
        this.to = this.todayTo;
        this.pageNumber = 0;
        this.orderBy = 0;
        this.orderDesc = true;
        if (this._navigationService.getPageFilter()['filter']) {
            this.filter = parseInt(this._navigationService.getPageFilter()['filter'].toString());
            this.filterBetType = 31;
            if (!this.filter) {
                this.filterBetType = 2;
                this.from = new Date(1900, 1, 1).getTime();
                this.to = Date.get_now().getTime();
            }
            else if (this.filter === 1) {
                this.from = new Date(1900, 1, 1).getTime();
                this.to = Date.get_now().getTime();
                this.pageSize = 10;
                this.betOutcomeTypes = 0;
                this.betStateTypes = this.filterBetType;
            }
            else {
                this.isCustomDateRange = true;
            }
        }
    },
    
    todayFrom: null,
    todayTo: null,
    yesterdayFrom: null,
    yesterdayTo: null,
    lastWeekFrom: null,
    lastWeekTo: null,
    lastMonthFrom: null,
    lastMonthTo: null,
    groupBets: false,
    _accountService: null,
    
    setAccountService: function AbstractMMCoreComponents_AbstractStatementComponent$setAccountService(accountService) {
        this._log.debug('SetAccountService');
        this._accountService = accountService;
    },
    
    _fixedOddsBettingService: null,
    
    setFixedOddsBettingService: function AbstractMMCoreComponents_AbstractStatementComponent$setFixedOddsBettingService(fixedOddsBettingService) {
        this._log.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService = fixedOddsBettingService;
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractStatementComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractMMCoreComponents_AbstractStatementComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.displayBetHistory();
    },
    
    _userService: null,
    
    setUserService: function AbstractMMCoreComponents_AbstractStatementComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    onUserChanged: function AbstractMMCoreComponents_AbstractStatementComponent$onUserChanged(eventSource) {
        this._log.debug('OnUserChanged');
    },
    
    init: function AbstractMMCoreComponents_AbstractStatementComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this.todayFrom = this.today;
        this.todayTo = this.today + this.milliSecondsInADay;
        this.yesterdayFrom = this.today - this.milliSecondsInADay;
        this.yesterdayTo = this.today;
        this.lastWeekFrom = this.today - 7 * this.milliSecondsInADay;
        this.lastWeekTo = this.today;
        this.lastMonthFrom = this.today - 30 * this.milliSecondsInADay;
        this.lastMonthTo = this.today;
        this.from = this.lastWeekFrom;
        this.to = this.lastWeekTo;
        this.betStateTypes = Number.parse(parameters['bet-state-types']);
        this.pageSize = Number.parse(parameters['page-size']);
        this.groupBets = Boolean.parse(parameters['group-bets'].toString());
        if (Object.keyExists(parameters, 'show-is-free-bet-icon-in-bet-history')) {
            this.showIsFreeInBetHistory = Boolean.parse(parameters['show-is-free-bet-icon-in-bet-history']);
        }
        if (Object.keyExists(parameters, 'is-free-bet-icon')) {
            this.isFreeIcon = parameters['is-free-bet-icon'];
        }
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractStatementComponent$renderComplete(eventArgs) {
        var elem = this._environment.getDomElement(String.format('{0}-initial-filter-type', this._domElementId));
        if (elem) {
            this.setBetStateType(Number.parse(elem.value));
        }
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractStatementComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction()) && this._userService.isLoggedIn();
    },
    
    getXsltParameters: function AbstractMMCoreComponents_AbstractStatementComponent$getXsltParameters(contextObject) {
        var _xsltParameters = {};
        _xsltParameters['component-instance-name'] = this._componentInstanceName;
        _xsltParameters['component-dom-element-id'] = this._domElementId;
        _xsltParameters['state'] = this._state;
        if (!this._navigationService.isEmpty()) {
            _xsltParameters['go-back'] = 'true';
        }
        var today = Date.get_today().getTime();
        _xsltParameters['page-number'] = this.pageNumber;
        _xsltParameters['page-size'] = this.pageSize;
        _xsltParameters['today-from'] = today;
        _xsltParameters['today-to'] = today + this.milliSecondsInADay;
        _xsltParameters['yesterday-from'] = today - this.milliSecondsInADay;
        _xsltParameters['yesterday-to'] = today + this.milliSecondsInADay;
        _xsltParameters['last-week-from'] = today - 7 * this.milliSecondsInADay;
        _xsltParameters['last-week-to'] = today + this.milliSecondsInADay;
        _xsltParameters['last-month-from'] = today - 30 * this.milliSecondsInADay;
        _xsltParameters['last-month-to'] = today + this.milliSecondsInADay;
        _xsltParameters['from'] = this.from;
        _xsltParameters['to'] = this.to;
        _xsltParameters['filter'] = this.filter;
        _xsltParameters['filter-type'] = this.filterBetType;
        _xsltParameters['cash-balance'] = this._accountService.get_creditAccountDetails().WithdrawalBalance.format('N', true);
        _xsltParameters['currency-symbol'] = this._accountService.getCurrencySimbol();
        if (this.isCustomDateRange) {
            _xsltParameters['custom-date-range'] = String.format('{0} - {1}', AbstractMMCoreComponents.AbstractStatementComponent.formatDate(new Date(this.from), AbstractMMCoreComponents.formatDateStyle.user), AbstractMMCoreComponents.AbstractStatementComponent.formatDate(new Date(this.to), AbstractMMCoreComponents.formatDateStyle.user));
            var dtFrom = new Date(this.from);
            var dtTo = new Date(this.to);
            _xsltParameters['custom-day-from'] = dtFrom.getDate();
            _xsltParameters['custom-month-from'] = dtFrom.getMonth();
            _xsltParameters['custom-year-from'] = dtFrom.getFullYear();
            _xsltParameters['custom-day-to'] = dtTo.getDate();
            _xsltParameters['custom-month-to'] = dtTo.getMonth();
            _xsltParameters['custom-year-to'] = dtTo.getFullYear();
        }
        return _xsltParameters;
    },
    
    displayBetHistoryEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$displayBetHistoryEventHandler(sender, eventArgs) {
        this.displayBetHistory();
        window.event.returnValue = false;
    },
    
    closeChangePasswordEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$closeChangePasswordEventHandler(sender, eventArgs) {
        var action = eventArgs.parameters.getAsString('action');
        this._navigationService.setAction(action);
    },
    
    displayBalanceHistoryEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$displayBalanceHistoryEventHandler(sender, eventArgs) {
        this.displayBalanceHistory();
        window.event.returnValue = false;
    },
    
    populateBetHistoryTableEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$populateBetHistoryTableEventHandler(sender, eventArgs) {
        if (this.filter === 1) {
            this.populateBetHistoryTableWithRowNumber(String.format('{0}-{1}', this._domElementId, eventArgs.parameters.getAsString('domelement')), eventArgs.parameters.getAsInt32('number-of-records'));
        }
        else {
            this.populateBetHistoryTable(String.format('{0}-{1}', this._domElementId, eventArgs.parameters.getAsString('domelement')));
        }
    },
    
    populateBalanceHistoryTableEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$populateBalanceHistoryTableEventHandler(sender, eventArgs) {
        if (this.filter === 1) {
            this.populateBalanceHistoryTableWithRowsNumber(String.format('{0}-{1}', this._domElementId, eventArgs.parameters.getAsString('domelement')), eventArgs.parameters.getAsInt32('number-of-records'));
        }
        else {
            this.populateBalanceHistoryTable(String.format('{0}-{1}', this._domElementId, eventArgs.parameters.getAsString('domelement')));
        }
    },
    
    changeFiltersEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$changeFiltersEventHandler(sender, eventArgs) {
        this.isCustomDateRange = eventArgs.parameters.getAsBoolean('iscustomdaterange');
        if (this.isCustomDateRange) {
            this.from = new Date(parseInt((this.getPrivateDomElement('yearFrom')).value), parseInt((this.getPrivateDomElement('monthFrom')).value), parseInt((this.getPrivateDomElement('dayFrom')).value)).getTime();
            this.to = new Date(parseInt((this.getPrivateDomElement('yearTo')).value), parseInt((this.getPrivateDomElement('monthTo')).value), parseInt((this.getPrivateDomElement('dayTo')).value)).getTime();
        }
        else {
            this.from = eventArgs.parameters.getAsNumber('filterfrom');
            this.to = eventArgs.parameters.getAsNumber('filterto');
            this.pageNumber = 0;
        }
        this.update();
        window.event.returnValue = false;
    },
    
    applyFiltersEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$applyFiltersEventHandler(sender, eventArgs) {
        this.pageNumber = 0;
        if (this.filter === 3) {
            this.from = new Date(parseInt((this.getPrivateDomElement('yearFrom')).value), parseInt((this.getPrivateDomElement('monthFrom')).value), parseInt((this.getPrivateDomElement('dayFrom')).value)).getTime();
            this.to = new Date(parseInt((this.getPrivateDomElement('yearTo')).value), parseInt((this.getPrivateDomElement('monthTo')).value), parseInt((this.getPrivateDomElement('dayTo')).value)).getTime();
        }
        this.update();
        window.event.returnValue = false;
    },
    
    toggleCustomDateRangeDisplayEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$toggleCustomDateRangeDisplayEventHandler(sender, eventArgs) {
        this.toggleCustomDateRangeDisplay();
        window.event.returnValue = false;
    },
    
    changePageEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$changePageEventHandler(sender, eventArgs) {
        if (eventArgs.parameters.getAsBoolean('pagedown')) {
            this.pageNumber--;
        }
        else {
            this.pageNumber++;
        }
        this.update();
        window.event.returnValue = false;
    },
    
    setPageSizeEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$setPageSizeEventHandler(sender, eventArgs) {
        this.setPageSize(parseInt((eventArgs.domElement).value));
    },
    
    setOrderEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$setOrderEventHandler(sender, eventArgs) {
        this.setOrder(eventArgs.parameters.getAsNumber('ordercolumn'));
        window.event.returnValue = false;
    },
    
    onCloseMethodClickedEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$onCloseMethodClickedEventHandler(sender, eventArgs) {
        var action = eventArgs.parameters.getAsString('action');
        this._navigationService.setAction(action);
    },
    
    setPeriodEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$setPeriodEventHandler(sender, eventArgs) {
        switch ((eventArgs.domElement).value) {
            case 'today':
                this.from = this.todayFrom;
                this.to = this.todayTo;
                break;
            case 'yesterday':
                this.from = this.yesterdayFrom;
                this.to = this.yesterdayTo;
                break;
            case 'week':
                this.from = this.lastWeekFrom;
                this.to = this.lastWeekTo;
                break;
            case 'month':
                this.from = this.lastMonthFrom;
                this.to = this.lastMonthTo;
                break;
        }
    },
    
    setFilterTypeEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$setFilterTypeEventHandler(sender, eventArgs) {
        this.filterBetType = parseInt((eventArgs.domElement).value);
        if (this.filterBetType === 100 || this.filterBetType === 101) {
            this._state = AbstractMMCoreComponents.AbstractStatementComponent._DisplayBalanceHistory;
        }
        else {
            if (this.filterBetType === 116) {
                this.betOutcomeTypes = 16;
                this.betStateTypes = 0;
            }
            else {
                this.betOutcomeTypes = 0;
                this.betStateTypes = this.filterBetType;
            }
            this._state = AbstractMMCoreComponents.AbstractStatementComponent._DisplayBetHistory;
        }
    },
    
    setFilterEventHandler: function AbstractMMCoreComponents_AbstractStatementComponent$setFilterEventHandler(sender, eventArgs) {
        this.filter = parseInt((eventArgs.domElement).value);
        if (this.filter === 1) {
            this.from = new Date(1900, 1, 1).getTime();
            this.to = Date.get_now().getTime();
            this.pageSize = 10;
            this.isCustomDateRange = false;
        }
        else if (this.filter === 2) {
            switch ((this._environment.getDomElement(this._domElementId + '-standartperiods')).value) {
                case 'today':
                    this.from = this.todayFrom;
                    this.to = this.todayTo;
                    break;
                case 'yesterday':
                    this.from = this.yesterdayFrom;
                    this.to = this.yesterdayTo;
                    break;
                case 'week':
                    this.from = this.lastWeekFrom;
                    this.to = this.lastWeekTo;
                    break;
                case 'month':
                    this.from = this.lastMonthFrom;
                    this.to = this.lastMonthTo;
                    break;
            }
            this.isCustomDateRange = false;
        }
        else if (this.filter === 3) {
            this.from = new Date(parseInt((this.getPrivateDomElement('yearFrom')).value), parseInt((this.getPrivateDomElement('monthFrom')).value), parseInt((this.getPrivateDomElement('dayFrom')).value)).getTime();
            this.to = new Date(parseInt((this.getPrivateDomElement('yearTo')).value), parseInt((this.getPrivateDomElement('monthTo')).value), parseInt((this.getPrivateDomElement('dayTo')).value)).getTime();
            this.isCustomDateRange = true;
        }
    },
    
    translateString: function AbstractMMCoreComponents_AbstractStatementComponent$translateString(inEnglish) {
        var domElement = this._environment.getDomElement(this._domElementId + '-strings');
        if (!domElement) {
            return inEnglish;
        }
        var xml = String.format('<xml>{0}</xml>', domElement.innerHTML);
        var xmlDocument = XMLDocumentParser.parse(xml);
        var xPath = '//string[@english=\'' + inEnglish + '\']';
        var node = xmlDocument.selectSingleNode(xPath);
        return (node) ? node.text : inEnglish;
    },
    
    clearStatementData: function AbstractMMCoreComponents_AbstractStatementComponent$clearStatementData() {
        var pagenav = this._environment.getDomElement(this._domElementId + '-pagenav');
        if (pagenav) {
            pagenav.style.display = 'none';
        }
        this._environment.getDomElement(this._domElementId + '-next-page').style.visibility = 'hidden';
        this._environment.updateDomElement(String.format('{0}-statement-data', this._domElementId), '');
    },
    
    failed: function AbstractMMCoreComponents_AbstractStatementComponent$failed(exception) {
        var errorMessage = Framework.ExceptionUtil.getExceptionDetails(exception).get_message();
        if (!errorMessage) {
            errorMessage = 'Error';
        }
        if (errorMessage.indexOf('The maximum message size quota for incoming messages (65536) has been exceeded.') > -1) {
            errorMessage = 'Please reduce your search criteria.  The current date range is too wide.';
        }
        this._environment.updateDomElement(this._domElementId + '-message', errorMessage);
        document.getElementById(this._domElementId).style.cursor = 'default';
        var messageElement = document.getElementById(this._domElementId + '-errormessage');
        if (messageElement) {
            messageElement.style.display = 'inline';
        }
        var contentElement = document.getElementById(this._domElementId + '-content');
        if (contentElement) {
            contentElement.style.display = 'none';
        }
    },
    
    adjustBetStateAndOutcomeTypes: function AbstractMMCoreComponents_AbstractStatementComponent$adjustBetStateAndOutcomeTypes() {
    },
    
    setOrder: function AbstractMMCoreComponents_AbstractStatementComponent$setOrder(orderColumn) {
        this._log.debug(String.format('SetOrder orderColumn=[{0}]', orderColumn));
        if (this.orderBy === orderColumn) {
            this.orderDesc = !this.orderDesc;
        }
        else {
            this.orderDesc = false;
        }
        this.orderBy = orderColumn;
        this.update();
    },
    
    toggleCustomDateRangeDisplay: function AbstractMMCoreComponents_AbstractStatementComponent$toggleCustomDateRangeDisplay() {
        var element = this.getPrivateDomElement('search-by-date');
        element.style.display = (element.style.display === 'block') ? 'none' : 'block';
    },
    
    displayBalanceHistory: function AbstractMMCoreComponents_AbstractStatementComponent$displayBalanceHistory() {
        this._state = AbstractMMCoreComponents.AbstractStatementComponent._DisplayBalanceHistory;
        this.initPosition();
        this.update();
    },
    
    displayBetHistory: function AbstractMMCoreComponents_AbstractStatementComponent$displayBetHistory() {
        this._state = AbstractMMCoreComponents.AbstractStatementComponent._DisplayBetHistory;
        this.initPosition();
        this.update();
    },
    
    balanceHistoryHeader: function AbstractMMCoreComponents_AbstractStatementComponent$balanceHistoryHeader() {
        return String.format('\r\n\t\t\t\t<table class=\'accdata\'>\r\n\t\t\t\t\t<tr class=\'headerrow\'>\r\n\t\t\t\t\t\t<th class=\'{6}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"0\">{0}<a></th>\r\n\t\t\t\t\t\t<th class=\'{7}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"1\">{1}<a></th>\r\n\t\t\t\t\t\t<th class=\'{8}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"2\">{2}<a></th>\r\n\t\t\t\t\t\t<th class=\'{9}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"3\">{3}<a></th>\r\n\t\t\t\t\t\t<th class=\'{10}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"4\">{4}<a></th>\r\n\t\t\t\t\t</tr>', this.translateString('Date'), this.translateString('Description'), this.translateString('Hint'), this.translateString('Debit'), this.translateString('Credit'), this._componentInstanceName.replace('\'', '\"'), (!this.orderBy) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 1) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 2) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 3) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 4) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '');
    },
    
    balanceHistoryTableRow: function AbstractMMCoreComponents_AbstractStatementComponent$balanceHistoryTableRow(balanceHistoryDetails, i) {
        return String.format('\r\n\t\t\t\t<tr class=\'datarow{0}\'>\r\n\t\t\t\t\t<td>\r\n\t\t\t\t\t\t<span style=\'white-space:nowrap;\'>{1} {2:MMM yyyy}</span>\r\n\t\t\t\t\t\t<span style=\'white-space:nowrap;\'>{2:HH:mm}</span>\r\n\t\t\t\t\t</td>\r\n\t\t\t\t\t<td>{3}</td>\r\n\t\t\t\t\t<td>{4}</td>\r\n\t\t\t\t\t<td style=\'text-align:right;\'>{5:n2}</td>\r\n\t\t\t\t\t<td style=\'text-align:right;\'>{6:n2}</td>\r\n\t\t\t\t</tr>', i % 2, Framework.JSONFormat.parseDateTime(balanceHistoryDetails['ValueDate'].toString()).getDate(), Framework.JSONFormat.parseDateTime(balanceHistoryDetails['ValueDate'].toString()), balanceHistoryDetails['Description'], balanceHistoryDetails['Hint'], balanceHistoryDetails['AmountDebit'], balanceHistoryDetails['AmountCredit']);
    },
    
    populateBalanceHistoryTable: function AbstractMMCoreComponents_AbstractStatementComponent$populateBalanceHistoryTable(domElementId) {
        this._log.debug(String.format('StatementComponent.PopulateBalanceHistoryTable domElementId = [{0}] from = [{1}] to = [{2}] pageNumber = [{3}] pageSize = [{4}] orderBy = [{5}] orderDesc = [{6}]', domElementId, this.from, this.to, this.pageNumber, this.pageSize, this.orderBy, this.orderDesc));
        this._accountService.getBalanceHistory(Delegate.create(this, function(result) {
            var balanceHistoryDetails = result;
            var tableContent = this.balanceHistoryHeader();
            if (balanceHistoryDetails.length > 0) {
                var lastRecordToRender;
                if (balanceHistoryDetails.length > this.pageSize) {
                    lastRecordToRender = this.pageSize;
                }
                else {
                    lastRecordToRender = balanceHistoryDetails.length;
                }
                for (var i = 0; i < lastRecordToRender; i++) {
                    tableContent += this.balanceHistoryTableRow(balanceHistoryDetails[i], i);
                }
            }
            else {
                tableContent += this.getNoDataBalanceHtml();
            }
            this.setPageNavVisibility(balanceHistoryDetails.length > 0 || this.pageNumber > 0);
            this.setNextPageVisibility(balanceHistoryDetails.length >= this.pageSize);
            this.setPrevPageVisibility(this.pageNumber > 0);
            this._environment.updateDomElement(domElementId, tableContent + '</table>');
            Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domElementId), this);
        }), Delegate.create(this, function(exception) {
            this.failed(exception);
        }), new Date(this.from), new Date(this.to), this.pageNumber, this.pageSize, this.orderBy, this.orderDesc);
    },
    
    populateBalanceHistoryTableWithRowsNumber: function AbstractMMCoreComponents_AbstractStatementComponent$populateBalanceHistoryTableWithRowsNumber(domElementId, numberOfRecords) {
        this._log.debug(String.format('StatementComponent.PopulateBalanceHistoryTable domElementId = [{0}] from = [{1}] to = [{2}] pageNumber = [{3}] pageSize = [{4}] orderBy = [{5}] orderDesc = [{6}] numberOfRows = [{7}]', domElementId, this.from, this.to, this.pageNumber, this.pageSize, this.orderBy, this.orderDesc, numberOfRecords));
        this._accountService.getBalanceHistoryWithNumberOfRecords(Delegate.create(this, function(result) {
            var balanceHistoryDetails = result;
            var tableContent = this.balanceHistoryHeader();
            if (balanceHistoryDetails.length > 0) {
                var lastRecordToRender;
                if (balanceHistoryDetails.length > this.pageSize) {
                    lastRecordToRender = this.pageSize;
                }
                else {
                    lastRecordToRender = balanceHistoryDetails.length;
                }
                for (var i = 0; i < lastRecordToRender; i++) {
                    tableContent += this.balanceHistoryTableRow(balanceHistoryDetails[i], i);
                }
            }
            else {
                tableContent += this.getNoDataBalanceHtml();
            }
            this.setPageNavVisibility(balanceHistoryDetails.length > 0 || this.pageNumber > 0);
            this.setNextPageVisibility(balanceHistoryDetails.length >= this.pageSize);
            this.setPrevPageVisibility(this.pageNumber > 0);
            this._environment.updateDomElement(domElementId, tableContent + '</table>');
            Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domElementId), this);
        }), Delegate.create(this, function(exception) {
            this.failed(exception);
        }), new Date(this.from), new Date(this.to), this.pageNumber, this.pageSize, this.orderBy, this.orderDesc, numberOfRecords);
    },
    
    getNoDataBalanceHtml: function AbstractMMCoreComponents_AbstractStatementComponent$getNoDataBalanceHtml() {
        return '<tr><td colspan=\'5\' class=\'nodata\' style=\'text-align:center\'>No data</td></tr>';
    },
    
    setBetStateType: function AbstractMMCoreComponents_AbstractStatementComponent$setBetStateType(betStateType) {
        this.betStateTypes = betStateType;
    },
    
    betHistoryTable: function AbstractMMCoreComponents_AbstractStatementComponent$betHistoryTable() {
        return String.format('\r\n\t\t\t\t<table class=\'{26}\'>\r\n\t\t\t\t\t<colgroup><col/><col class=\'{25}\'/><col/><col/><col/><col/><col/><col/><col/><col/></colgroup>\r\n\t\t\t\t\t<tr class=\'{27}\'>\r\n\t\t\t\t\t\t<th class=\'{13}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"0\">{0}<a></th>\r\n\t\t\t\t\t\t<th class=\'{14}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"1\">{1}<a></th>\r\n\t\t\t\t\t\t<th class=\'{15}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"2\">{2}<a></th>\r\n\t\t\t\t\t\t<th class=\'{16}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"3\">{3}<a></th>\r\n\t\t\t\t\t\t<th class=\'{17}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"4\">{4}<a></th>\r\n\t\t\t\t\t\t<th class=\'{18}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"5\">{5}<a></th>\r\n\t\t\t\t\t\t<th class=\'{19}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"6\">{6}<a></th>\r\n\t\t\t\t\t\t<th class=\'{20}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"7\">{7}<a></th>\r\n\t\t\t\t\t\t<th class=\'{21}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"8\">{8}<a></th>\r\n\t\t\t\t\t\t<th class=\'{22}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"9\">{9}<a></th>\r\n\t\t\t\t\t\t<th class=\'{23}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"10\">{10}<a></th>\r\n\t\t\t\t\t\t<th class=\'{24}\'><a href=\'#\' behavior.ID=\"SetOrder\" behavior.autobind.SetOrder=\"onclick\" behavior.SetOrder.ordercolumn=\"11\">{11}<a></th>\r\n\t\t\t\t\t</tr>', this.translateString('Date'), this.translateString('Bet Ref'), this.translateString('W/P/S stake'), this.translateString('Bet type'), this.translateString('Event / Market'), this.translateString('Selection'), this.translateString('Hcp'), this.translateString('Price'), this.translateString('Result'), this.translateString('Status'), this.translateString('Total Stake'), this.translateString('Return'), this._componentInstanceName.replace('\'', '\"'), (!this.orderBy) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 1) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 2) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 3) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 4) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 5) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 6) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 7) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 8) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 9) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 10) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.orderBy === 11) ? ((this.orderDesc) ? 'orderDESC' : 'orderASC') : '', (this.groupBets) ? '' : 'colstatbetref', 'accdata', (this.groupBets) ? 'headerrow accdata' : 'headerrow');
    },
    
    renderBetHistoryTable: function AbstractMMCoreComponents_AbstractStatementComponent$renderBetHistoryTable(domElementID, betHistoryDetails) {
        var tableContent = this.betHistoryTable();
        if (betHistoryDetails.length > 0) {
            var rowCssClass = String.Empty;
            var cellCssClass = String.Empty;
            var lastRecordToRender = ((betHistoryDetails.length > this.pageSize) ? this.pageSize : betHistoryDetails.length);
            for (var i = 0; i < lastRecordToRender; i++) {
                rowCssClass = 'datarow' + (i % 2).toString();
                cellCssClass = String.Empty;
                var rowType = this.isGroupRow(betHistoryDetails, i, lastRecordToRender);
                if (this.groupBets && rowType.grouped) {
                    rowCssClass += ' dataRowGrouped';
                    if (rowType.firstInGroup) {
                        cellCssClass = 'dataCellGroupedTop';
                    }
                    else if (rowType.lastInGroup) {
                        cellCssClass = 'dataCellGroupedBottom';
                    }
                    else {
                        cellCssClass = 'dataCellGroupedMiddle';
                    }
                }
                tableContent += this.getTableContent(betHistoryDetails[i], rowCssClass, cellCssClass, this.groupBets && rowType.grouped);
            }
        }
        else {
            tableContent += '<tr><td colspan=\'12\' class=\'nodata\'>No data to display for the specified period.</td></tr>';
        }
        return tableContent;
    },
    
    populateBetHistoryTable: function AbstractMMCoreComponents_AbstractStatementComponent$populateBetHistoryTable(domElementId) {
        this.adjustBetStateAndOutcomeTypes();
        this._log.debug(String.format('StatementComponent.PopulateBetHistoryTable domElementId = [{0}] from = [{1}] to = [{2}] pageNumber = [{3}] pageSize = [{4}] orderBy = [{5}] orderDesc = [{6}]', domElementId, this.from, this.to, this.pageNumber, this.pageSize, this.orderBy, this.orderDesc));
        this._fixedOddsBettingService.getBetHistoryDetails(Delegate.create(this, function(result) {
            var betHistoryDetails = result;
            this._environment.updateDomElement(domElementId, this.renderBetHistoryTable(domElementId, betHistoryDetails) + '</table>');
            Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domElementId), this);
            this.setPageNavVisibility(betHistoryDetails.length > 0 || this.pageNumber > 0);
            this.setNextPageVisibility(betHistoryDetails.length >= this.pageSize);
            this.setPrevPageVisibility(this.pageNumber > 0);
        }), Delegate.create(this, function(exception) {
            this.failed(exception);
        }), new Date(this.from), new Date(this.to), this.pageNumber, this.pageSize, this.orderBy, this.orderDesc, this.betStateTypes, this.betOutcomeTypes);
    },
    
    populateBetHistoryTableWithRowNumber: function AbstractMMCoreComponents_AbstractStatementComponent$populateBetHistoryTableWithRowNumber(domElementId, numberOfRecords) {
        this.adjustBetStateAndOutcomeTypes();
        this._log.debug(String.format('StatementComponent.PopulateBetHistoryTable domElementId = [{0}] from = [{1}] to = [{2}] pageNumber = [{3}] pageSize = [{4}] orderBy = [{5}] orderDesc = [{6}]', domElementId, this.from, this.to, this.pageNumber, this.pageSize, this.orderBy, this.orderDesc));
        this._fixedOddsBettingService.getBetHistoryDetailsWithNumberOfRecords(Delegate.create(this, function(result) {
            var betHistoryDetails = result;
            this._environment.updateDomElement(domElementId, this.renderBetHistoryTable(domElementId, betHistoryDetails) + '</table>');
            Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domElementId), this);
            this.setPageNavVisibility(betHistoryDetails.length > 0 || this.pageNumber > 0);
            this.setNextPageVisibility(betHistoryDetails.length >= this.pageSize);
            this.setPrevPageVisibility(this.pageNumber > 0);
        }), Delegate.create(this, function(exception) {
            this.failed(exception);
        }), new Date(this.from), new Date(this.to), this.pageNumber, this.pageSize, this.orderBy, this.orderDesc, this.betStateTypes, this.betOutcomeTypes, numberOfRecords);
    },
    
    isGroupRow: function AbstractMMCoreComponents_AbstractStatementComponent$isGroupRow(betHistoryDetails, i, rowCount) {
        var rowType = new AbstractMMCoreComponents.RowType(false, false, false);
        var thisReference = betHistoryDetails[i]['FullExternalReference'].toString();
        var previousReference = String.Empty;
        var nextReference = String.Empty;
        if (i < rowCount - 1) {
            nextReference = betHistoryDetails[i + 1]['FullExternalReference'].toString();
        }
        if (i > 0) {
            previousReference = betHistoryDetails[i - 1]['FullExternalReference'].toString();
        }
        if ((thisReference === nextReference) || thisReference === previousReference) {
            rowType.grouped = true;
            if (thisReference !== previousReference) {
                rowType.firstInGroup = true;
            }
            else if (thisReference !== nextReference) {
                rowType.lastInGroup = true;
            }
        }
        return rowType;
    },
    
    getTableContent: function AbstractMMCoreComponents_AbstractStatementComponent$getTableContent(betHistoryDetail, rowCssClass, cellCssClass, isGroup) {
        var isFreeIndicator = '';
        if (this.showIsFreeInBetHistory && Object.keyExists(betHistoryDetail, 'IsFree') && betHistoryDetail['IsFree'] === '-1') {
            isFreeIndicator = 'f';
            if (this.isFreeIcon.length > 0) {
                isFreeIndicator = '<img scr=\'' + this.isFreeIcon + '\' alt=\'f\' title=\'Placed with free bet\' />';
            }
        }
        return String.format('\r\n\t\t\t\t<tr class=\'{0}\'>\r\n\t\t\t\t\t<td class=\'{18}\'>\r\n\t\t\t\t\t\t<span style=\'white-space: nowrap;\'>{1} {2:MMM yyyy}</span>\r\n\t\t\t\t\t\t<span style=\'white-space: nowrap;\'>{2:HH:mm}</span>\r\n\t\t\t\t\t</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{3}</td>\r\n\t\t\t\t\t<td class=\'{17}\' style=\'text-align:right;\'>{20}{4:n2}{5:n2}{6:n2}</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{7}</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{8} {9}</td>\r\n\t\t\t\t\t<td class=\'statselname {17}\'>{10}</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{11}</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{12}</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{13}</td>\r\n\t\t\t\t\t<td class=\'{17}\'>{14}</td>\r\n\t\t\t\t\t<td class=\'{17}\' style=\'text-align:right;\'>{15:n2}</td>\r\n\t\t\t\t\t<td class=\'{19}\' style=\'text-align:right;\'>{16:n2}</td>\r\n\t\t\t\t</tr>', rowCssClass, Framework.JSONFormat.parseDateTime(betHistoryDetail['TSAttempted'].toString()).getDate(), Framework.JSONFormat.parseDateTime(betHistoryDetail['TSAttempted'].toString()), betHistoryDetail['FullExternalReference'], betHistoryDetail['WUnitStake'], betHistoryDetail['PUnitStake'], betHistoryDetail['SUnitStake'], betHistoryDetail['BetTypeName'], betHistoryDetail['EventName'], betHistoryDetail['MarketName'], betHistoryDetail['SelectionName'], betHistoryDetail['Handicap'], this._fixedOddsBettingService.formatOdds(betHistoryDetail['IDFOPriceType'].toString(), betHistoryDetail['OwnPriceUp'], betHistoryDetail['OwnPriceDown']), betHistoryDetail['BetStateName'], betHistoryDetail['IDFOBetState'], betHistoryDetail['TotalStake'], betHistoryDetail['TotalReturn'], (isGroup) ? cellCssClass : 'dataCell', (isGroup) ? cellCssClass + ' dataCellGroupedLeft' : 'dataCell', (isGroup) ? cellCssClass + ' dataCellGroupedRight' : 'dataCell', isFreeIndicator);
    },
    
    setPageNavVisibility: function AbstractMMCoreComponents_AbstractStatementComponent$setPageNavVisibility(isVisible) {
        var pagenav = this._environment.getDomElement(this._domElementId + '-pagenav');
        if (pagenav) {
            pagenav.style.display = (isVisible) ? 'block' : 'none';
        }
    },
    
    setNextPageVisibility: function AbstractMMCoreComponents_AbstractStatementComponent$setNextPageVisibility(isVisible) {
        if (this._environment.getDomElement(this._domElementId + '-next-page')) {
            this._environment.getDomElement(this._domElementId + '-next-page').style.visibility = (isVisible) ? 'visible' : 'hidden';
        }
    },
    
    setPrevPageVisibility: function AbstractMMCoreComponents_AbstractStatementComponent$setPrevPageVisibility(isVisible) {
        if (this._environment.getDomElement(this._domElementId + '-prev-page')) {
            this._environment.getDomElement(this._domElementId + '-prev-page').style.visibility = (isVisible) ? 'visible' : 'hidden';
        }
    },
    
    goBack: function AbstractMMCoreComponents_AbstractStatementComponent$goBack() {
        this._log.debug('GoBack');
        this._navigationService.goBack();
        return false;
    },
    
    setPageSize: function AbstractMMCoreComponents_AbstractStatementComponent$setPageSize(pageSize) {
        this.pageSize = pageSize;
        this.update();
    }
}


Type.createNamespace('AbstractMMCoreComponents.BetSlipComponent');

////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder

AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder = function AbstractMMCoreComponents_BetSlipComponent_BetSlipXmlBuilder(betSlipCalculation, selections, stakePerSelection, allowedBetTypes, stakePerBetTypes, isEachWayPerBetType, previousSelections, fixedOddsbettingService, accountService, betSlipService) {
    this.Singles = new Array(Object.getKeyCount(selections));
    this.Multiples = new Array(allowedBetTypes.length);
    this.Summary = new AbstractMMCoreComponents.BetSlipComponent.BetSlipSummary();
    var index = 0;
    var runningTotalReturn = 0;
    var runningTotalStake = 0;
    var returnType = 0;
    var $dict1 = selections;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        this.Singles[index] = new AbstractMMCoreComponents.BetSlipComponent.SingleSelection();
        this.Singles[index].create(entry.value, fixedOddsbettingService, betSlipService);
        if (Object.keyExists(stakePerSelection, entry.key)) {
            this.Singles[index].Stake = stakePerSelection[entry.key];
            var selectionCalculation = (Object.keyExists(betSlipCalculation.PerSelection, entry.key)) ? betSlipCalculation.PerSelection[entry.key] : null;
            if (selectionCalculation) {
                this.Singles[index].TotalStake = AbstractMMCoreComponents.CommonBetting.formatNumber(selectionCalculation.TotalStake);
                this.Singles[index].UnitCount = selectionCalculation.UnitCount;
                this.Singles[index].PotentialReturn = AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(selectionCalculation.PotentialReturn);
                this.Singles[index].IDFOBetType = selectionCalculation.IDFOBetType;
                runningTotalReturn += selectionCalculation.PotentialReturn;
                runningTotalStake += selectionCalculation.TotalStake;
                returnType = AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType(selectionCalculation.PotentialReturn, returnType);
            }
        }
        index++;
    }
    index = 0;
    var $enum3 = allowedBetTypes.getEnumerator();
    while ($enum3.moveNext()) {
        var entry = $enum3.get_current();
        this.Multiples[index] = new AbstractMMCoreComponents.BetSlipComponent.MultipleSelection();
        this.Multiples[index].create(entry);
        if (Object.keyExists(stakePerBetTypes, entry.IDFOBetType)) {
            this.Multiples[index].Stake = stakePerBetTypes[entry.IDFOBetType];
            var betTypeCalculation = (Object.keyExists(betSlipCalculation.PerBetType, entry.IDFOBetType)) ? betSlipCalculation.PerBetType[entry.IDFOBetType] : null;
            if (betTypeCalculation) {
                this.Multiples[index].TotalStake = AbstractMMCoreComponents.CommonBetting.formatNumber(betTypeCalculation.TotalStake);
                this.Multiples[index].UnitCount = betTypeCalculation.UnitCount;
                this.Multiples[index].PotentialReturn = AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(betTypeCalculation.PotentialReturn);
                this.Multiples[index].IDFOBetType = betTypeCalculation.IDFOBetType;
                this.Multiples[index].IsEachWayChecked = isEachWayPerBetType[entry.IDFOBetType];
                runningTotalReturn += betTypeCalculation.UnitCount;
                runningTotalStake += betTypeCalculation.TotalStake;
                returnType = AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType(betTypeCalculation.PotentialReturn, returnType);
            }
        }
        index++;
    }
    this.Summary.Selections = this.Singles.length;
    this.Summary.TotalReturn = AbstractMMCoreComponents.CommonBetting.formatPotentialReturn((returnType < 0) ? returnType : runningTotalReturn);
    this.Summary.TotalStake = AbstractMMCoreComponents.CommonBetting.formatNumber(runningTotalStake);
    if (accountService.get_creditAccountDetails()) {
        this.Summary.Balance = AbstractMMCoreComponents.CommonBetting.formatNumber(accountService.get_creditAccountDetails().WithdrawalBalance);
    }
    if (accountService.get_freeAccountDetails()) {
        this.Summary.FreeBets = AbstractMMCoreComponents.CommonBetting.formatNumber(accountService.get_freeAccountDetails().WithdrawalBalance);
    }
    var changedSelections = [];
    var $dict4 = previousSelections;
    for (var $key5 in $dict4) {
        var previousEntry = { key: $key5, value: $dict4[$key5] };
        var previousSelection = previousEntry.value;
        if (Object.keyExists(selections, previousEntry.key)) {
            var currentSelection = selections[previousEntry.key];
            if (previousSelection.PriceUp !== currentSelection.PriceUp || previousSelection.PriceDown !== currentSelection.PriceDown || previousSelection.PriceUpCS !== currentSelection.PriceUpCS || previousSelection.PriceDownCS !== currentSelection.PriceDownCS) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.price, currentSelection.SelectionName, fixedOddsbettingService.formatOdds(currentSelection.IDFOPriceType[currentSelection.ActivePriceType], currentSelection.PriceUp, currentSelection.PriceDown), fixedOddsbettingService.formatOdds(previousSelection.IDFOPriceType[previousSelection.ActivePriceType], previousSelection.PriceUp, previousSelection.PriceDown)));
            }
            if (previousSelection.Handicap !== currentSelection.Handicap) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.handicap, currentSelection.SelectionName, currentSelection.Handicap.toString(), previousSelection.Handicap.toString()));
            }
            if (previousSelection.SelectionName !== currentSelection.SelectionName) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.name, previousSelection.SelectionName, currentSelection.SelectionName, previousSelection.SelectionName));
            }
            if (previousSelection.IsTradable !== currentSelection.IsTradable) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.tradable, currentSelection.SelectionName, '', ''));
            }
            if (previousSelection.LowerBand !== currentSelection.LowerBand || previousSelection.UpperBand !== currentSelection.UpperBand) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.band, currentSelection.SelectionName, currentSelection.LowerBand + ' ' + currentSelection.UpperBand, previousSelection.LowerBand + ' ' + previousSelection.UpperBand));
            }
            if (AbstractMMCoreComponents.CommonBetting.checkArrayDifferences(previousSelection.EachWayPlaceTerms, currentSelection.EachWayPlaceTerms) && AbstractMMCoreComponents.CommonBetting.checkArrayDifferences(previousSelection.EachWayReduction, currentSelection.EachWayReduction)) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.eachWay, currentSelection.SelectionName, AbstractMMCoreComponents.CommonBetting.formatEachWayOdds(currentSelection.EachWayReduction, currentSelection.EachWayPlaceTerms), AbstractMMCoreComponents.CommonBetting.formatEachWayOdds(previousSelection.EachWayReduction, previousSelection.EachWayPlaceTerms)));
            }
            if (!AbstractMMCoreComponents.CommonBetting.checkArrayDifferences(previousSelection.IDFOPriceType, currentSelection.IDFOPriceType)) {
                changedSelections.add(new AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate(previousEntry.key, AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.priceType, currentSelection.SelectionName, AbstractMMCoreComponents.CommonBetting.formatPriceTypes(currentSelection.IDFOPriceType), AbstractMMCoreComponents.CommonBetting.formatPriceTypes(previousSelection.IDFOPriceType)));
            }
        }
    }
    this.SelectionsUpdates = changedSelections;
}
AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder.prototype = {
    Singles: null,
    Multiples: null,
    Summary: null,
    SelectionsUpdates: null,
    
    getBetSlipXML: function AbstractMMCoreComponents_BetSlipComponent_BetSlipXmlBuilder$getBetSlipXML() {
        var xmlData = Framework.AbstractEnvironment.serializeToXml('state', this, false);
        return (String.isNullOrEmpty(xmlData)) ? Framework.XMLUtils.get_emptyContentDocument() : XMLDocumentParser.parse(xmlData);
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.BetSlipSummary

AbstractMMCoreComponents.BetSlipComponent.BetSlipSummary = function AbstractMMCoreComponents_BetSlipComponent_BetSlipSummary() {
}
AbstractMMCoreComponents.BetSlipComponent.BetSlipSummary.prototype = {
    Selections: null,
    TotalStake: null,
    TotalReturn: null,
    Balance: null,
    FreeBets: null
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection

AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection = function AbstractMMCoreComponents_BetSlipComponent_BetSlipSelection() {
}
AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection.prototype = {
    Stake: 0,
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: null,
    IDFOBetType: null
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.SingleSelection

AbstractMMCoreComponents.BetSlipComponent.SingleSelection = function AbstractMMCoreComponents_BetSlipComponent_SingleSelection() {
    AbstractMMCoreComponents.BetSlipComponent.SingleSelection.constructBase(this);
}
AbstractMMCoreComponents.BetSlipComponent.SingleSelection.prototype = {
    IDFOPriceType: null,
    ActiveBetTypes: null,
    SinglePrices: null,
    ActivePriceTypeIndex: 0,
    IDFOEvent: null,
    EventName: null,
    IDFOMarket: null,
    MarketName: null,
    HADValue: null,
    Handicap: null,
    EachWayReduction: null,
    EachWayPlaceTerms: null,
    ActiveEachWayIndex: 0,
    IDFOSelection: null,
    SelectionName: null,
    PriceUp: null,
    PriceDown: null,
    IDFOEventScorecast: null,
    IDFOSelectionCS: null,
    IsTrapBettingOptionOn: false,
    IsTrap: false,
    UseWhenCalculatingMultiples: false,
    InterelationColor: null,
    
    create: function AbstractMMCoreComponents_BetSlipComponent_SingleSelection$create(selection, fixedOddsbettingService, betSlipService) {
        this.ActiveBetTypes = selection.ActiveBetTypes;
        this.ActiveEachWayIndex = selection.ActiveEachWay;
        this.ActivePriceTypeIndex = selection.ActivePriceType;
        this.EachWayPlaceTerms = selection.EachWayPlaceTerms;
        this.EachWayReduction = selection.EachWayReduction;
        var oEventName = selection.EventName.replace('&', '&#38;');
        this.EventName = decodeURI(oEventName);
        this.HADValue = selection.HADValue;
        this.Handicap = selection.Handicap;
        this.IDFOEvent = selection.IDFOEvent;
        this.IDFOEventScorecast = selection.IDFOEventScorecast;
        this.IDFOMarket = selection.IDFOMarket;
        this.IDFOPriceType = selection.IDFOPriceType;
        this.IDFOSelection = selection.IDFOSelection;
        this.IDFOSelectionCS = selection.IDFOSelectionCS;
        var oMarketName = selection.MarketName.replace('&', '&#38;');
        this.MarketName = decodeURI(oMarketName);
        this.PriceDown = selection.PriceDown;
        this.PriceUp = selection.PriceUp;
        this.SelectionName = selection.SelectionName;
        this.IsTrapBettingOptionOn = selection.IsTrapBettingOptionOn;
        this.IsTrap = selection.IsTrap;
        this.UseWhenCalculatingMultiples = true;
        this.InterelationColor = betSlipService.getSelectionsInterRelationColors()[selection.IDFOSelection.toString()];
        this.SinglePrices = new Array(0);
        for (var i = 0; i < this.IDFOPriceType.length; i++) {
            if (FixedOddsBettingService.PriceType.isValidForSingle(this.IDFOPriceType[i])) {
                this.SinglePrices[i] = new AbstractMMCoreComponents.BetSlipComponent.BetSlipPriceType(this.IDFOPriceType[i], fixedOddsbettingService.formatOdds(this.IDFOPriceType[i], this.PriceUp, this.PriceDown));
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.MultipleSelection

AbstractMMCoreComponents.BetSlipComponent.MultipleSelection = function AbstractMMCoreComponents_BetSlipComponent_MultipleSelection() {
    AbstractMMCoreComponents.BetSlipComponent.MultipleSelection.constructBase(this);
}
AbstractMMCoreComponents.BetSlipComponent.MultipleSelection.prototype = {
    Name: null,
    IsEachWayAllowed: false,
    IsEachWayChecked: false,
    
    create: function AbstractMMCoreComponents_BetSlipComponent_MultipleSelection$create(betType) {
        this.IDFOBetType = betType.IDFOBetType;
        this.IsEachWayAllowed = betType.IsEachWayAllowed;
        this.Name = betType.Name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.BetSlipPriceType

AbstractMMCoreComponents.BetSlipComponent.BetSlipPriceType = function AbstractMMCoreComponents_BetSlipComponent_BetSlipPriceType(IDFOPriceType, formattedOdds) {
    this.IDFOPriceType = IDFOPriceType;
    this.FormattedOdds = formattedOdds;
}
AbstractMMCoreComponents.BetSlipComponent.BetSlipPriceType.prototype = {
    IDFOPriceType: null,
    FormattedOdds: null
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate

AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate = function AbstractMMCoreComponents_BetSlipComponent_BetSlipUpdate(selectionKey, updateType, selectionName, newValue, oldValue) {
    this.SelectionKey = selectionKey;
    this.UpdateType = updateType;
    this.SelectionName = selectionName;
    this.NewValue = newValue;
    this.OldValue = oldValue;
}
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate.prototype = {
    SelectionKey: null,
    UpdateType: null,
    SelectionName: null,
    NewValue: null,
    OldValue: null
}


////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes

AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes = function AbstractMMCoreComponents_BetSlipComponent_BetSlipUpdateTypes() {
}


AbstractMMCoreComponents.AbstractBetPlacementComponent.createClass('AbstractMMCoreComponents.AbstractBetPlacementComponent', Framework.Component.AbstractXsltBasedComponent, NavigationService.IPageFilterChangedListener, FixedOddsBettingService.IOddsTypeChangedListener, AccountService.IAccountPreferencesChangedListener, FixedOddsBettingService.IBetPlacementStateChangedListener);
AbstractMMCoreComponents.AbstractBetSlipComponent.createClass('AbstractMMCoreComponents.AbstractBetSlipComponent', Framework.Component.AbstractXsltBasedComponent, AccountService.IBalanceChangedListener, NavigationService.IPageFilterChangedListener, FixedOddsBettingService.IOddsTypeChangedListener, BetSlipService.ISelectionsAddedListener, BetSlipService.ISelectionsRemovedListener, BetSlipService.IAllowedBetTypesChangedListener, BetSlipService.IBetSlipCalculationChangedListener, BetSlipService.IBetSlipSelectionsUpdateListener);
AbstractMMCoreComponents.CommonBetting.createClass('AbstractMMCoreComponents.CommonBetting');
AbstractMMCoreComponents.AbstractLoginComponent.createClass('AbstractMMCoreComponents.AbstractLoginComponent', Framework.Component.AbstractXsltBasedComponent, UserService.IUserChangedListener);
AbstractMMCoreComponents.AbstractPaymentTransactionComponent.createClass('AbstractMMCoreComponents.AbstractPaymentTransactionComponent', Framework.Component.AbstractXsltBasedComponent, UserService.IUserChangedListener, NavigationService.IPageFilterChangedListener, AccountService.IBalanceChangedListener);
AbstractMMCoreComponents.RowType.createClass('AbstractMMCoreComponents.RowType');
AbstractMMCoreComponents.AbstractStatementComponent.createClass('AbstractMMCoreComponents.AbstractStatementComponent', Framework.Component.AbstractXsltBasedComponent, NavigationService.IPageFilterChangedListener, UserService.IUserChangedListener);
AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder.createClass('AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder');
AbstractMMCoreComponents.BetSlipComponent.BetSlipSummary.createClass('AbstractMMCoreComponents.BetSlipComponent.BetSlipSummary');
AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection.createClass('AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection');
AbstractMMCoreComponents.BetSlipComponent.SingleSelection.createClass('AbstractMMCoreComponents.BetSlipComponent.SingleSelection', AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection);
AbstractMMCoreComponents.BetSlipComponent.MultipleSelection.createClass('AbstractMMCoreComponents.BetSlipComponent.MultipleSelection', AbstractMMCoreComponents.BetSlipComponent.BetSlipSelection);
AbstractMMCoreComponents.BetSlipComponent.BetSlipPriceType.createClass('AbstractMMCoreComponents.BetSlipComponent.BetSlipPriceType');
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate.createClass('AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdate');
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.createClass('AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes');
AbstractMMCoreComponents.AbstractBetPlacementComponent._betPlacementStateDomElementId$2 = [ 'confirmation-required-before', 'confirmation-required', 'placed', 'acceptable', 'rejected', 'waiting', 'failed' ];
AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2 = 'error_message';
AbstractMMCoreComponents.AbstractPaymentTransactionComponent._statusArea = [ 'transient', 'success', 'failed', 'approval' ];
AbstractMMCoreComponents.AbstractStatementComponent._DisplayBalanceHistory = 0;
AbstractMMCoreComponents.AbstractStatementComponent._DisplayBetHistory = 1;
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.price = 'Price';
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.handicap = 'Handicap';
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.name = 'Name';
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.tradable = 'Tradable';
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.band = 'Band';
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.eachWay = 'EachWay';
AbstractMMCoreComponents.BetSlipComponent.BetSlipUpdateTypes.priceType = 'PriceType';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('AbstractWarpComponents');

////////////////////////////////////////////////////////////////////////////////
// AbstractWarpComponents.AbstractMarketGroupListComponent

AbstractWarpComponents.AbstractMarketGroupListComponent = function AbstractWarpComponents_AbstractMarketGroupListComponent() {
    this._marketTypesSelected = [];
    this._scrollingScorecastDomains = [];
    AbstractWarpComponents.AbstractMarketGroupListComponent.constructBase(this);
}
AbstractWarpComponents.AbstractMarketGroupListComponent.prototype = {
    _parameters: null,
    _marketGroupXsltUrl: null,
    _marketGroupContentUrl: null,
    _marketContentUrl: null,
    _eventScorecastContentUrl: null,
    _eventContentUrl: null,
    _mediaImagesBaseUrl: null,
    _mediaCoverageContentUrl: null,
    _autoRefreshPeriod: 10000,
    _dateGrouping: false,
    _maxSelectionCount: 0,
    _isFirstMarketTypeView: true,
    _scrollScorecasts: true,
    
    _getRacePoolTabElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getRacePoolTabElement$1(IDFOMarket, racePoolTab) {
        return this.getPrivateDomElement(String.format('{0}-{1}-racepool-tab', IDFOMarket, racePoolTab));
    },
    
    _getRacePoolTblElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getRacePoolTblElement$1(IDFOMarket, racePoolTab) {
        return this.getPrivateDomElement(String.format('{0}-{1}-racepool-tbl', IDFOMarket, racePoolTab));
    },
    
    _getRacePoolSelectionCheckboxElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getRacePoolSelectionCheckboxElement$1(IDFOMarket, IDFOPriceType, IDFOSelection, selectionPlace) {
        return this.getPrivateDomElement(String.format('racepool-selection-{0}-{1}-{2}-{3}', IDFOMarket, IDFOPriceType, IDFOSelection, selectionPlace));
    },
    
    _updateRacePoolTotalStakeElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_updateRacePoolTotalStakeElement$1(IDFOMarket, IDFOPriceType, stake) {
        var stakeString = (stake) ? stake.toString() : '';
        this.updatePrivateDomElement(String.format('{0}-{1}-totalstake', IDFOMarket, IDFOPriceType), stakeString);
    },
    
    _updateRacePoolPlaceBetBtn$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_updateRacePoolPlaceBetBtn$1(IDFOMarket, racePoolTab, stake) {
        var btn = this.getPrivateDomElement(String.format('{0}-{1}-placebet-btn', IDFOMarket, racePoolTab));
        if (btn) {
            btn.disabled = !stake;
        }
    },
    
    _getRacePoolUnitStakeElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getRacePoolUnitStakeElement$1(IDFOMarket, IDFOPriceType) {
        return this.getPrivateDomElement(String.format('{0}-{1}-unitstake', IDFOMarket, IDFOPriceType));
    },
    
    _setActiveRacePoolTabs$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_setActiveRacePoolTabs$1() {
        this._log.debug('SetActiveRacePoolTabs');
        var $dict1 = this._racePoolBetSlipService.getRacePoolRaceTabsManagers();
        for (var $key2 in $dict1) {
            var raceTab = { key: $key2, value: $dict1[$key2] };
            var manager = raceTab.value;
            this.setActiveRacePoolTab(manager.idfoMarket);
        }
    },
    
    setActiveRacePoolTab: function AbstractWarpComponents_AbstractMarketGroupListComponent$setActiveRacePoolTab(IDFOMarket) {
        var manager = this._racePoolBetSlipService.getRacePoolRaceTabsManager(IDFOMarket);
        if (!manager) {
            return;
        }
        for (var i = 0; i < manager.racePoolTabs.length; i++) {
            var tab = this._getRacePoolTabElement$1(IDFOMarket, manager.racePoolTabs[i].toString());
            var table = this._getRacePoolTblElement$1(IDFOMarket, manager.racePoolTabs[i].toString());
            if (manager.racePoolTabs[i].toString() === manager.activeRacePoolTab) {
                if (tab) {
                    this._environment.safelySetCssClass(tab.id, 'cur');
                }
                if (table) {
                    table.style.display = 'block';
                }
            }
            else {
                if (tab) {
                    this._environment.safelyRemoveCssClass(tab.id, 'cur');
                }
                if (table) {
                    table.style.display = 'none';
                }
            }
        }
    },
    
    collectRacePoolMarketsFromPage: function AbstractWarpComponents_AbstractMarketGroupListComponent$collectRacePoolMarketsFromPage() {
        this._log.debug('CollectRacePoolMarketsFromPage');
        var liElements = this._environment.getDomElement(this._domElementId).getElementsByTagName('li');
        if (!liElements) {
            return;
        }
        for (var i = 0; i < liElements.length; i++) {
            if (!String.isNullOrEmpty(liElements[i].id) && liElements[i].id.indexOf('racepool-tab') > 0) {
                var IDParts = liElements[i].id.split('-');
                this._racePoolBetSlipService.addTabToRacePoolRaceTabsManager(Number.parse(IDParts[1]), IDParts[2]);
            }
        }
    },
    
    _clearRacePoolSelections$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_clearRacePoolSelections$1(IDFOMarket, IDFOPriceType) {
        this._racePoolBetSlipService.removeAllRacePoolSelections(IDFOMarket, IDFOPriceType);
    },
    
    _updateRacePoolState$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_updateRacePoolState$1() {
        var racePools = this._racePoolBetSlipService.getRacePools();
        var $dict1 = racePools;
        for (var $key2 in $dict1) {
            var racePoolentry = { key: $key2, value: $dict1[$key2] };
            var racePool = racePoolentry.value;
            var $dict3 = racePool.selectionsPlaces;
            for (var $key4 in $dict3) {
                var placeEntry = { key: $key4, value: $dict3[$key4] };
                var currentSelectionPlace = placeEntry.key;
                var IDFOSelections = placeEntry.value;
                if (IDFOSelections) {
                    for (var i = 0; i < IDFOSelections.length; i++) {
                        var selection = racePool.selections[IDFOSelections[i].toString()];
                        var checkBox = this._getRacePoolSelectionCheckboxElement$1(selection.IDFOMarket, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, currentSelectionPlace);
                        if (checkBox) {
                            checkBox.checked = true;
                        }
                    }
                }
            }
            if (racePool.calculatedBet) {
                this._updateRacePoolTotalStakeElement$1(racePool.idfoMarket, racePool.idfoPriceType, racePool.calculatedBet.TotalStake);
                this._updateRacePoolPlaceBetBtn$1(racePool.idfoMarket, racePool.racePoolTab, racePool.calculatedBet.TotalStake);
            }
            if (racePool.unitStake) {
                var unitStakeElement = this._getRacePoolUnitStakeElement$1(racePool.idfoMarket, racePool.idfoPriceType);
                if (unitStakeElement) {
                    unitStakeElement.value = racePool.unitStake.toString();
                }
            }
        }
    },
    
    _populateRacePoolCalculation$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_populateRacePoolCalculation$1(IDFOMarket, IDFOPriceType) {
        var racePool = this._racePoolBetSlipService.getRacePool(IDFOMarket, IDFOPriceType);
        var stake = (racePool.calculatedBet) ? racePool.calculatedBet.TotalStake : 0;
        this._updateRacePoolTotalStakeElement$1(IDFOMarket, IDFOPriceType, stake);
        this._updateRacePoolPlaceBetBtn$1(IDFOMarket, racePool.racePoolTab, stake);
    },
    
    getMarketElement: function AbstractWarpComponents_AbstractMarketGroupListComponent$getMarketElement(IDFOMarket) {
        return this.getPrivateDomElement(IDFOMarket);
    },
    
    _getEventScorecastElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getEventScorecastElement$1(IDFOEventScorecast) {
        var element = this.getPrivateDomElement(IDFOEventScorecast);
        if (!element) {
            element = document.getElementById(this._domElementId);
        }
        return element;
    },
    
    getSimpleSelectionCheckBoxElement: function AbstractWarpComponents_AbstractMarketGroupListComponent$getSimpleSelectionCheckBoxElement(IDFOSelection) {
        var domElementId = String.format('{0}-selection-{1}', this._domElementId, IDFOSelection);
        return this._environment.getDomElement(domElementId);
    },
    
    _getScorecastSelectionCheckBoxElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getScorecastSelectionCheckBoxElement$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        var domElementId = String.format('{0}-selection-{1}-{2}-{3}', this._domElementId, IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        return this._environment.getDomElement(domElementId);
    },
    
    _getSelectionCheckBoxElement$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getSelectionCheckBoxElement$1(selection) {
        return (!selection.IDFOEventScorecast) ? this.getSimpleSelectionCheckBoxElement(selection.IDFOSelection) : this._getScorecastSelectionCheckBoxElement$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS);
    },
    
    updateCheckboxes: function AbstractWarpComponents_AbstractMarketGroupListComponent$updateCheckboxes() {
        var $dict1 = this._betSlipService.getSelections();
        for (var $key2 in $dict1) {
            var selectionEntry = { key: $key2, value: $dict1[$key2] };
            var selection = selectionEntry.value;
            var selectionCheckBoxElement = this._getSelectionCheckBoxElement$1(selection);
            if (selectionCheckBoxElement) {
                selectionCheckBoxElement.checked = true;
            }
        }
    },
    
    getXsltParameters: function AbstractWarpComponents_AbstractMarketGroupListComponent$getXsltParameters(displayShowAll) {
        var result = {};
        result['component-instance-name'] = this._componentInstanceName;
        result['component-dom-element-id'] = this._domElementId;
        result['odds-type'] = this._fixedOddsBettingService.getPreferences().OddsType.toUpperCase();
        result['media-images-base-url'] = this._mediaImagesBaseUrl;
        result['mediacoverage-content-url'] = this._mediaCoverageContentUrl;
        result['date-grouping'] = this._dateGrouping;
        result['current-date'] = Date.get_today().format('dd/MM/yyyy');
        result['race-tabs-per-market'] = '';
        if (displayShowAll) {
            result['display-show-all'] = true;
        }
        return result;
    },
    
    _getTranslatedPhrase$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_getTranslatedPhrase$1(phrase) {
        return phrase;
    },
    
    transformAndUpdateCallback: function AbstractWarpComponents_AbstractMarketGroupListComponent$transformAndUpdateCallback(domID) {
        if (this._environment.getDomElement(domID)) {
            this.bindBehaviors(domID);
        }
        this.updateCheckboxes();
        this.collectRacePoolMarketsFromPage();
        this._setActiveRacePoolTabs$1();
        this._updateRacePoolState$1();
        this.updateVisibleMarketTypes(this._isFirstMarketTypeView);
    },
    
    bindBehaviors: function AbstractWarpComponents_AbstractMarketGroupListComponent$bindBehaviors(domID) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(domID), (this));
    },
    
    updateVisibleMarketTypes: function AbstractWarpComponents_AbstractMarketGroupListComponent$updateVisibleMarketTypes(selectStartingMarketTypes) {
        var marketTypeSelectorContainer = this.getPrivateDomElement('markettype-selector-container');
        if (marketTypeSelectorContainer) {
            var inputCollection = marketTypeSelectorContainer.getElementsByTagName('input');
            var numberToShowOnStart = 3;
            var numberSelected = 0;
            for (var i = 0; i < inputCollection.length; i++) {
                var inputElement = inputCollection[i];
                if (inputElement.type === 'checkbox' && inputElement.getAttribute('idfomarkettype')) {
                    var IDFOMarketType = inputElement.getAttribute('idfomarkettype').toString();
                    var marketTypeSelector = inputElement;
                    if (selectStartingMarketTypes && numberSelected < numberToShowOnStart) {
                        this._marketTypesSelected.add(IDFOMarketType);
                        numberSelected++;
                    }
                    if (this._marketTypesSelected.contains(IDFOMarketType)) {
                        marketTypeSelector.checked = true;
                    }
                    this.toggleMarketTypeGroup(IDFOMarketType);
                }
            }
        }
        this._isFirstMarketTypeView = false;
    },
    
    toggleMarketTypeGroup: function AbstractWarpComponents_AbstractMarketGroupListComponent$toggleMarketTypeGroup(IDFOMarketType) {
        var marketTypeContainer = this.getPrivateDomElement('markettype-container-' + IDFOMarketType);
        if (marketTypeContainer) {
            marketTypeContainer.style.display = (this._marketTypesSelected.contains(IDFOMarketType)) ? 'block' : 'none';
        }
    },
    
    clearPeriodicalTransformAndUpdateTasks: function AbstractWarpComponents_AbstractMarketGroupListComponent$clearPeriodicalTransformAndUpdateTasks() {
        this._environment.clearPeriodicalTransformAndUpdate(this._domElementId);
        var $enum1 = this._scrollingScorecastDomains.getEnumerator();
        while ($enum1.moveNext()) {
            var domain = $enum1.get_current();
            this._environment.clearPeriodicalTransformAndUpdate(domain);
        }
        this._scrollingScorecastDomains.clear();
    },
    
    repaintMarket: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintMarket(IDFOMarket, displayShowAll) {
        this._log.debug(String.format('RepaintMarket IDFOMarket=[{0}] displayShowAll=[{1}]', IDFOMarket, displayShowAll));
        this.setActiveRacePoolTab(Number.parse(IDFOMarket));
        if (this.getMarketElement(IDFOMarket)) {
            this.getMarketElement(IDFOMarket).style.display = 'block';
            var contentUrl = this._marketContentUrl.replace('${idfomarket}', IDFOMarket);
            var domID = this._domElementId + '-' + IDFOMarket;
            this._environment.periodicalTransformAndUpdate(domID, contentUrl, this._marketGroupXsltUrl, this.getXsltParameters(displayShowAll), Delegate.create(this, function() {
                this.transformAndUpdateCallback(domID);
            }), this._domElementId, this._autoRefreshPeriod);
        }
        else {
            this._log.debug(String.format('No element with id {0}-{1}, skipping market repaint', this._domElementId, IDFOMarket));
        }
    },
    
    repaintEventScorecast: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintEventScorecast(IDFOEventScorecast, idfoSelectionGoalScorer, displayShowAll) {
        this._log.debug(String.format('RepaintEventScorecast IDFOEventScorecast=[{0}] idfoSelectionGoalScorer=[{1}] displayShowAll=[{2}]', IDFOEventScorecast, idfoSelectionGoalScorer, displayShowAll));
        var scorecastElement = this._getEventScorecastElement$1(IDFOEventScorecast);
        if (scorecastElement) {
            scorecastElement.style.display = 'block';
            var contentUrl = this._eventScorecastContentUrl.replace('${idfoeventscorecast}', IDFOEventScorecast).replace('${idfoselectedgoalscorer}', idfoSelectionGoalScorer);
            if (this._scrollScorecasts) {
                this._environment.periodicalTransformAndUpdate(scorecastElement.id, contentUrl, this._marketGroupXsltUrl, this.getXsltParameters(displayShowAll), Delegate.create(this, function() {
                    this.bindBehaviors(scorecastElement.id);
                    this.updateCheckboxes();
                }), this._domElementId, this._autoRefreshPeriod);
            }
            else {
                var navIDFOEventScorecast = this._bettingNavigationService.getEventScorecastFromEvent();
                if (!String.isNullOrEmpty(navIDFOEventScorecast)) {
                    this._environment.clearPeriodicalTransformAndUpdate(this._domElementId);
                    this._environment.periodicalTransformAndUpdate(this._domElementId, contentUrl, this._marketGroupXsltUrl, this.getXsltParameters(displayShowAll), Delegate.create(this, function() {
                        this.bindBehaviors(this._domElementId);
                        this.updateCheckboxes();
                    }), this._domElementId, this._autoRefreshPeriod);
                }
                else {
                    this._environment.clearPeriodicalTransformAndUpdate(scorecastElement.id);
                    this._scrollingScorecastDomains.add(scorecastElement.id);
                    this._environment.periodicalTransformAndUpdate(scorecastElement.id, contentUrl, this._marketGroupXsltUrl, this.getXsltParameters(displayShowAll), Delegate.create(this, function() {
                        this.bindBehaviors(scorecastElement.id);
                        this.updateCheckboxes();
                    }), scorecastElement.id, this._autoRefreshPeriod);
                }
            }
        }
        else {
            this._log.debug(String.format('Cannot find event scorecast box placeholder IDFOEventScorecast=[{0}]', IDFOEventScorecast));
        }
    },
    
    _showMaxSelectionMsg$1: function AbstractWarpComponents_AbstractMarketGroupListComponent$_showMaxSelectionMsg$1() {
        var oElement = document.getElementById(this._domElementId + '-max-selection-msg');
        if (oElement) {
            alert(oElement.innerText);
        }
    },
    
    _userService: null,
    
    setUserService: function AbstractWarpComponents_AbstractMarketGroupListComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    onUserChanged: function AbstractWarpComponents_AbstractMarketGroupListComponent$onUserChanged(eventSource) {
        this._log.debug('OnUserChanged');
    },
    
    _betSlipService: null,
    
    setBetSlipService: function AbstractWarpComponents_AbstractMarketGroupListComponent$setBetSlipService(betSlipService) {
        this._log.debug('SetBetSlipService');
        this._betSlipService = betSlipService;
    },
    
    onSelectionsAdded: function AbstractWarpComponents_AbstractMarketGroupListComponent$onSelectionsAdded(eventSource, selection) {
        this._log.debug('OnSelectionsAdded');
        for (var i = 0; i < selection.length; i++) {
            this._log.debug(String.format('OnSelectionsAdded - Checking selection RacePoolType=[{0}] IDFOSelection=[{1}]', selection[i].IDFOPriceType, selection[i].IDFOSelection));
            var checkBoxElement = this._getSelectionCheckBoxElement$1(selection[i]);
            if (checkBoxElement) {
                checkBoxElement.checked = true;
            }
        }
    },
    
    onSelectionsRemoved: function AbstractWarpComponents_AbstractMarketGroupListComponent$onSelectionsRemoved(eventSource, selection) {
        this._log.debug('OnSelectionsRemoved');
        for (var i = 0; i < selection.length; i++) {
            this._log.debug(String.format('Unchecking selection RacePoolType=[{0}] IDFOSelection=[{1}]', selection[i].IDFOPriceType, selection[i].IDFOSelection));
            var checkBoxElement = this._getSelectionCheckBoxElement$1(selection[i]);
            if (checkBoxElement) {
                checkBoxElement.checked = false;
            }
        }
    },
    
    _racePoolBetSlipService: null,
    
    setRacePoolBetSlipService: function AbstractWarpComponents_AbstractMarketGroupListComponent$setRacePoolBetSlipService(racePoolBetSlipService) {
        this._log.debug('SetRacePoolBetSlipService');
        this._racePoolBetSlipService = racePoolBetSlipService;
    },
    
    onRacePoolSelectionsAdded: function AbstractWarpComponents_AbstractMarketGroupListComponent$onRacePoolSelectionsAdded(IDFOMarket, selection, selectionsPlaces) {
        this._log.debug('OnRacePoolSelectionsAdded');
        for (var i = 0; i < selectionsPlaces.length; i++) {
            this._log.debug(String.format('Checking selection IDFOMarket=[{0}] IDFOMarket=[{1}] IDFOSelection=[{2}] selectionPlace=[{3}]', selection[i].IDFOMarket, selection[i].IDFOPriceType, selection[i].IDFOSelection, selectionsPlaces[i]));
            var checkBoxElement = this._getRacePoolSelectionCheckboxElement$1(selection[i].IDFOMarket, selection[i].IDFOPriceType[selection[i].ActivePriceType], selection[i].IDFOSelection, selectionsPlaces[i]);
            if (checkBoxElement) {
                checkBoxElement.checked = true;
            }
        }
    },
    
    onRacePoolSelectionsRemoved: function AbstractWarpComponents_AbstractMarketGroupListComponent$onRacePoolSelectionsRemoved(IDFOMarket, selection, selectionsPlaces) {
        this._log.debug('OnRacePoolSelectionsRemoved');
        for (var i = 0; i < selection.length; i++) {
            this._log.debug(String.format('Unchecking selection IDFOMarket=[{0}] IDFOPriceType=[{1}] IDFOSelection=[{2}] selectionPlace=[{3}]', selection[i].IDFOMarket, selection[i].IDFOPriceType, selection[i].IDFOSelection, selectionsPlaces[i]));
            var checkBoxElement = this._getRacePoolSelectionCheckboxElement$1(selection[i].IDFOMarket, selection[i].IDFOPriceType[selection[i].ActivePriceType], selection[i].IDFOSelection, selectionsPlaces[i]);
            if (checkBoxElement) {
                checkBoxElement.checked = false;
            }
        }
    },
    
    onRacePoolBetSlipCalculationChanged: function AbstractWarpComponents_AbstractMarketGroupListComponent$onRacePoolBetSlipCalculationChanged(IDFOMarket, IDFOPriceType) {
        this._log.debug('OnRacePoolBetSlipCalculationChanged');
        this._populateRacePoolCalculation$1(IDFOMarket, IDFOPriceType);
    },
    
    _bettingNavigationService: null,
    
    setBettingNavigationService: function AbstractWarpComponents_AbstractMarketGroupListComponent$setBettingNavigationService(bettingNavigationService) {
        this._log.debug('SetBettingNavigationService');
        this._bettingNavigationService = bettingNavigationService;
    },
    
    _fixedOddsBettingService: null,
    
    setFixedOddsBettingService: function AbstractWarpComponents_AbstractMarketGroupListComponent$setFixedOddsBettingService(fixedOddsBettingService) {
        this._log.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService = fixedOddsBettingService;
    },
    
    onOddsTypeChanged: function AbstractWarpComponents_AbstractMarketGroupListComponent$onOddsTypeChanged(fixedOddsBettingService) {
        this._log.debug('OnOddsTypeChanged');
        this.repaint();
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractWarpComponents_AbstractMarketGroupListComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractWarpComponents_AbstractMarketGroupListComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this._isFirstMarketTypeView = true;
        this.repaint();
    },
    
    init: function AbstractWarpComponents_AbstractMarketGroupListComponent$init(environment, componentInstanceName, domElementId, parameters) {
        AbstractWarpComponents.AbstractMarketGroupListComponent.callBase(this, 'init', [ environment, componentInstanceName, domElementId, parameters ]);
        this._parameters = new Framework.CommonComponentParameters(parameters);
        this._marketGroupXsltUrl = parameters['market-group-xslt-url'];
        this._marketGroupXsltUrl = this._marketGroupXsltUrl.replace('${region}', this._environment.getRegion());
        this._marketGroupXsltUrl = this._marketGroupXsltUrl.replace('${language}', this._environment.getLanguage());
        this._marketGroupContentUrl = parameters['market-group-content-url'];
        this._marketContentUrl = parameters['market-content-url'];
        this._eventScorecastContentUrl = parameters['scorecast-content-url'];
        this._eventContentUrl = parameters['event-content-url'];
        this._mediaImagesBaseUrl = parameters['media-images-base-url'];
        this._autoRefreshPeriod = Number.parse(parameters['auto-refresh-period']);
        if (Object.keyExists(parameters, 'date-grouping')) {
            this._dateGrouping = Boolean.parse(parameters['date-grouping']);
        }
        if (Object.keyExists(parameters, 'max-selection-count')) {
            this._maxSelectionCount = Number.parse(parameters['max-selection-count']);
        }
        var _raceTabsPerMarket = parameters['race-tabs-per-market'];
        var mediaCoverageContentUrl = parameters['mediacoverage-content-url'];
        if (mediaCoverageContentUrl.startsWith('/')) {
            mediaCoverageContentUrl = mediaCoverageContentUrl.substr(1);
        }
        this._mediaCoverageContentUrl = this._environment.getBaselineUrl(String.equals('https', this._environment.getProtocol(), true)) + mediaCoverageContentUrl.replace('${region}', this._environment.getRegion());
        this._scrollScorecasts = (Object.keyExists(parameters, 'scroll-scorecast-selections')) ? Boolean.parse(parameters['scroll-scorecast-selections'].toString()) : true;
        this._isFirstMarketTypeView = true;
    },
    
    start: function AbstractWarpComponents_AbstractMarketGroupListComponent$start() {
        this.repaint();
    },
    
    repaint: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaint() {
    },
    
    repaintMarketTimeoutEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintMarketTimeoutEventHandler(sender, eventArgs) {
        window.setTimeout(Delegate.create(this, function() {
            this.repaintMarket(eventArgs.parameters.getAsString('idfomarket'), false);
        }), eventArgs.parameters.getAsNumber('timeout'));
    },
    
    repaintMarketEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintMarketEventHandler(sender, eventArgs) {
        this.repaintMarket(eventArgs.parameters.getAsString('idfomarket'), false);
    },
    
    repaintMarketGroupEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintMarketGroupEventHandler(sender, eventArgs) {
        var IDFWMarketGroup = eventArgs.parameters.getAsString('idfwmarketgroup');
        this._log.debug(String.format('RepaintMarketGroup IDFWMarketGroup=[{0}]', IDFWMarketGroup));
        var contentUrl = this._marketGroupContentUrl.replace('${idfwmarketgroup}', IDFWMarketGroup);
        var domID = this._domElementId + '-' + IDFWMarketGroup;
        this._environment.periodicalTransformAndUpdate(domID, contentUrl, this._marketGroupXsltUrl, this.getXsltParameters(false), Delegate.create(this, function() {
            this.transformAndUpdateCallback(domID);
        }), this._domElementId, this._autoRefreshPeriod);
    },
    
    repaintEventScorecastOnLoadEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintEventScorecastOnLoadEventHandler(sender, eventArgs) {
        this.repaintEventScorecast(eventArgs.parameters.getAsString('idfoeventscorecast'), '0', false);
    },
    
    showEventEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$showEventEventHandler(sender, eventArgs) {
        this._log.debug(String.format('ShowEvent IDFOEvent=[{0}] IDFOMarket=[{1}] IDFWMarketGroup=[{2}] ', eventArgs.parameters.getAsString('idfoevent'), null, null));
        this._bettingNavigationService.setEvent(eventArgs.parameters.getAsString('idfoevent'), null, null);
        window.event.returnValue = false;
    },
    
    selectionClickEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$selectionClickEventHandler(sender, eventArgs) {
        this._log.debug('OnSelectionClick');
        if (this._maxSelectionCount > 0) {
            var oCheckBoxElement = eventArgs.domElement;
            if (oCheckBoxElement.checked) {
                var oSelection = this._betSlipService.getSelections();
                if (Object.getKeyCount(oSelection) === this._maxSelectionCount) {
                    oCheckBoxElement.checked = false;
                    this._showMaxSelectionMsg$1();
                    return;
                }
            }
        }
        if (!this._betSlipService.isSelectionIn(eventArgs.parameters.getAsNumber('idfoselection'), null, null)) {
            this._betSlipService.addSelection(eventArgs.parameters.getAsStringArray('pricetype'), null, eventArgs.parameters.getAsNumber('idfoevent'), eventArgs.parameters.getAsString('eventname'), eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsEscapedString('marketname'), eventArgs.parameters.getAsString('mtag'), eventArgs.parameters.getAsString('ttagleft'), eventArgs.parameters.getAsString('ttagright'), eventArgs.parameters.getAsString('ctag'), eventArgs.parameters.getAsBoolean('istrapbettingoptionon'), eventArgs.parameters.getAsString('hadvalue'), eventArgs.parameters.getAsNumber('handicap'), eventArgs.parameters.getAsNumber('upperband'), eventArgs.parameters.getAsNumber('lowerband'), eventArgs.parameters.getAsNumberArray('ewreduction'), eventArgs.parameters.getAsNumberArray('ewplaceterms'), eventArgs.parameters.getAsNumber('idfoselection'), eventArgs.parameters.getAsString('selectionname'), eventArgs.parameters.getAsNumber('priceup'), eventArgs.parameters.getAsNumber('pricedown'), eventArgs.parameters.getAsString('activebettypes'), eventArgs.parameters.getAsStringArray('foprices'), eventArgs.parameters.getAsNumber('selectionhashcode'), eventArgs.parameters.getAsBoolean('istradable'));
        }
        else {
            this._betSlipService.removeSelection(eventArgs.parameters.getAsNumber('idfoselection'));
        }
    },
    
    repaintEventScorecastEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$repaintEventScorecastEventHandler(sender, eventArgs) {
        this.repaintEventScorecast(eventArgs.parameters.getAsString('idfoeventscorecast'), (eventArgs.domElement).value, false);
    },
    
    scorecastSelectionClickEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$scorecastSelectionClickEventHandler(sender, eventArgs) {
        this._log.debug('OnScorecastSelectionClick');
        var selectionCheckBoxElement = this._getScorecastSelectionCheckBoxElement$1(eventArgs.parameters.getAsNumber('idfoeventscorecast'), eventArgs.parameters.getAsNumber('idfoselection1gs'), eventArgs.parameters.getAsNumber('idfoselectioncs'));
        if (!selectionCheckBoxElement) {
            return;
        }
        if (selectionCheckBoxElement.checked) {
            this._betSlipService.addScorecastSelection(eventArgs.parameters.getAsStringArray('idfopricetype'), eventArgs.parameters.getAsNumber('idfoevent'), eventArgs.parameters.getAsString('eventname'), eventArgs.parameters.getAsNumber('idfomarket1gs'), eventArgs.parameters.getAsString('marketname1gs'), eventArgs.parameters.getAsString('mtag'), eventArgs.parameters.getAsString('ttagleft'), eventArgs.parameters.getAsString('ttagright'), eventArgs.parameters.getAsString('ctag'), eventArgs.parameters.getAsNumber('idfoselection1gs'), eventArgs.parameters.getAsString('selectionname1gs'), eventArgs.parameters.getAsNumber('priceup1gs'), eventArgs.parameters.getAsNumber('pricedown1gs'), eventArgs.parameters.getAsNumber('idfoeventscorecast'), eventArgs.parameters.getAsNumber('idfomarketcs'), eventArgs.parameters.getAsString('marketnamecs'), eventArgs.parameters.getAsNumber('idfoselectioncs'), eventArgs.parameters.getAsString('selectionnamecs'), eventArgs.parameters.getAsNumber('priceupcs'), eventArgs.parameters.getAsNumber('pricedowncs'), eventArgs.parameters.getAsNumber('selectionhashcode'), eventArgs.parameters.getAsBoolean('istradable'));
        }
        else {
            this._betSlipService.removeScorecastSelection(eventArgs.parameters.getAsNumber('idfoeventscorecast'), eventArgs.parameters.getAsNumber('idfoselection1gs'), eventArgs.parameters.getAsNumber('idfoselectioncs'));
        }
    },
    
    showCoverageInfoEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$showCoverageInfoEventHandler(sender, eventArgs) {
        var domElement = this._environment.getDomElement(eventArgs.parameters.getAsString('domid'));
        if (domElement) {
            domElement.style.visibility = 'visible';
        }
    },
    
    hideCoverageInfoEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$hideCoverageInfoEventHandler(sender, eventArgs) {
        var domElement = this._environment.getDomElement(eventArgs.parameters.getAsString('domid'));
        if (domElement) {
            domElement.style.visibility = 'hidden';
        }
    },
    
    marketTypeSelectorEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$marketTypeSelectorEventHandler(sender, eventArgs) {
        var IDFOMarketType = eventArgs.parameters.getAsString('idfomarkettype');
        var marketTypeSelector = this.getPrivateDomElement('markettype-selector-' + IDFOMarketType);
        if (marketTypeSelector) {
            if (marketTypeSelector.checked) {
                this._marketTypesSelected.add(IDFOMarketType);
            }
            else {
                this._marketTypesSelected.remove(IDFOMarketType);
            }
        }
        this.toggleMarketTypeGroup(IDFOMarketType);
    },
    
    setMarketEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$setMarketEventHandler(sender, eventArgs) {
        this._bettingNavigationService.setMarketFromEvent(eventArgs.parameters.getAsString('idfomarket'));
        eventArgs.domElement.blur();
        window.event.returnValue = false;
    },
    
    setMarketGroupEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$setMarketGroupEventHandler(sender, eventArgs) {
        var IDFWMarketGroup = eventArgs.parameters.getAsString('idfwmarketgroup');
        this._log.debug(String.format('SetMarketGroup IDFWMarketGroup=[{0}]', IDFWMarketGroup));
        this._bettingNavigationService.setMarketGroup(0, IDFWMarketGroup);
    },
    
    changeRacePoolTabEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$changeRacePoolTabEventHandler(sender, eventArgs) {
        this._racePoolBetSlipService.setRacePoolActiveTab(eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsString('racepooltab'));
        this.setActiveRacePoolTab(eventArgs.parameters.getAsNumber('idfomarket'));
        window.event.returnValue = false;
    },
    
    setRacePoolUnitStakeEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$setRacePoolUnitStakeEventHandler(sender, eventArgs) {
        var element = this._getRacePoolUnitStakeElement$1(eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsString('idfopricetype'));
        if (element) {
            this._racePoolBetSlipService.setRacePoolStake(eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsString('idfopricetype'), eventArgs.parameters.getAsString('racepooltab'), eventArgs.parameters.getAsNumber('minselection'), Number.parse((element).value), eventArgs.parameters.getAsString('racepoolname'));
        }
    },
    
    placeRacePoolBetSlipEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$placeRacePoolBetSlipEventHandler(sender, eventArgs) {
        if (!this._userService.isLoggedIn()) {
            alert('Please log in');
        }
        else {
            var placePriceTypes = [];
            var $enum1 = eventArgs.parameters.getAsStringArray('idfopricetypes').getEnumerator();
            while ($enum1.moveNext()) {
                var priceType = $enum1.get_current();
                if (!String.isNullOrEmpty(priceType)) {
                    var status = this._racePoolBetSlipService.checkRacePoolSelections(eventArgs.parameters.getAsNumber('idfomarket'), priceType);
                    if (String.isNullOrEmpty(status)) {
                        placePriceTypes.add(priceType);
                    }
                    else if (status === 'skip') {
                    }
                    else {
                        alert(status);
                        return;
                    }
                }
            }
            if (placePriceTypes.length > 0) {
                this._racePoolBetSlipService.placeRacePoolBetSlip(eventArgs.parameters.getAsNumber('idfomarket'), placePriceTypes);
            }
            else {
                alert('Please make your selections');
            }
        }
    },
    
    racePoolSelectionClickEventHandler: function AbstractWarpComponents_AbstractMarketGroupListComponent$racePoolSelectionClickEventHandler(sender, eventArgs) {
        var selectionCheckbox = this._getRacePoolSelectionCheckboxElement$1(eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsString('idfopricetype'), eventArgs.parameters.getAsNumber('idfoselection'), eventArgs.parameters.getAsString('selectionplace'));
        if (selectionCheckbox && selectionCheckbox.checked) {
            this._racePoolBetSlipService.addRacePoolSelection(eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsString('idfopricetype'), eventArgs.parameters.getAsString('racepooltab'), eventArgs.parameters.getAsString('selectionplace'), eventArgs.parameters.getAsNumber('minnoselections'), eventArgs.parameters.getAsNumber('idfoevent'), eventArgs.parameters.getAsString('eventname'), eventArgs.parameters.getAsString('marketname'), eventArgs.parameters.getAsString('mtag'), eventArgs.parameters.getAsString('ttagleft'), eventArgs.parameters.getAsString('ttagright'), eventArgs.parameters.getAsString('ctag'), eventArgs.parameters.getAsNumber('idfoselection'), eventArgs.parameters.getAsString('selectionname'));
        }
        else {
            this._racePoolBetSlipService.removeRacePoolSelection(eventArgs.parameters.getAsNumber('idfomarket'), eventArgs.parameters.getAsString('idfopricetype'), eventArgs.parameters.getAsNumber('idfoselection'), eventArgs.parameters.getAsString('selectionplace'));
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractWarpComponents.AbstractNavigationComponent

AbstractWarpComponents.AbstractNavigationComponent = function AbstractWarpComponents_AbstractNavigationComponent() {
    this._currentItem = String.Empty;
    this._currentArea = String.Empty;
    this._topLevelCssClass = String.Empty;
    this._navigationblockparameters = String.Empty;
    AbstractWarpComponents.AbstractNavigationComponent.constructBase(this);
}
AbstractWarpComponents.AbstractNavigationComponent.prototype = {
    _repaintOnUserChanged: false,
    _repaintOnPageFilterChanged: false,
    _protocol: null,
    _activeElement: null,
    _navigationSection: 'primary',
    _navigationService: null,
    _bettingNavigationService: null,
    
    setNavigationService: function AbstractWarpComponents_AbstractNavigationComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
    },
    
    onPageFilterChanged: function AbstractWarpComponents_AbstractNavigationComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        if (this._repaintOnPageFilterChanged) {
            this.update();
        }
        else {
            this.setActiveElement();
        }
    },
    
    _userService: null,
    
    setUserService: function AbstractWarpComponents_AbstractNavigationComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    onUserChanged: function AbstractWarpComponents_AbstractNavigationComponent$onUserChanged(eventSource) {
        this._log.debug('OnUserChanged');
        if (this._repaintOnUserChanged) {
            this.update();
        }
    },
    
    setBettingNavigationService: function AbstractWarpComponents_AbstractNavigationComponent$setBettingNavigationService(bettingNavigationService) {
        this._log.debug('SetBettingNavigationService');
        this._bettingNavigationService = bettingNavigationService;
    },
    
    executeActionEventHandler: function AbstractWarpComponents_AbstractNavigationComponent$executeActionEventHandler(sender, eventArgs) {
        eval(eventArgs.parameters.getAsString('action'));
    },
    
    setPageFilterEventHandler: function AbstractWarpComponents_AbstractNavigationComponent$setPageFilterEventHandler(sender, eventArgs) {
        this.setPageFilter(eventArgs.domElement.parentNode, eventArgs.parameters.getAsString('area'), eventArgs.parameters.getAsBoolean('preservequerystring'));
        window.event.returnValue = false;
    },
    
    togglePartWithVisibleStyleNameEventHandler: function AbstractWarpComponents_AbstractNavigationComponent$togglePartWithVisibleStyleNameEventHandler(sender, eventArgs) {
        this.togglePartWithVisibleStyleName(eventArgs.domElement, eventArgs.parameters.getAsString('componentid'), eventArgs.parameters.getAsString('visiblestylename'));
        window.event.returnValue = false;
    },
    
    showElementEventHandler: function AbstractWarpComponents_AbstractNavigationComponent$showElementEventHandler(sender, eventArgs) {
        this._environment.getDomElement(eventArgs.parameters.getAsString('elementid')).style.display = 'block';
    },
    
    hideElementEventHandler: function AbstractWarpComponents_AbstractNavigationComponent$hideElementEventHandler(sender, eventArgs) {
        this._environment.getDomElement(eventArgs.parameters.getAsString('elementid')).style.display = 'none';
    },
    
    get_isComponentVisible: function AbstractWarpComponents_AbstractNavigationComponent$get_isComponentVisible() {
        var navtypes = null;
        if (this._bettingNavigationService.getNavigationTypes()) {
            navtypes = this._bettingNavigationService.getNavigationTypes().split(',');
        }
        return (this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction()) && this.isNavigationTypesInAValidCombination(navtypes));
    },
    
    getXsltParameters: function AbstractWarpComponents_AbstractNavigationComponent$getXsltParameters(contextObject) {
        var useService = (!contextObject) ? true : contextObject;
        var xsltParameters = {};
        xsltParameters['component-instance-name'] = this._componentInstanceName;
        xsltParameters['component-dom-element-id'] = this._domElementId;
        xsltParameters['username'] = (useService && this._userService.isLoggedIn()) ? this._userService.get_username() : null;
        xsltParameters['navigation-section'] = this._navigationSection;
        xsltParameters['top-level-css-class'] = this._topLevelCssClass;
        xsltParameters['current-item'] = this._currentItem;
        xsltParameters['navigationblock-parameters'] = this._navigationblockparameters;
        xsltParameters['current-action'] = this._navigationService.getAction();
        xsltParameters['current-area'] = this._navigationService.getPageArea();
        return xsltParameters;
    },
    
    init: function AbstractWarpComponents_AbstractNavigationComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._repaintOnUserChanged = Boolean.parse(parameters['repaint-onuserchanged']);
        this._repaintOnPageFilterChanged = Boolean.parse(parameters['repaint-onpagefilterchanged']);
        this._protocol = parameters['protocol'];
        this._topLevelCssClass = parameters['top-level-css-class'];
        if ((parameters['navigation-section']) !== '') {
            this._navigationSection = parameters['navigation-section'];
        }
        if ((parameters['current-item']) !== '') {
            this._currentItem = parameters['current-item'];
        }
        if ((parameters['navigationblock-parameters']) !== '') {
            this._navigationblockparameters = parameters['navigationblock-parameters'];
        }
    },
    
    renderComplete: function AbstractWarpComponents_AbstractNavigationComponent$renderComplete(eventArgs) {
        if (eventArgs.get_customEventArgs() && eventArgs.get_customEventArgs().parametersDictionary['RepaintForAdmin']) {
            return;
        }
        this.setActiveElement();
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE && ScriptFX.Application.current.get_host().get_majorVersion() < 7) {
            Framework.ADxMenu.ieSetup();
        }
    },
    
    setActiveElement: function AbstractWarpComponents_AbstractNavigationComponent$setActiveElement() {
        var action = this._navigationService.getAction();
        if (String.isNullOrEmpty(action)) {
            action = String.Empty;
        }
        var liElements = this._environment.getDomElement(this._domElementId).getElementsByTagName('LI');
        this.deactivateElement();
        for (var i = 0; i < liElements.length; i++) {
            var liElement = liElements[i];
            if (liElement.attributes.getNamedItem('action') && liElement.attributes.getNamedItem('action').value === action) {
                this.activateElement(liElement);
                break;
            }
        }
    },
    
    repaintForAdmin: function AbstractWarpComponents_AbstractNavigationComponent$repaintForAdmin() {
        var customEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs();
        customEventArgs.parametersDictionary['RepaintForAdmin'] = true;
        this.update(this._environment.getDomElement(this._domElementId), this._parameters.get_contentUrl(), this._parameters.get_xsltUrl(), this.getXsltParameters(false), customEventArgs);
        AbstractWarpComponents.AbstractNavigationComponent.callBase(this, 'disableForAdmin');
    },
    
    setPageFilter: function AbstractWarpComponents_AbstractNavigationComponent$setPageFilter(liElement, area, preserveQueryString) {
        if (liElement.tagName !== 'LI') {
            throw new Error('Expected an LI element');
        }
        this.deactivateElement();
        this.activateElement(liElement);
        var pageFilter = {};
        if (preserveQueryString) {
            pageFilter = this._navigationService.getPageFilter();
        }
        pageFilter['action'] = liElement.attributes.getNamedItem('action').value;
        this._log.debug('SetPageFilter');
        this._navigationService.goTo(area, pageFilter);
        return false;
    },
    
    activateElement: function AbstractWarpComponents_AbstractNavigationComponent$activateElement(liElement) {
        this._activeElement = liElement;
        this._activeElement.className += ' cur';
        this._currentItem = liElement.attributes.getNamedItem('action').value;
    },
    
    deactivateElement: function AbstractWarpComponents_AbstractNavigationComponent$deactivateElement() {
        if (this._activeElement) {
            this._activeElement.className = this._activeElement.className.replace('cur', '');
            this._activeElement = null;
            this._currentItem = String.Empty;
        }
    },
    
    togglePart: function AbstractWarpComponents_AbstractNavigationComponent$togglePart(parId, componentId) {
        this.togglePartWithVisibleStyleName(parId, componentId, 'block');
    },
    
    togglePartWithVisibleStyleName: function AbstractWarpComponents_AbstractNavigationComponent$togglePartWithVisibleStyleName(parId, componentId, visibleStyleName) {
        var el = document.getElementById(componentId);
        if (el.style.display === visibleStyleName || el.style.display.length < 1) {
            el.style.display = 'none';
            (parId).innerText = (parId).innerText.replace('Close', 'Open');
            Framework.CookieUtil.setCookie(componentId, 'none');
        }
        else {
            el.style.display = visibleStyleName;
            (parId).innerText = (parId).innerText.replace('Open', 'Close');
            Framework.CookieUtil.setCookie(componentId, visibleStyleName);
        }
    }
}


AbstractWarpComponents.AbstractMarketGroupListComponent.createClass('AbstractWarpComponents.AbstractMarketGroupListComponent', Framework.Component.AbstractComponent, NavigationService.IPageFilterChangedListener, BetSlipService.ISelectionsAddedListener, BetSlipService.ISelectionsRemovedListener, FixedOddsBettingService.IOddsTypeChangedListener, RacePoolBetSlipService.IRacePoolSelectionsAddedListener, RacePoolBetSlipService.IRacePoolSelectionsRemovedListener, RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener);
AbstractWarpComponents.AbstractNavigationComponent.createClass('AbstractWarpComponents.AbstractNavigationComponent', Framework.Component.AbstractXsltBasedComponent, UserService.IUserChangedListener, NavigationService.IPageFilterChangedListener);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('DGEService');

////////////////////////////////////////////////////////////////////////////////
// DGEService.IDGENotificationListener

DGEService.IDGENotificationListener = function() { };
DGEService.IDGENotificationListener.prototype = {
    onDGENotification : null
}
DGEService.IDGENotificationListener.createInterface('DGEService.IDGENotificationListener');


////////////////////////////////////////////////////////////////////////////////
// DGEService.DGENotificationEvent

DGEService.DGENotificationEvent = function() { };
DGEService.DGENotificationEvent.prototype = {
    noT_ENOUGH_MONEY_ON_PLACE_WAGER: 1, 
    oN_ADD_FAVORITES: 2
}
DGEService.DGENotificationEvent.createEnum('DGEService.DGENotificationEvent', false);


////////////////////////////////////////////////////////////////////////////////
// DGEService.IResultsFiltersChangedListener

DGEService.IResultsFiltersChangedListener = function() { };
DGEService.IResultsFiltersChangedListener.prototype = {
    onResultsFiltersChanged : null
}
DGEService.IResultsFiltersChangedListener.createInterface('DGEService.IResultsFiltersChangedListener');


////////////////////////////////////////////////////////////////////////////////
// DGEService.BoardStackInfo

DGEService.BoardStackInfo = function DGEService_BoardStackInfo() {
}
DGEService.BoardStackInfo.prototype = {
    AddOnIndex: null,
    SeriesId: null,
    SeriesName: null,
    GameId: null,
    GameName: null,
    PickValues: null,
    Boards: null,
    Events: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.BoardInfo

DGEService.BoardInfo = function DGEService_BoardInfo() {
}
DGEService.BoardInfo.prototype = {
    PickSystem: null,
    PickSystemName: null,
    QuickPick: false,
    PickValues: null,
    Stake: 0,
    Rows: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.BoardRowInfo

DGEService.BoardRowInfo = function DGEService_BoardRowInfo() {
}
DGEService.BoardRowInfo.prototype = {
    DrawId: null,
    DrawName: null,
    PickSystemId: null,
    PickSystemName: null,
    Stake: 0
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.DGENotification

DGEService.DGENotification = function DGEService_DGENotification(notificationEvent) {
    this._notificationEvent = notificationEvent;
}
DGEService.DGENotification.prototype = {
    _notificationEvent: 0,
    
    get_notificationEvent: function DGEService_DGENotification$get_notificationEvent() {
        return this._notificationEvent;
    },
    
    getNotificationEventName: function DGEService_DGENotification$getNotificationEventName() {
        return Enum.toString(DGEService.DGENotificationEvent, this._notificationEvent).toUpperCase();
    }
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.ResultsFilters

DGEService.ResultsFilters = function DGEService_ResultsFilters() {
}
DGEService.ResultsFilters.prototype = {
    
    setResultsFilters: function DGEService_ResultsFilters$setResultsFilters(gameID, gameName, searchDate, searchNumbers, searchDraw, SearchType) {
        DGEService.ResultsFilters._searchGameID = gameID;
        DGEService.ResultsFilters._searchGameName = gameName;
        DGEService.ResultsFilters._searchDate = searchDate;
        DGEService.ResultsFilters._searchNumbers = searchNumbers;
        DGEService.ResultsFilters._searchDraw = searchDraw;
        DGEService.ResultsFilters._typeOfSearch = SearchType;
    },
    
    get_gameFilter: function DGEService_ResultsFilters$get_gameFilter() {
        return DGEService.ResultsFilters._searchGameID;
    },
    
    get_gameName: function DGEService_ResultsFilters$get_gameName() {
        return DGEService.ResultsFilters._searchGameName;
    },
    
    get_resultsSearchDate: function DGEService_ResultsFilters$get_resultsSearchDate() {
        return DGEService.ResultsFilters._searchDate;
    },
    
    get_resultsSearchNumbers: function DGEService_ResultsFilters$get_resultsSearchNumbers() {
        return DGEService.ResultsFilters._searchNumbers;
    },
    
    get_resultsSearchDraw: function DGEService_ResultsFilters$get_resultsSearchDraw() {
        return DGEService.ResultsFilters._searchDraw;
    },
    
    get_resultsSearchType: function DGEService_ResultsFilters$get_resultsSearchType() {
        return DGEService.ResultsFilters._typeOfSearch;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.SubscriptionConditionInfo

DGEService.SubscriptionConditionInfo = function DGEService_SubscriptionConditionInfo() {
}
DGEService.SubscriptionConditionInfo.prototype = {
    ParameterName: null,
    Condition: null,
    Value: null,
    Value2: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.EventInfo

DGEService.EventInfo = function DGEService_EventInfo() {
}
DGEService.EventInfo.prototype = {
    DrawNumber: 0,
    State: null,
    Name: null,
    Parameters: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.GameAddOnInfo

DGEService.GameAddOnInfo = function DGEService_GameAddOnInfo() {
}
DGEService.GameAddOnInfo.prototype = {
    AddOnGameId: null,
    Optional: false
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.GameInfo

DGEService.GameInfo = function DGEService_GameInfo() {
}
DGEService.GameInfo.prototype = {
    ExternalId: null,
    GameTypeId: null,
    GameTypeName: null,
    Name: null,
    Description: null,
    State: null,
    Parameters: null,
    AddOns: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.FavoriteBoard

DGEService.FavoriteBoard = function DGEService_FavoriteBoard() {
}
DGEService.FavoriteBoard.prototype = {
    AddOnIndex: null,
    SeriesId: null,
    GameId: null,
    GameName: null,
    Rows: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.FavoriteBoardRow

DGEService.FavoriteBoardRow = function DGEService_FavoriteBoardRow() {
}
DGEService.FavoriteBoardRow.prototype = {
    PickSystem: null,
    PickSystemName: null,
    QuickPick: false,
    PickValues: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.FavoriteWager

DGEService.FavoriteWager = function DGEService_FavoriteWager() {
}
DGEService.FavoriteWager.prototype = {
    GameId: null,
    GameName: null,
    FavoriteWagerId: 0,
    Alias: null,
    IsDefault: false,
    EditionCount: 0,
    BoardStacks: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.WagerInfo

DGEService.WagerInfo = function DGEService_WagerInfo() {
}
DGEService.WagerInfo.prototype = {
    Id: 0,
    State: null,
    Game: null,
    CustomerId: 0,
    AccountId: null,
    TotalStake: 0,
    TotalWinAmount: 0,
    TotalWinTax: 0,
    EditionCount: 0,
    SubscriptionId: 0,
    ModifiedByUserId: 0,
    AttemptTime: null,
    PlaceReference: null,
    StakeReference: null,
    PlaceTime: null,
    CancelReference: null,
    CancelTime: null,
    BoardStacks: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.FundingType

DGEService.FundingType = function DGEService_FundingType() {
}
DGEService.FundingType.prototype = {
    FundingTypeId: null,
    Name: null,
    enabled: true
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.SubscriptionEventInfo

DGEService.SubscriptionEventInfo = function DGEService_SubscriptionEventInfo() {
}
DGEService.SubscriptionEventInfo.prototype = {
    EventId: 0,
    Type: null,
    FundingAmount: 0,
    GameId: null,
    Wager: null,
    Message: null,
    Created: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.SubscriptionInfo

DGEService.SubscriptionInfo = function DGEService_SubscriptionInfo() {
    DGEService.SubscriptionInfo.constructBase(this);
}
DGEService.SubscriptionInfo.prototype = {
    SubscriptionId: 0,
    State: null,
    GameId: null,
    GameName: null,
    LeftEditions: 0,
    Created: null,
    LastModified: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.SubscriptionRequest

DGEService.SubscriptionRequest = function DGEService_SubscriptionRequest() {
}
DGEService.SubscriptionRequest.prototype = {
    StartTime: null,
    ExpiryTime: null,
    TotalEditions: null,
    FundingType: null,
    LockFunds: false,
    PaymentInstrumentId: 0,
    SchedulePeriod: null,
    ScheduleOffset: 0,
    BoardStacks: null,
    Conditions: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.WagerRequest

DGEService.WagerRequest = function DGEService_WagerRequest() {
}
DGEService.WagerRequest.prototype = {
    EditionCount: 0,
    FromSubscription: false,
    BoardStacks: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.CancelWagerResult

DGEService.CancelWagerResult = function DGEService_CancelWagerResult() {
}
DGEService.CancelWagerResult.prototype = {
    CancelReference: null,
    State: null,
    ErrorMessage: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.WagerResult

DGEService.WagerResult = function DGEService_WagerResult() {
}
DGEService.WagerResult.prototype = {
    WagerId: 0,
    WagerReference: null,
    State: null,
    ErrorMessage: null,
    BoardStacks: null
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.DGEService

DGEService.DGEService = function DGEService_DGEService() {
    this._resultsFiltersChangedListener$1 = new Framework.ListenerInvoker(true);
    this._dgeNotificationListeners$1 = new Framework.ListenerInvoker(true);
    DGEService.DGEService.constructBase(this);
}
DGEService.DGEService.prototype = {
    _userService$1: null,
    
    setUserService: function DGEService_DGEService$setUserService(userService) {
        DGEService.DGEService._log$1.debug('SetUserService');
        this._userService$1 = userService;
    },
    
    _accountService$1: null,
    
    setAccountService: function DGEService_DGEService$setAccountService(accountService) {
        DGEService.DGEService._log$1.debug('SetAccountService');
        this._accountService$1 = accountService;
    },
    
    registerResultsFiltersChangedListener: function DGEService_DGEService$registerResultsFiltersChangedListener(resultsFiltersChangedListener) {
        DGEService.DGEService._log$1.debug('RegisterResultsFiltersChangedListener');
        this._resultsFiltersChangedListener$1.registerListener(resultsFiltersChangedListener);
    },
    
    unregisterResultsFiltersChangedListener: function DGEService_DGEService$unregisterResultsFiltersChangedListener(resultsFiltersChangedListener) {
        DGEService.DGEService._log$1.debug('UnregisterResultsFiltersChangedListener');
        this._resultsFiltersChangedListener$1.unregisterListener(resultsFiltersChangedListener);
    },
    
    _fireResultsFiltersChangedEvent$1: function DGEService_DGEService$_fireResultsFiltersChangedEvent$1() {
        DGEService.DGEService._log$1.debug('FireResultsFiltersChangedEvent');
        this._resultsFiltersChangedListener$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onResultsFiltersChanged(this);
        }));
    },
    
    registerDGENotificationListener: function DGEService_DGEService$registerDGENotificationListener(dgeNotificationListener) {
        DGEService.DGEService._log$1.debug('RegisterDGENotificationListener');
        this._dgeNotificationListeners$1.registerListener(dgeNotificationListener);
    },
    
    unregisterDGENotificationListener: function DGEService_DGEService$unregisterDGENotificationListener(dgeNotificationListener) {
        DGEService.DGEService._log$1.debug('UnregisterDGENotificationListener');
        this._dgeNotificationListeners$1.unregisterListener(dgeNotificationListener);
    },
    
    _fireDGENotificationEvent$1: function DGEService_DGEService$_fireDGENotificationEvent$1(notificationEvent) {
        DGEService.DGEService._log$1.debug('FireDGENotificationEvent');
        this._dgeNotificationListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onDGENotification(new DGEService.DGENotification(notificationEvent));
        }));
    },
    
    init: function DGEService_DGEService$init(environment, parameters) {
        DGEService.DGEService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        DGEService.DGEService.callBase(this, 'init', [ environment, parameters ]);
    },
    
    start: function DGEService_DGEService$start() {
        DGEService.DGEService._log$1.debug('Start');
    },
    
    placeWager: function DGEService_DGEService$placeWager(successCallback, failureCallback, wager) {
        DGEService.DGEService._log$1.debug(String.format('placeWager wager [{0}]', wager));
        if (!this._checkEnoughMoneyToPlaceWager$1(wager)) {
            this._fireDGENotificationEvent$1(DGEService.DGENotificationEvent.noT_ENOUGH_MONEY_ON_PLACE_WAGER);
            failureCallback.invoke(null);
            return;
        }
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'placeWager', { wager: wager }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('placeWager exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    _checkEnoughMoneyToPlaceWager$1: function DGEService_DGEService$_checkEnoughMoneyToPlaceWager$1(wager) {
        var totalStake = 0;
        var $enum1 = wager.BoardStacks.getEnumerator();
        while ($enum1.moveNext()) {
            var boardStackInfo = $enum1.get_current();
            var $enum2 = boardStackInfo.Boards.getEnumerator();
            while ($enum2.moveNext()) {
                var boardInfo = $enum2.get_current();
                totalStake += boardInfo.Stake;
            }
        }
        return this._accountService$1.get_creditAccountDetails().TradingBalance >= totalStake;
    },
    
    cancelWager: function DGEService_DGEService$cancelWager(successCallback, failureCallback, wagerReference) {
        DGEService.DGEService._log$1.debug(String.format('cancelWager wagerReference [{0}]', wagerReference));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'cancelWager', { wagerReference: wagerReference }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('cancelWager exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    getWagerByWagerReference: function DGEService_DGEService$getWagerByWagerReference(successCallback, failureCallback, wagerReference) {
        DGEService.DGEService._log$1.debug(String.format('getWagerByWagerReference wagerReference:{0}', wagerReference));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getWagerByWagerReference', { wagerReference: wagerReference }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('deleteFavoriteWager exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    createSubscription: function DGEService_DGEService$createSubscription(successCallback, failureCallback, request) {
        DGEService.DGEService._log$1.debug(String.format('createSubscription subscriptionRequest [{0}]', request));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'createSubscription', { request: request }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('createSubscription exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    updateSubscription: function DGEService_DGEService$updateSubscription(successCallback, failureCallback, subscriptionId, request) {
        DGEService.DGEService._log$1.debug(String.format('updateSubscription subscriptionId [{0}] subscriptionRequest [{1}]', subscriptionId, request));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'updateSubscription', { subscriptionId: subscriptionId, request: request }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('updateSubscription exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    suspendSubscription: function DGEService_DGEService$suspendSubscription(successCallback, failureCallback, subscriptionId) {
        DGEService.DGEService._log$1.debug(String.format('suspendSubscription subscriptionId [{0}]', subscriptionId));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'suspendSubscription', { subscriptionId: subscriptionId }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('suspendSubscription exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    resumeSubscription: function DGEService_DGEService$resumeSubscription(successCallback, failureCallback, subscriptionId) {
        DGEService.DGEService._log$1.debug(String.format('unsuspendSubscription subscriptionId [{0}]', subscriptionId));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'resumeSubscription', { subscriptionId: subscriptionId }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('resumeSubscription exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    deleteSubscription: function DGEService_DGEService$deleteSubscription(successCallback, failureCallback, subscriptionId) {
        DGEService.DGEService._log$1.debug(String.format('deleteSubscription subscriptionId [{0}]', subscriptionId));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'deleteSubscription', { subscriptionId: subscriptionId }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('deleteSubscription exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    getSubscriptions: function DGEService_DGEService$getSubscriptions(successCallback, failureCallback) {
        DGEService.DGEService._log$1.debug(String.format('getSubscriptions'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getSubscriptions', {}, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('getSubscriptions exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    getSubscriptionEvents: function DGEService_DGEService$getSubscriptionEvents(successCallback, failureCallback, subscriptionId) {
        DGEService.DGEService._log$1.debug(String.format('getSubscriptionEvents for subscription {0}', subscriptionId));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getSubscriptionEvents', { subscriptionId: subscriptionId }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('getSubscriptionEvents exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    getPaymentInstrumentsForDgSubscriptions: function DGEService_DGEService$getPaymentInstrumentsForDgSubscriptions(successCallback, failureCallback, fundingTypeId) {
        DGEService.DGEService._log$1.debug(String.format('getPaymentInstrumentsForDgSubscriptions'));
        if (fundingTypeId === 'MANUAL') {
            successCallback.invoke({});
        }
        else {
            this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getPaymentInstrumentsForDgSubscriptions', { fundingTypeId: fundingTypeId }, Delegate.create(this, function(result) {
                successCallback.invoke(result);
            }), Delegate.create(this, function(exception) {
                DGEService.DGEService._log$1.debug('getPaymentInstrumentsForDgSubscriptions exception ' + exception.message);
                if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                    this._userService$1.handleSessionTimeout(exception);
                }
                else {
                    failureCallback.invoke(exception);
                }
            }));
        }
    },
    
    getFundingTypes: function DGEService_DGEService$getFundingTypes(successCallback, failureCallback) {
        DGEService.DGEService._log$1.debug(String.format('getPaymentInstrumentsForDgSubscriptions'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getFundingTypes', {}, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('getFundingTypes exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    getFavoriteWagersForGames: function DGEService_DGEService$getFavoriteWagersForGames(successCallback, failureCallback, externalGameIds) {
        DGEService.DGEService._log$1.debug(String.format('getFavoriteWagersForGames'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getFavoriteWagersForGames', { externalGameIds: externalGameIds }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('getFavoriteWagersForGames exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    createFavoriteWager: function DGEService_DGEService$createFavoriteWager(successCallback, failureCallback, wager) {
        DGEService.DGEService._log$1.debug(String.format('createFavoriteWager'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'createFavoriteWager', { wagerRequest: wager }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this._fireDGENotificationEvent$1(DGEService.DGENotificationEvent.oN_ADD_FAVORITES);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('createFavoriteWager exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    updateDefaultFavoriteWager: function DGEService_DGEService$updateDefaultFavoriteWager(successCallback, failureCallback, wager) {
        DGEService.DGEService._log$1.debug(String.format('updateDefaultFavoriteWager'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'updateDefaultFavoriteWager', { wagerId: wager.FavoriteWagerId, isDefault: wager.IsDefault, alias: wager.Alias }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('updateDefaultFavoriteWager exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    deleteFavoriteWager: function DGEService_DGEService$deleteFavoriteWager(successCallback, failureCallback, wagerFavoriteId) {
        DGEService.DGEService._log$1.debug(String.format('deleteFavoriteWager wagerFavoriteId={0}', wagerFavoriteId));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'deleteFavoriteWager', { wagerFavoriteId: wagerFavoriteId }, successCallback, Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('deleteFavoriteWager exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    getHypotheticalWinnings: function DGEService_DGEService$getHypotheticalWinnings(successCallback, failureCallback, externalId, pickValues, drawNumber, drawDate, criteria) {
        DGEService.DGEService._log$1.debug(String.format('getHypotheticalWinnings externalId:{0}, pickValues:{1}, drawNumber:{2}, criteria:{3}', externalId, pickValues, drawNumber, criteria));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'getHypotheticalWinnings', { externalId: externalId, pickValues: pickValues, drawNumber: drawNumber, drawDate: drawDate, criteria: criteria }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('getHypotheticalWinnings exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    setResultsSearchFilters: function DGEService_DGEService$setResultsSearchFilters(gameID, gameName, searchDate, searchNumbers, searchDraw, searchType) {
        var oFilters = new DGEService.ResultsFilters();
        oFilters.setResultsFilters(gameID, gameName, searchDate, searchNumbers, searchDraw, searchType);
        this._fireResultsFiltersChangedEvent$1();
    },
    
    quickPick: function DGEService_DGEService$quickPick(successCallback, failureCallback, boardStackInfo) {
        DGEService.DGEService._log$1.debug(String.format('quickPick'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'quickPick', { boardStackInfo: boardStackInfo }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('quickPick exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    fullQuickPick: function DGEService_DGEService$fullQuickPick(successCallback, failureCallback, boardStackInfo) {
        DGEService.DGEService._log$1.debug(String.format('fullQuickPick'));
        this._environment.invokeAsync(DGEService.DGEService._serviceName$1, 'fullQuickPick', { boardStackInfo: boardStackInfo }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            DGEService.DGEService._log$1.debug('fullQuickPick exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService$1.handleSessionTimeout(exception);
            }
            else {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    mockQuickPick: function DGEService_DGEService$mockQuickPick(successCallback, failureCallback, boardStackInfo) {
        for (var b = 0; b < boardStackInfo.Boards.length; b++) {
            if (isNullOrUndefined(boardStackInfo.Boards[b])) {
                continue;
            }
            var boardInfo = boardStackInfo.Boards[b];
            var boardResultValues = '';
            var setValues = boardInfo.PickValues.split(':');
            for (var s = 0; s < setValues.length; s++) {
                if (s > 0) {
                    boardResultValues += ':';
                }
                var numberValues = setValues[s].split(',');
                for (var n = 0; n < numberValues.length; n++) {
                    if (numberValues[n] === 'QP') {
                        var max = 33;
                        var nr;
                        while (true) {
                            nr = (Math.floor(Math.random() * max + 1)).toString();
                            if (!numberValues.contains(nr)) {
                                break;
                            }
                        }
                        numberValues[n] = nr;
                    }
                    if (n > 0) {
                        boardResultValues += ',';
                    }
                    boardResultValues += numberValues[n];
                }
            }
            boardInfo.PickValues = boardResultValues;
        }
        successCallback.invoke(boardStackInfo);
    }
}


////////////////////////////////////////////////////////////////////////////////
// DGEService.WinningInfo

DGEService.WinningInfo = function DGEService_WinningInfo() {
}
DGEService.WinningInfo.prototype = {
    DrawDate: null,
    DrawName: null,
    ResultValues: null,
    ResultBonusValues: null,
    DrawNumber: 0,
    DrawId: null,
    DivisionLevel: 0,
    DivisionName: null,
    Shares: 0,
    Prize: null
}


DGEService.BoardStackInfo.createClass('DGEService.BoardStackInfo');
DGEService.BoardInfo.createClass('DGEService.BoardInfo');
DGEService.BoardRowInfo.createClass('DGEService.BoardRowInfo');
DGEService.DGENotification.createClass('DGEService.DGENotification');
DGEService.ResultsFilters.createClass('DGEService.ResultsFilters');
DGEService.SubscriptionConditionInfo.createClass('DGEService.SubscriptionConditionInfo');
DGEService.EventInfo.createClass('DGEService.EventInfo');
DGEService.GameAddOnInfo.createClass('DGEService.GameAddOnInfo');
DGEService.GameInfo.createClass('DGEService.GameInfo');
DGEService.FavoriteBoard.createClass('DGEService.FavoriteBoard');
DGEService.FavoriteBoardRow.createClass('DGEService.FavoriteBoardRow');
DGEService.FavoriteWager.createClass('DGEService.FavoriteWager');
DGEService.WagerInfo.createClass('DGEService.WagerInfo');
DGEService.FundingType.createClass('DGEService.FundingType');
DGEService.SubscriptionEventInfo.createClass('DGEService.SubscriptionEventInfo');
DGEService.SubscriptionRequest.createClass('DGEService.SubscriptionRequest');
DGEService.SubscriptionInfo.createClass('DGEService.SubscriptionInfo', DGEService.SubscriptionRequest);
DGEService.WagerRequest.createClass('DGEService.WagerRequest');
DGEService.CancelWagerResult.createClass('DGEService.CancelWagerResult');
DGEService.WagerResult.createClass('DGEService.WagerResult');
DGEService.DGEService.createClass('DGEService.DGEService', Framework.AbstractService);
DGEService.WinningInfo.createClass('DGEService.WinningInfo');
DGEService.ResultsFilters._searchGameID = null;
DGEService.ResultsFilters._searchGameName = null;
DGEService.ResultsFilters._searchDate = null;
DGEService.ResultsFilters._searchNumbers = null;
DGEService.ResultsFilters._searchDraw = null;
DGEService.ResultsFilters._typeOfSearch = null;
DGEService.DGEService._serviceName$1 = 'DGEService';
DGEService.DGEService._log$1 = Framework.Logger.getLog(DGEService.DGEService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BoletoService');

////////////////////////////////////////////////////////////////////////////////
// BoletoService.IBoletoCtxListener

BoletoService.IBoletoCtxListener = function() { };
BoletoService.IBoletoCtxListener.prototype = {
    onBoletoContentChanged : null,
    onBoletoAction : null,
    onBoletoMessageEvent : null,
    onBoletoStateChanged : null
}
BoletoService.IBoletoCtxListener.createInterface('BoletoService.IBoletoCtxListener');


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoViewState

BoletoService.BoletoViewState = function() { };
BoletoService.BoletoViewState.prototype = {
    INPUT: 1, 
    CONFIRMATION: 2, 
    RESULT: 3
}
BoletoService.BoletoViewState.createEnum('BoletoService.BoletoViewState', false);


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoMessageType

BoletoService.BoletoMessageType = function() { };
BoletoService.BoletoMessageType.prototype = {
    ACCEPTED: 1, 
    INFO: 2, 
    WARNING: 3, 
    ERROR: 4
}
BoletoService.BoletoMessageType.createEnum('BoletoService.BoletoMessageType', false);


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoService

BoletoService.BoletoService = function BoletoService_BoletoService() {
    this._boletoContentChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._boletoActionListeners$1 = new Framework.ListenerInvoker(true);
    this._boletoMessageListeners$1 = new Framework.ListenerInvoker(true);
    this._boletoStateChangedListener$1 = new Framework.ListenerInvoker(true);
    BoletoService.BoletoService.constructBase(this);
}
BoletoService.BoletoService.prototype = {
    _navigationService: null,
    _userService: null,
    _accountService: null,
    _dgeService: null,
    _boletoContext$1: null,
    
    get_boletoContext: function BoletoService_BoletoService$get_boletoContext() {
        return this._boletoContext$1;
    },
    
    setNavigationService: function BoletoService_BoletoService$setNavigationService(navigationService) {
        BoletoService.BoletoService._log$1.debug('SetNavigationService');
        this._navigationService = navigationService;
    },
    
    setUserService: function BoletoService_BoletoService$setUserService(userService) {
        BoletoService.BoletoService._log$1.debug('SetUserService');
        this._userService = userService;
    },
    
    setAccountService: function BoletoService_BoletoService$setAccountService(accountService) {
        BoletoService.BoletoService._log$1.debug('AccountService');
        this._accountService = accountService;
    },
    
    setDGEService: function BoletoService_BoletoService$setDGEService(dgeService) {
        BoletoService.BoletoService._log$1.debug('DGEService');
        this._dgeService = dgeService;
    },
    
    onPageWillChange: function BoletoService_BoletoService$onPageWillChange() {
        BoletoService.BoletoService._log$1.debug('OnPageWillChange');
        this._environment.storeState(BoletoService.BoletoService._serviceName$1, this._getState$1());
    },
    
    onUserChanged: function BoletoService_BoletoService$onUserChanged(eventSource) {
        if (!this._userService.isLoggedIn()) {
            this._clearState$1();
            this.reset();
        }
    },
    
    init: function BoletoService_BoletoService$init(environment, parameters) {
        BoletoService.BoletoService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        BoletoService.BoletoService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var _state = this._environment.getStoredState(BoletoService.BoletoService._serviceName$1);
        if (_state) {
            this._setState(_state);
        }
        else {
            this._boletoContext$1 = new BoletoService.BoletoContext();
        }
    },
    
    start: function BoletoService_BoletoService$start() {
        BoletoService.BoletoService._log$1.debug('Start');
        this._userService.registerUserChangedListener(this);
    },
    
    initBoletoData: function BoletoService_BoletoService$initBoletoData(data, messages) {
        BoletoService.BoletoService._log$1.debug('InitBoletoContext');
        if (isNullOrUndefined(this._boletoContext$1)) {
            this._boletoContext$1 = new BoletoService.BoletoContext();
        }
        this._boletoContext$1.numberLength = data.numberLength;
        this._boletoContext$1.randomCount = data.randomCount;
        this._boletoContext$1.fractionsCount = data.fractionsCount;
        this._boletoContext$1.externalId = data.externalid;
        this._boletoContext$1.seriesId = data.seriesid;
        this._boletoContext$1.drawId = data.drawid;
        this._boletoContext$1.priceBase = data.priceBase;
        this._boletoContext$1.priceMax = data.priceMax;
        this._boletoContext$1._gameEvents = data.gameEvents;
        this._boletoContext$1._gameDraws = data.gameDraws;
        this._boletoContext$1._pickSystemMap = data.pickSystemMap;
        this._boletoContext$1._messages = messages;
        this._boletoContext$1.fetchingNumber = false;
        this._boletoContext$1.fetchingRandomNumbers = false;
        this._boletoContext$1.fetchingPlaceWager = false;
        if (this._userService.isLoggedIn()) {
            this.getRandomNumbers(false);
        }
    },
    
    play: function BoletoService_BoletoService$play(externalGameId, state) {
        this._environment.storeState('explicitComponentState', state);
        var areaName = this._parameters['play-area'];
        var areaAction = this._parameters['play-action'];
        var oDictionary = {};
        oDictionary['action'] = areaAction;
        this._navigationService.goTo(areaName, oDictionary);
    },
    
    _getState$1: function BoletoService_BoletoService$_getState$1() {
        return this._boletoContext$1._getState();
    },
    
    _setState: function BoletoService_BoletoService$_setState(state) {
        if (isNullOrUndefined(this._boletoContext$1)) {
            this._boletoContext$1 = new BoletoService.BoletoContext();
        }
        try {
            var wagerInfo = this._environment.getStoredState('explicitComponentState');
            if (!isNullOrUndefined(wagerInfo)) {
                this._boletoContext$1._mergeState(wagerInfo);
                this.searchNumberWithAdditionalWork(wagerInfo._numberContext._number.toString(), Delegate.create(this, function(result) {
                    this._boletoContext$1._numberContext._selectedFractions = this._boletoContext$1._numberContext._selectedFractions & this._boletoContext$1._numberContext._availableFractions;
                }));
                return;
            }
            this._boletoContext$1._setState(state);
            this._environment.storeState('explicitComponentState', null);
        }
        catch (e) {
        }
    },
    
    _clearState$1: function BoletoService_BoletoService$_clearState$1() {
        this._environment.storeState(BoletoService.BoletoService._serviceName$1, null);
    },
    
    registerBoletoContentChangedListener: function BoletoService_BoletoService$registerBoletoContentChangedListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('RegisterNumberContextChangedListener');
        this._boletoContentChangedListeners$1.registerListener(boletoListener);
    },
    
    unregisterBoletoContentChangedListener: function BoletoService_BoletoService$unregisterBoletoContentChangedListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('RegisterNumberContextChangedListener');
        this._boletoContentChangedListeners$1.unregisterListener(boletoListener);
    },
    
    fireBoletoContentChangedEvent: function BoletoService_BoletoService$fireBoletoContentChangedEvent(eventObject) {
        BoletoService.BoletoService._log$1.debug('FireNumberContextChangedEvent');
        this._boletoContentChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBoletoContentChanged(eventObject);
        }));
    },
    
    registerBoletoActionListener: function BoletoService_BoletoService$registerBoletoActionListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('RegisterBoletoActionListener');
        this._boletoActionListeners$1.registerListener(boletoListener);
    },
    
    unregisterBoletoActionListener: function BoletoService_BoletoService$unregisterBoletoActionListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('UnregisterBoletoActionListener');
        this._boletoActionListeners$1.unregisterListener(boletoListener);
    },
    
    fireBoletoActionEvent: function BoletoService_BoletoService$fireBoletoActionEvent(eventObject) {
        BoletoService.BoletoService._log$1.debug('FireBoletoActionEvent');
        this._boletoActionListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBoletoAction(eventObject);
        }));
    },
    
    registerBoletoMessageListener: function BoletoService_BoletoService$registerBoletoMessageListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('RegisterBoletoMessageListener');
        this._boletoMessageListeners$1.registerListener(boletoListener);
    },
    
    unregisterBoletoMessageListener: function BoletoService_BoletoService$unregisterBoletoMessageListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('UnregisterBoletoMessageListener');
        this._boletoMessageListeners$1.unregisterListener(boletoListener);
    },
    
    fireBoletoMessageEvent: function BoletoService_BoletoService$fireBoletoMessageEvent(eventObject) {
        BoletoService.BoletoService._log$1.debug('FireBoletoMessageEvent');
        this._boletoMessageListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBoletoMessageEvent(eventObject);
        }));
    },
    
    registerBoletoStateChangedListener: function BoletoService_BoletoService$registerBoletoStateChangedListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('RegisterBoletoStateChangedListener');
        this._boletoStateChangedListener$1.registerListener(boletoListener);
    },
    
    unregisterBoletoStateChangedListener: function BoletoService_BoletoService$unregisterBoletoStateChangedListener(boletoListener) {
        BoletoService.BoletoService._log$1.debug('UnregisterBoletoStateChangedListener');
        this._boletoStateChangedListener$1.unregisterListener(boletoListener);
    },
    
    fireBoletoStateChangedEvent: function BoletoService_BoletoService$fireBoletoStateChangedEvent(eventObject) {
        BoletoService.BoletoService._log$1.debug('FireBoletoSteteChangedEvent');
        this._boletoStateChangedListener$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBoletoStateChanged(eventObject);
        }));
    },
    
    fireContentChanged: function BoletoService_BoletoService$fireContentChanged(numberChanged, fractionsChanged, terminatorChanged, randomContextChanged, priceChanged, placementEnabledChanged, wagerReferenceChanged) {
        var eventObject = new BoletoService.BoletoContentEvent();
        eventObject.numberChanged = numberChanged;
        eventObject.fractionsChanged = fractionsChanged;
        eventObject.terminatorChanged = terminatorChanged;
        eventObject.randomContextChanged = randomContextChanged;
        eventObject.priceChanged = priceChanged;
        eventObject.placementEnabledChanged = placementEnabledChanged;
        eventObject.wagerResultReferenceChanged = wagerReferenceChanged;
        this.fireBoletoContentChangedEvent(eventObject);
    },
    
    fireMessage: function BoletoService_BoletoService$fireMessage(messageType, messageTitle, messageText, isAlert, isConfirmationRequired, successCallback, failureCallback) {
        var eventObject = new BoletoService.BoletoMessageEvent();
        eventObject.messageType = messageType;
        eventObject.title = messageTitle;
        eventObject.message = messageText;
        eventObject.confirmCallback = successCallback;
        eventObject.failureCallback = failureCallback;
        eventObject.isAlert = isAlert;
        eventObject.isConfirmationRequired = isConfirmationRequired;
        this.fireBoletoMessageEvent(eventObject);
    },
    
    reset: function BoletoService_BoletoService$reset() {
        this.resetContext();
        this.changeState(BoletoService.BoletoViewState.INPUT);
    },
    
    searchNumber: function BoletoService_BoletoService$searchNumber(value) {
        this.searchNumberWithAdditionalWork(value, null);
    },
    
    searchNumberWithAdditionalWork: function BoletoService_BoletoService$searchNumberWithAdditionalWork(value, additionalWork) {
        BoletoService.BoletoService._log$1.debug('SearchNumber');
        var number = parseInt(value, 10);
        var seriesId = this._boletoContext$1.seriesId;
        this.getNumber(Delegate.create(this, function(result) {
            this._boletoContext$1.fetchingNumber = false;
            var numberResult = result;
            if (isNullOrUndefined(this._boletoContext$1._numberContext)) {
                this._boletoContext$1._numberContext = new BoletoService.NumberContextVO();
            }
            this._boletoContext$1._numberContext._number = numberResult.Number;
            this._boletoContext$1._numberContext._availableFractions = numberResult.Fractions;
            this.fireContentChanged(true, true, false, false, false, false, false);
            this.changeState(BoletoService.BoletoViewState.CONFIRMATION);
            if (!this._boletoContext$1._numberContext._availableFractions) {
                this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.nO_FRACTIONS_TITLE), this.getMessage(BoletoService.BoletoMessages.nO_FRACTIONS), true, false, null, null);
            }
            BoletoService.BoletoService._log$1.debug(String.format('Service returned number,fractions: [{0}, {1}]', numberResult.Number, numberResult.Fractions));
            if (additionalWork) {
                additionalWork.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            this._boletoContext$1.fetchingNumber = false;
        }), number, seriesId);
    },
    
    getNumber: function BoletoService_BoletoService$getNumber(sucessCallback, failureCallback, number, seriesId) {
        BoletoService.BoletoService._log$1.debug(String.format('searchNumber [{0}]', number));
        if (this._userService && !this._userService.isLoggedIn()) {
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.loG_IN), this.getMessage(BoletoService.BoletoMessages.loG_IN), true, false, null, null);
            failureCallback.invoke(null);
            return;
        }
        this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.PROCESSING), this.getMessage(BoletoService.BoletoMessages.fetchinG_NUMBER), false, false, null, null);
        this._boletoContext$1.fetchingNumber = true;
        this._environment.invokeAsync(BoletoService.BoletoService._serviceName$1, 'getNumber', { number: number, seriesId: seriesId }, sucessCallback, Delegate.create(this, function(exception) {
            BoletoService.BoletoService._log$1.debug('searchNumber exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                if (this._userService) {
                    this._userService.handleSessionTimeout(exception);
                }
            }
            else {
                failureCallback.invoke(exception);
                this._prepareAndFireUnavailableExceptionMessage$1(exception);
            }
        }));
    },
    
    getRandomNumbers: function BoletoService_BoletoService$getRandomNumbers(terminator) {
        BoletoService.BoletoService._log$1.debug('GetRandomNumbers');
        var term = this._boletoContext$1._terminator;
        var seriesId = this._boletoContext$1.seriesId;
        this.getRandom(Delegate.create(this, function(result) {
            this._boletoContext$1.fetchingRandomNumbers = false;
            var randomResult = result;
            this._boletoContext$1._randomContext = new Array(0);
            for (var i = 0; i < randomResult.Numbers.length; i++) {
                var numberContext = new BoletoService.NumberContextVO();
                numberContext._number = randomResult.Numbers[i].Number;
                numberContext._availableFractions = randomResult.Numbers[i].Fractions;
                numberContext._selectedFractions = 0;
                this._boletoContext$1._randomContext[i] = numberContext;
                this.fireContentChanged(false, false, false, true, false, false, false);
            }
            if (this._boletoContext$1.viewState === BoletoService.BoletoViewState.INPUT) {
                this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.inpuT_TITLE), this.getMessage(BoletoService.BoletoMessages.INPUT), false, false, null, null);
            }
        }), Delegate.create(this, function(exception) {
            this._boletoContext$1.fetchingRandomNumbers = false;
        }), this._boletoContext$1.randomCount, term, seriesId);
    },
    
    getRandom: function BoletoService_BoletoService$getRandom(successCallback, failureCallback, count, terminator, seriesId) {
        if (!this._userService.isLoggedIn()) {
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.loG_IN), this.getMessage(BoletoService.BoletoMessages.loG_IN), true, false, null, null);
            failureCallback.invoke(null);
            return;
        }
        if (this._boletoContext$1.viewState === BoletoService.BoletoViewState.INPUT) {
            this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.PROCESSING), this.getMessage(BoletoService.BoletoMessages.fetchinG_RANDOM), false, false, null, null);
        }
        this._boletoContext$1.fetchingRandomNumbers = true;
        this._environment.invokeAsync(BoletoService.BoletoService._serviceName$1, 'getRandomNumbers', { count: count, terminator: terminator, seriesId: seriesId }, successCallback, Delegate.create(this, function(exception) {
            BoletoService.BoletoService._log$1.debug('searchNumber exception ' + exception.message);
            if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
                this._userService.handleSessionTimeout(exception);
            }
            else {
                this._prepareAndFireUnavailableExceptionMessage$1(exception);
                failureCallback.invoke(exception);
            }
        }));
    },
    
    _prepareAndFireUnavailableExceptionMessage$1: function BoletoService_BoletoService$_prepareAndFireUnavailableExceptionMessage$1(exception) {
        this.fireMessage(BoletoService.BoletoMessageType.ERROR, this.getMessage(BoletoService.BoletoMessages.serveR_UNAVAILABLE), this.getMessage(BoletoService.BoletoMessages.serveR_UNAVAILABLE) + ((isNullOrUndefined(exception)) ? '' : '(' + exception.message) + ')', false, false, null, null);
    },
    
    selectRandomNumber: function BoletoService_BoletoService$selectRandomNumber(index) {
        BoletoService.BoletoService._log$1.debug('SelectRandomNumber');
        if (isNullOrUndefined(this._boletoContext$1.get_randomContext()) || !this._boletoContext$1.get_randomContext().length) {
            return;
        }
        this._boletoContext$1._numberContext = new BoletoService.NumberContextVO();
        this._boletoContext$1._numberContext._number = this._boletoContext$1._randomContext[index]._number;
        this._boletoContext$1._numberContext._availableFractions = this._boletoContext$1._randomContext[index]._availableFractions;
        this._boletoContext$1._numberContext._selectedFractions = 0;
        this.fireContentChanged(true, true, false, false, false, false, false);
        this.changeState(BoletoService.BoletoViewState.CONFIRMATION);
        if (!this._boletoContext$1._numberContext._availableFractions) {
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.nO_FRACTIONS_TITLE), this.getMessage(BoletoService.BoletoMessages.nO_FRACTIONS), true, false, null, null);
        }
    },
    
    increaseTerminator: function BoletoService_BoletoService$increaseTerminator() {
        BoletoService.BoletoService._log$1.debug('IncreaseTerminator');
        var term = this._boletoContext$1._terminator;
        var newTerm = term + 1;
        if (newTerm >= 10) {
            newTerm = -1;
        }
        this._boletoContext$1._terminator = newTerm;
        this.fireContentChanged(false, false, true, false, false, false, false);
    },
    
    decreaseTerminator: function BoletoService_BoletoService$decreaseTerminator() {
        BoletoService.BoletoService._log$1.debug('DecreaseTerminator');
        var term = this._boletoContext$1._terminator;
        var newTerm = term - 1;
        if (newTerm < -1) {
            newTerm = 9;
        }
        this._boletoContext$1._terminator = newTerm;
        this.fireContentChanged(false, false, true, false, false, false, false);
    },
    
    selectFraction: function BoletoService_BoletoService$selectFraction(fraction) {
        BoletoService.BoletoService._log$1.debug('SelectFraction');
        var result = this._boletoContext$1.injectFraction(fraction);
        if (result) {
            this.fireContentChanged(false, true, false, false, true, false, false);
        }
    },
    
    selectAllFractions: function BoletoService_BoletoService$selectAllFractions() {
        BoletoService.BoletoService._log$1.debug('SelectAllFractions');
        if (this._boletoContext$1.selectAllFractions()) {
            this.fireContentChanged(false, true, false, false, true, false, false);
        }
    },
    
    clearAllFractions: function BoletoService_BoletoService$clearAllFractions() {
        BoletoService.BoletoService._log$1.debug('ClearAllFractions');
        if (this._boletoContext$1.clearAllFractions()) {
            this.fireContentChanged(false, true, false, false, true, false, false);
        }
    },
    
    changeState: function BoletoService_BoletoService$changeState(viewState) {
        this._boletoContext$1.viewState = viewState;
        var eventObject = new BoletoService.BoletoStateEvent();
        eventObject.viewState = viewState;
        this.fireBoletoStateChangedEvent(eventObject);
    },
    
    resetContext: function BoletoService_BoletoService$resetContext() {
        this._boletoContext$1._reset();
        this.fireContentChanged(true, true, true, true, true, true, true);
    },
    
    placeWager: function BoletoService_BoletoService$placeWager() {
        BoletoService.BoletoService._log$1.debug('PlaceWager');
        if (this._boletoContext$1._numberContext._selectedFractions <= 0) {
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, 'Warning', 'Select fractions', true, false, null, null);
            return;
        }
        if (!this._userService.isLoggedIn()) {
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.loG_IN), this.getMessage(BoletoService.BoletoMessages.loG_IN), true, false, null, null);
            return;
        }
        var wagerRequest = this._createWagerRequest$1();
        this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.PROCESSING), this.getMessage(BoletoService.BoletoMessages.placinG_WAGER), false, false, null, null);
        this._boletoContext$1.fetchingPlaceWager = true;
        this._dgeService.placeWager(Delegate.create(this, function(result) {
            this._boletoContext$1.fetchingPlaceWager = false;
            var wagerResult = result;
            if (wagerResult.State === 'OPEN') {
                for (var b = 0; b < wagerResult.BoardStacks.length; b++) {
                    var boardResult = wagerResult.BoardStacks[b];
                    var boardResults = boardResult.Boards;
                    var drawNumbers = new Array(boardResult.Events.length);
                    var j = 0;
                    var $enum1 = boardResult.Events.getEnumerator();
                    while ($enum1.moveNext()) {
                        var info = $enum1.get_current();
                        drawNumbers[j++] = info.DrawNumber;
                    }
                    for (var i = 0; i < boardResults.length; i++) {
                        var drawIds = null;
                        if (boardResults[i].Rows) {
                            drawIds = new Array(boardResults[i].Rows.length);
                            var k = 0;
                            var $enum2 = boardResults[i].Rows.getEnumerator();
                            while ($enum2.moveNext()) {
                                var row = $enum2.get_current();
                                drawIds[k] = row.DrawId;
                            }
                        }
                    }
                }
                this._boletoContext$1._wagerResult = wagerResult;
                this._boletoContext$1._tryExcludeFractionsForRandom();
                this.fireContentChanged(false, true, false, false, false, false, true);
                this.changeState(BoletoService.BoletoViewState.RESULT);
                this._accountService.fetchAccountsDetails();
                this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.placE_OK_TITLE), String.format(this.getMessage(BoletoService.BoletoMessages.placE_OK), wagerResult.WagerReference), false, false, null, null);
            }
            else if (!isNullOrUndefined(wagerResult.ErrorMessage)) {
                this.fireMessage(BoletoService.BoletoMessageType.ERROR, 'Error', 'Placement error: ' + wagerResult.ErrorMessage, true, false, null, null);
            }
        }), Delegate.create(this, function(exception) {
            this._boletoContext$1.fetchingPlaceWager = false;
            alert(String.format('Placement exception: {0}', exception.message));
        }), wagerRequest);
    },
    
    addToFavorites: function BoletoService_BoletoService$addToFavorites(successCallback, failureCallback) {
        if (!this._userService.isLoggedIn()) {
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.loG_IN), this.getMessage(BoletoService.BoletoMessages.loG_IN), true, false, null, null);
            return;
        }
        var wagerRequest = this._createWagerRequest$1();
        this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.PROCESSING), this.getMessage(BoletoService.BoletoMessages.addinG_TO_FAVORITES), false, false, null, null);
        this._dgeService.createFavoriteWager(Delegate.create(this, function() {
            this.fireMessage(BoletoService.BoletoMessageType.INFO, this.getMessage(BoletoService.BoletoMessages.SUCCESS), this.getMessage(BoletoService.BoletoMessages.addeD_TO_FAVORITES), false, false, null, null);
        }), Delegate.create(this, function(exception) {
            var msg = (exception) ? String.format(this.getMessage(BoletoService.BoletoMessages.ERROR), exception.message) : String.format(this.getMessage(BoletoService.BoletoMessages.favoriteS_FAILED), 'unknown error');
            this.fireMessage(BoletoService.BoletoMessageType.WARNING, this.getMessage(BoletoService.BoletoMessages.ERROR), this.getMessage(BoletoService.BoletoMessages.serveR_UNAVAILABLE), true, false, null, null);
            failureCallback.invoke(exception);
        }), wagerRequest);
    },
    
    cancelWager: function BoletoService_BoletoService$cancelWager() {
        BoletoService.BoletoService._log$1.debug('CancelWager');
        this.changeState(BoletoService.BoletoViewState.INPUT);
        this._boletoContext$1._numberContext = new BoletoService.NumberContextVO();
        this.fireContentChanged(false, false, false, false, true, false, false);
    },
    
    getMessage: function BoletoService_BoletoService$getMessage(messageID) {
        return (isNullOrUndefined(this._boletoContext$1._messages)) ? '' : this._boletoContext$1.getMessage(messageID);
    },
    
    _createWagerRequest$1: function BoletoService_BoletoService$_createWagerRequest$1() {
        var wagerRequest = new DGEService.WagerRequest();
        wagerRequest.EditionCount = 1;
        wagerRequest.BoardStacks = new Array(0);
        wagerRequest.BoardStacks[0] = this._createBoardStackRequest$1();
        return wagerRequest;
    },
    
    _createBoardStackRequest$1: function BoletoService_BoletoService$_createBoardStackRequest$1() {
        var boardStackRequest = new DGEService.BoardStackInfo();
        boardStackRequest.GameId = this._boletoContext$1.externalId;
        boardStackRequest.SeriesId = this._boletoContext$1.seriesId;
        var boards = [];
        var boardRequest = new DGEService.BoardInfo();
        boardRequest.PickSystem = this._boletoContext$1.get_pickSystemID();
        boardRequest.PickValues = String.format('{0}:{1}', this._boletoContext$1._numberContext._number, this._boletoContext$1._numberContext._selectedFractions);
        boardRequest.Stake = this._boletoContext$1.get_price();
        boardRequest.QuickPick = false;
        boards.add(boardRequest);
        boardStackRequest.Boards = boards;
        return boardStackRequest;
    }
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoContentEvent

BoletoService.BoletoContentEvent = function BoletoService_BoletoContentEvent() {
}
BoletoService.BoletoContentEvent.prototype = {
    numberChanged: false,
    fractionsChanged: false,
    terminatorChanged: false,
    randomContextChanged: false,
    priceChanged: false,
    wagerResultReferenceChanged: false,
    placementEnabledChanged: false,
    
    toString: function BoletoService_BoletoContentEvent$toString() {
        return 'BoletoContentEvent{' + ', NumberChanged=' + this.numberChanged + ', FractionsChanged' + this.fractionsChanged + ', TerminatorChanged' + this.terminatorChanged + ', RandomContextChanged' + this.randomContextChanged + ', PriceChanged' + this.priceChanged + ', WagerResultReferenceChanged' + this.wagerResultReferenceChanged + '}';
    }
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoMessageEvent

BoletoService.BoletoMessageEvent = function BoletoService_BoletoMessageEvent() {
    this.messageType = BoletoService.BoletoMessageType.ACCEPTED;
}
BoletoService.BoletoMessageEvent.prototype = {
    title: null,
    message: null,
    isAlert: true,
    isConfirmationRequired: false,
    confirmCallback: null,
    failureCallback: null,
    
    toString: function BoletoService_BoletoMessageEvent$toString() {
        return 'BoletoMessageEvent{' + ' message: ' + this.message + ', messageType: ' + this.messageType + ', IsAlert: ' + this.isAlert + ', IsConfirmationRequired' + this.isConfirmationRequired + '}';
    }
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoActionEvent

BoletoService.BoletoActionEvent = function BoletoService_BoletoActionEvent(action) {
    this.action = action;
}
BoletoService.BoletoActionEvent.prototype = {
    action: null,
    
    toString: function BoletoService_BoletoActionEvent$toString() {
        return 'BoletoActionEvent{' + ' action: ' + this.action + '}';
    }
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoStateEvent

BoletoService.BoletoStateEvent = function BoletoService_BoletoStateEvent() {
    this.viewState = BoletoService.BoletoViewState.INPUT;
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoInitVO

BoletoService.BoletoInitVO = function BoletoService_BoletoInitVO() {
}
BoletoService.BoletoInitVO.prototype = {
    numberLength: null,
    randomCount: null,
    fractionsCount: null,
    externalid: null,
    seriesid: null,
    drawid: null,
    name: null,
    priceBase: null,
    priceMax: null,
    sets: null,
    pickSystems: null,
    pickSystemMap: null,
    gameEvents: null,
    gameDraws: null
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoSetVO

BoletoService.BoletoSetVO = function BoletoService_BoletoSetVO() {
}
BoletoService.BoletoSetVO.prototype = {
    id: null,
    min: null,
    max: null,
    repetitionAllowed: false
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoPickSystemVO

BoletoService.BoletoPickSystemVO = function BoletoService_BoletoPickSystemVO() {
}
BoletoService.BoletoPickSystemVO.prototype = {
    id: null,
    name: null,
    combinations: null,
    sets: null
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoPickSystemSetVO

BoletoService.BoletoPickSystemSetVO = function BoletoService_BoletoPickSystemSetVO() {
}
BoletoService.BoletoPickSystemSetVO.prototype = {
    id: null,
    symbolCount: null
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.GameEventInitData

BoletoService.GameEventInitData = function BoletoService_GameEventInitData() {
}
BoletoService.GameEventInitData.prototype = {
    drawNumber: null,
    name: null,
    date: null
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.GameDrawInitData

BoletoService.GameDrawInitData = function BoletoService_GameDrawInitData() {
}
BoletoService.GameDrawInitData.prototype = {
    drawId: null,
    name: null
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoContext

BoletoService.BoletoContext = function BoletoService_BoletoContext() {
    this.viewState = BoletoService.BoletoViewState.INPUT;
    this._terminator = -1;
}
BoletoService.BoletoContext._getAvailableFractions = function BoletoService_BoletoContext$_getAvailableFractions(numberContextVO, fractionsCount) {
    var fractions = new Array(0);
    var mask = 1;
    var j = 0;
    for (var i = 0; i < fractionsCount; i++) {
        if (((numberContextVO._availableFractions >> i) & mask) === 1) {
            fractions[j++] = i;
        }
    }
    return fractions;
}
BoletoService.BoletoContext._getAvailableFractionsCount = function BoletoService_BoletoContext$_getAvailableFractionsCount(numberContextVO, fractionsCount) {
    var fractions = 0;
    var mask = 1;
    for (var i = 0; i < fractionsCount; i++) {
        if (((numberContextVO._availableFractions >> i) & mask) === 1) {
            fractions++;
        }
    }
    return fractions;
}
BoletoService.BoletoContext.getSelectedFractionsFromNumber = function BoletoService_BoletoContext$getSelectedFractionsFromNumber(num, fractionsCount) {
    var fractions = new Array(0);
    var mask = 1;
    var j = 0;
    for (var i = 0; i < fractionsCount; i++) {
        if (((num >> i) & mask) === 1) {
            fractions[j++] = i;
        }
    }
    return fractions;
}
BoletoService.BoletoContext._getSelectedFractions = function BoletoService_BoletoContext$_getSelectedFractions(numberContextVO, fractionsCount) {
    return BoletoService.BoletoContext.getSelectedFractionsFromNumber(numberContextVO._selectedFractions, fractionsCount);
}
BoletoService.BoletoContext._getSelectedFractionsCount = function BoletoService_BoletoContext$_getSelectedFractionsCount(numberContextVO, fractionsCount) {
    var fractions = 0;
    var mask = 1;
    for (var i = 0; i < fractionsCount; i++) {
        if (((numberContextVO._selectedFractions >> i) & mask) === 1) {
            fractions++;
        }
    }
    return fractions;
}
BoletoService.BoletoContext.prototype = {
    fetchingNumber: false,
    fetchingRandomNumbers: false,
    fetchingPlaceWager: false,
    numberLength: null,
    randomCount: null,
    fractionsCount: null,
    externalId: null,
    seriesId: null,
    drawId: null,
    priceBase: null,
    priceMax: null,
    infoMessage: null,
    _numberContext: null,
    _randomContext: null,
    _placementEnabled: false,
    _wagerResult: null,
    _messages: null,
    _pickSystemMap: null,
    _gameEvents: null,
    _gameDraws: null,
    
    get_wagerResult: function BoletoService_BoletoContext$get_wagerResult() {
        return this._wagerResult;
    },
    
    get_randomContext: function BoletoService_BoletoContext$get_randomContext() {
        return this._randomContext;
    },
    
    get_numberContext: function BoletoService_BoletoContext$get_numberContext() {
        return this._numberContext;
    },
    set_numberContext: function BoletoService_BoletoContext$set_numberContext(value) {
        this._numberContext = value;
        return value;
    },
    
    get_terminator: function BoletoService_BoletoContext$get_terminator() {
        return this._terminator;
    },
    set_terminator: function BoletoService_BoletoContext$set_terminator(value) {
        this._terminator = value;
        return value;
    },
    
    getRandomContext: function BoletoService_BoletoContext$getRandomContext(index) {
        return this._randomContext[index];
    },
    
    getEvent: function BoletoService_BoletoContext$getEvent(drawNumber) {
        var $enum1 = this._gameEvents.getEnumerator();
        while ($enum1.moveNext()) {
            var eventInit = $enum1.get_current();
            if (eventInit.drawNumber === drawNumber) {
                return eventInit;
            }
        }
        return null;
    },
    
    getDraw: function BoletoService_BoletoContext$getDraw(drawId) {
        var $enum1 = this._gameDraws.getEnumerator();
        while ($enum1.moveNext()) {
            var drawInit = $enum1.get_current();
            if (drawInit.drawId === drawId) {
                return drawInit;
            }
        }
        return null;
    },
    
    addRandomNumber: function BoletoService_BoletoContext$addRandomNumber(numberContext) {
        var newIndex = this._randomContext.length;
        this._randomContext[newIndex] = numberContext;
    },
    
    removeRandomNumbers: function BoletoService_BoletoContext$removeRandomNumbers() {
        (this._randomContext).clear();
    },
    
    injectFraction: function BoletoService_BoletoContext$injectFraction(index) {
        if (isNullOrUndefined(this._numberContext)) {
            return false;
        }
        var mask = 1 << index;
        this._numberContext._selectedFractions = this._numberContext._selectedFractions ^ mask;
        return true;
    },
    
    selectAllFractions: function BoletoService_BoletoContext$selectAllFractions() {
        if (isNullOrUndefined(this._numberContext)) {
            return false;
        }
        this._numberContext._selectedFractions = this._numberContext._availableFractions;
        return true;
    },
    
    clearAllFractions: function BoletoService_BoletoContext$clearAllFractions() {
        if (isNullOrUndefined(this._numberContext)) {
            return false;
        }
        this._numberContext._selectedFractions = 0;
        return true;
    },
    
    getRandomAvailableFractions: function BoletoService_BoletoContext$getRandomAvailableFractions(index) {
        return this._randomContext[index]._availableFractions;
    },
    
    getRandomAvailableFractionsCount: function BoletoService_BoletoContext$getRandomAvailableFractionsCount(index) {
        return BoletoService.BoletoContext._getAvailableFractionsCount(this._randomContext[index], this.fractionsCount);
    },
    
    getCurrentAvailableFractions: function BoletoService_BoletoContext$getCurrentAvailableFractions() {
        return BoletoService.BoletoContext._getAvailableFractions(this._numberContext, this.fractionsCount);
    },
    
    getCurrentAvailableFractionsCount: function BoletoService_BoletoContext$getCurrentAvailableFractionsCount() {
        return BoletoService.BoletoContext._getAvailableFractionsCount(this._numberContext, this.fractionsCount);
    },
    
    getCurrentSelectedFractions: function BoletoService_BoletoContext$getCurrentSelectedFractions() {
        return BoletoService.BoletoContext._getSelectedFractions(this._numberContext, this.fractionsCount);
    },
    
    getCurrentSelectedFractionsCount: function BoletoService_BoletoContext$getCurrentSelectedFractionsCount() {
        return BoletoService.BoletoContext._getSelectedFractionsCount(this._numberContext, this.fractionsCount);
    },
    
    get_price: function BoletoService_BoletoContext$get_price() {
        if (isNullOrUndefined(this._numberContext)) {
            return 0;
        }
        if (isNullOrUndefined(BoletoService.BoletoContext._getSelectedFractions(this._numberContext, this.fractionsCount))) {
            return 0;
        }
        return BoletoService.BoletoContext._getSelectedFractionsCount(this._numberContext, this.fractionsCount) * this.priceBase;
    },
    
    get_pickSystemID: function BoletoService_BoletoContext$get_pickSystemID() {
        var key = this.getCurrentSelectedFractionsCount().toString();
        return this._pickSystemMap[key].toString();
    },
    
    getMessage: function BoletoService_BoletoContext$getMessage(messageID) {
        return this._messages[messageID];
    },
    
    _getState: function BoletoService_BoletoContext$_getState() {
        var valueObject = new BoletoService.BoletoContextVO();
        valueObject.numberLength = this.numberLength;
        valueObject.randomCount = this.randomCount;
        valueObject.fractionsCount = this.fractionsCount;
        valueObject.externalId = this.externalId;
        valueObject.seriesId = this.seriesId;
        valueObject.drawId = this.drawId;
        valueObject.priceBase = this.priceBase;
        valueObject.priceMax = this.priceMax;
        valueObject.viewState = this.viewState;
        valueObject.infoMessage = this.infoMessage;
        valueObject._terminator = this._terminator;
        valueObject._numberContext = this._numberContext;
        valueObject._randomContext = this._randomContext;
        valueObject._wagerResult = this._wagerResult;
        return valueObject;
    },
    
    _setState: function BoletoService_BoletoContext$_setState(state) {
        var valueObject = state;
        this.numberLength = valueObject.numberLength;
        this.randomCount = valueObject.randomCount;
        this.fractionsCount = valueObject.fractionsCount;
        this.externalId = valueObject.externalId;
        this.seriesId = valueObject.seriesId;
        this.drawId = valueObject.drawId;
        this.priceBase = valueObject.priceBase;
        this.priceMax = valueObject.priceMax;
        this.viewState = valueObject.viewState;
        this.infoMessage = valueObject.infoMessage;
        this._terminator = valueObject._terminator;
        this._numberContext = valueObject._numberContext;
        this._randomContext = valueObject._randomContext;
        this._wagerResult = valueObject._wagerResult;
    },
    
    _mergeState: function BoletoService_BoletoContext$_mergeState(state) {
        var valueObject = state;
        this.viewState = valueObject.viewState;
        if (valueObject.numberLength) {
            this.numberLength = valueObject.numberLength;
        }
        if (valueObject.randomCount) {
            this.randomCount = valueObject.randomCount;
        }
        if (valueObject.fractionsCount) {
            this.fractionsCount = valueObject.fractionsCount;
        }
        if (valueObject.externalId) {
            this.externalId = valueObject.externalId;
        }
        if (valueObject.seriesId) {
            this.seriesId = valueObject.seriesId;
        }
        if (valueObject.drawId) {
            this.drawId = valueObject.drawId;
        }
        if (valueObject.priceBase) {
            this.priceBase = valueObject.priceBase;
        }
        if (valueObject.priceMax) {
            this.priceMax = valueObject.priceMax;
        }
        if (valueObject.infoMessage) {
            this.infoMessage = valueObject.infoMessage;
        }
        if (valueObject._terminator) {
            this._terminator = valueObject._terminator;
        }
        if (valueObject._numberContext) {
            this._numberContext = valueObject._numberContext;
        }
        if (valueObject._randomContext) {
            this._randomContext = valueObject._randomContext;
        }
        if (valueObject._wagerResult) {
            this._wagerResult = valueObject._wagerResult;
        }
    },
    
    _reset: function BoletoService_BoletoContext$_reset() {
        this._terminator = -1;
        this._numberContext = null;
        this._wagerResult = null;
        this._placementEnabled = false;
        this.infoMessage = null;
    },
    
    _tryExcludeFractionsForRandom: function BoletoService_BoletoContext$_tryExcludeFractionsForRandom() {
        if (isNullOrUndefined(this._randomContext)) {
            return;
        }
        for (var i = 0; i < this._randomContext.length; i++) {
            if (this._randomContext[i]._number === this._numberContext._number) {
                this._randomContext[i]._selectedFractions = this._numberContext._selectedFractions;
                this._randomContext[i]._availableFractions = this._excludeFractions(this._randomContext[i]._availableFractions, this._numberContext._selectedFractions);
            }
        }
    },
    
    _excludeFractions: function BoletoService_BoletoContext$_excludeFractions(availableFractions, selectedFractions) {
        for (var i = 0; i < this.fractionsCount; i++) {
            var mask = 1 << i;
            if ((selectedFractions & mask)) {
                availableFractions = availableFractions ^ mask;
            }
        }
        return availableFractions;
    }
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.NumberContextVO

BoletoService.NumberContextVO = function BoletoService_NumberContextVO() {
    this._number = -1;
}
BoletoService.NumberContextVO.prototype = {
    _availableFractions: 0,
    _selectedFractions: 0
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoContextVO

BoletoService.BoletoContextVO = function BoletoService_BoletoContextVO() {
}
BoletoService.BoletoContextVO.prototype = {
    numberLength: null,
    randomCount: null,
    fractionsCount: null,
    externalId: null,
    seriesId: null,
    drawId: null,
    priceBase: null,
    priceMax: null,
    viewState: 0,
    infoMessage: null,
    _terminator: 0,
    _numberContext: null,
    _randomContext: null,
    _wagerResult: null
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoMessages

BoletoService.BoletoMessages = function BoletoService_BoletoMessages() {
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.BoletoMessageVO

BoletoService.BoletoMessageVO = function BoletoService_BoletoMessageVO() {
    this.messageType = BoletoService.BoletoMessageType.INFO;
}
BoletoService.BoletoMessageVO.prototype = {
    messageID: null,
    messageTitle: '',
    messageText: ''
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.NumberResult

BoletoService.NumberResult = function BoletoService_NumberResult() {
}
BoletoService.NumberResult.prototype = {
    Number: 0,
    Fractions: 0
}


////////////////////////////////////////////////////////////////////////////////
// BoletoService.RandomResult

BoletoService.RandomResult = function BoletoService_RandomResult() {
}
BoletoService.RandomResult.prototype = {
    Numbers: null
}


BoletoService.BoletoService.createClass('BoletoService.BoletoService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
BoletoService.BoletoContentEvent.createClass('BoletoService.BoletoContentEvent');
BoletoService.BoletoMessageEvent.createClass('BoletoService.BoletoMessageEvent');
BoletoService.BoletoActionEvent.createClass('BoletoService.BoletoActionEvent');
BoletoService.BoletoStateEvent.createClass('BoletoService.BoletoStateEvent');
BoletoService.BoletoInitVO.createClass('BoletoService.BoletoInitVO');
BoletoService.BoletoSetVO.createClass('BoletoService.BoletoSetVO');
BoletoService.BoletoPickSystemVO.createClass('BoletoService.BoletoPickSystemVO');
BoletoService.BoletoPickSystemSetVO.createClass('BoletoService.BoletoPickSystemSetVO');
BoletoService.GameEventInitData.createClass('BoletoService.GameEventInitData');
BoletoService.GameDrawInitData.createClass('BoletoService.GameDrawInitData');
BoletoService.BoletoContext.createClass('BoletoService.BoletoContext');
BoletoService.NumberContextVO.createClass('BoletoService.NumberContextVO');
BoletoService.BoletoContextVO.createClass('BoletoService.BoletoContextVO');
BoletoService.BoletoMessages.createClass('BoletoService.BoletoMessages');
BoletoService.BoletoMessageVO.createClass('BoletoService.BoletoMessageVO');
BoletoService.NumberResult.createClass('BoletoService.NumberResult');
BoletoService.RandomResult.createClass('BoletoService.RandomResult');
BoletoService.BoletoService._serviceName$1 = 'BoletoService';
BoletoService.BoletoService._log$1 = Framework.Logger.getLog(BoletoService.BoletoService._serviceName$1);
BoletoService.BoletoActionEvent.numbeR_ACCEPTED = 'NumberAccepted';
BoletoService.BoletoActionEvent.numbeR_REJECTED = 'NumberRejected';
BoletoService.BoletoActionEvent.wageR_PLACED = 'WagerPlaced';
BoletoService.BoletoMessages.placinG_WAGER = 'placing_wager';
BoletoService.BoletoMessages.loG_IN = 'log_in';
BoletoService.BoletoMessages.INPUT = 'input';
BoletoService.BoletoMessages.inpuT_TITLE = 'input_title';
BoletoService.BoletoMessages.nO_FRACTIONS = 'no_fractions';
BoletoService.BoletoMessages.nO_FRACTIONS_TITLE = 'no_fractions_title';
BoletoService.BoletoMessages.PROCESSING = 'processing';
BoletoService.BoletoMessages.SUCCESS = 'success';
BoletoService.BoletoMessages.ERROR = 'error';
BoletoService.BoletoMessages.fetchinG_RANDOM = 'fetching_random';
BoletoService.BoletoMessages.fetchinG_NUMBER = 'fetching_number';
BoletoService.BoletoMessages.confirM_PLACEMENT = 'confirm_placement';
BoletoService.BoletoMessages.confirM_PLACEMENT_TITLE = 'confirm_placement_title';
BoletoService.BoletoMessages.placemenT_IN_PROGRESS = 'placement_in_progress';
BoletoService.BoletoMessages.placemenT_IN_PROGRESS_TITLE = 'placement_in_progress_title';
BoletoService.BoletoMessages.placE_OK = 'placement_ok';
BoletoService.BoletoMessages.placE_OK_TITLE = 'placement_ok_title';
BoletoService.BoletoMessages.placE_FAILED = 'placement_failed';
BoletoService.BoletoMessages.placE_FAILED_TITLE = 'placement_failed_title';
BoletoService.BoletoMessages.serveR_UNAVAILABLE = 'server_unavailable';
BoletoService.BoletoMessages.addinG_TO_FAVORITES = 'adding_to_favorites';
BoletoService.BoletoMessages.addeD_TO_FAVORITES = 'added_to_favorites';
BoletoService.BoletoMessages.favoriteS_FAILED = 'favorites_failed';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('LotteryBoardService');

////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SubscriptionsContinue

LotteryBoardService.SubscriptionsContinue = function() { };
LotteryBoardService.SubscriptionsContinue.prototype = {
    INDEFINETELY: 1, 
    nO_OF_WEEKS: 2, 
    expirY_DATE: 3
}
LotteryBoardService.SubscriptionsContinue.createEnum('LotteryBoardService.SubscriptionsContinue', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.ViewState

LotteryBoardService.ViewState = function() { };
LotteryBoardService.ViewState.prototype = {
    INPUT: 1, 
    CONFIRMATION: 2, 
    RESULT: 3
}
LotteryBoardService.ViewState.createEnum('LotteryBoardService.ViewState', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.NumberType

LotteryBoardService.NumberType = function() { };
LotteryBoardService.NumberType.prototype = {
    REGULAR: 2, 
    clienT_QP: 3, 
    serveR_QP: 4
}
LotteryBoardService.NumberType.createEnum('LotteryBoardService.NumberType', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.ILotteryMessageListener

LotteryBoardService.ILotteryMessageListener = function() { };
LotteryBoardService.ILotteryMessageListener.prototype = {
    onLotteryMessage : null
}
LotteryBoardService.ILotteryMessageListener.createInterface('LotteryBoardService.ILotteryMessageListener');


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.ILotteryPropertyChangedListener

LotteryBoardService.ILotteryPropertyChangedListener = function() { };
LotteryBoardService.ILotteryPropertyChangedListener.prototype = {
    onLotteryPropertyChanged : null
}
LotteryBoardService.ILotteryPropertyChangedListener.createInterface('LotteryBoardService.ILotteryPropertyChangedListener');


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.IActionListener

LotteryBoardService.IActionListener = function() { };
LotteryBoardService.IActionListener.prototype = {
    onActionPerformed : null
}
LotteryBoardService.IActionListener.createInterface('LotteryBoardService.IActionListener');


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.MessageType

LotteryBoardService.MessageType = function() { };
LotteryBoardService.MessageType.prototype = {
    ACCEPTED: 1, 
    INFO: 2, 
    WARNING: 3, 
    ERROR: 4
}
LotteryBoardService.MessageType.createEnum('LotteryBoardService.MessageType', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.ISportsBoardContentChangedListener

LotteryBoardService.ISportsBoardContentChangedListener = function() { };
LotteryBoardService.ISportsBoardContentChangedListener.prototype = {
    onSportsBoardContentChanged : null,
    onSportsBoardStateChanged : null,
    onSportsBoardMessage : null,
    get_instanceID : null
}
LotteryBoardService.ISportsBoardContentChangedListener.createInterface('LotteryBoardService.ISportsBoardContentChangedListener');


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsViewState

LotteryBoardService.SportsViewState = function() { };
LotteryBoardService.SportsViewState.prototype = {
    UNKNOWN: 0, 
    INPUT: 1, 
    CONFIRMATION: 2, 
    RESULT: 3
}
LotteryBoardService.SportsViewState.createEnum('LotteryBoardService.SportsViewState', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsQPType

LotteryBoardService.SportsQPType = function() { };
LotteryBoardService.SportsQPType.prototype = {
    server: 0, 
    client: 1, 
    clientRandom: 2
}
LotteryBoardService.SportsQPType.createEnum('LotteryBoardService.SportsQPType', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.IBoardStackContentListener

LotteryBoardService.IBoardStackContentListener = function() { };
LotteryBoardService.IBoardStackContentListener.prototype = {
    onBoardStackContentChanged : null
}
LotteryBoardService.IBoardStackContentListener.createInterface('LotteryBoardService.IBoardStackContentListener');


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsMessageType

LotteryBoardService.SportsMessageType = function() { };
LotteryBoardService.SportsMessageType.prototype = {
    ACCEPTED: 1, 
    INFO: 2, 
    WARNING: 3, 
    ERROR: 4
}
LotteryBoardService.SportsMessageType.createEnum('LotteryBoardService.SportsMessageType', false);


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.AbstractControllerFactory

LotteryBoardService.AbstractControllerFactory = function LotteryBoardService_AbstractControllerFactory(lotterybBoardService, instanceID) {
    this._lotteryBoardService = lotterybBoardService;
    this._instanceID = instanceID;
}
LotteryBoardService.AbstractControllerFactory.prototype = {
    _lotteryBoardService: null,
    _instanceID: null,
    
    create: function LotteryBoardService_AbstractControllerFactory$create() {
        var controller = this._lotteryBoardService._getController(this._instanceID);
        if (isNullOrUndefined(controller)) {
            controller = this.doCreate();
            this.init(controller);
        }
        return controller;
    },
    
    init: function LotteryBoardService_AbstractControllerFactory$init(controller) {
        this._lotteryBoardService._registerController(controller);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService._commonUtils

LotteryBoardService._commonUtils = function LotteryBoardService__commonUtils() {
}
LotteryBoardService._commonUtils.getRandomNumber = function LotteryBoardService__commonUtils$getRandomNumber(max) {
    if (max < 1) {
        return 0;
    }
    else {
        return Math.floor(Math.random() * max + 1);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.AbstractLotteryController

LotteryBoardService.AbstractLotteryController = function LotteryBoardService_AbstractLotteryController(instanceID, messages, lotteryContext) {
    LotteryBoardService.AbstractLotteryController.constructBase(this, [ instanceID, lotteryContext.environment ]);
    this._lotteryContext = lotteryContext;
    this._messages = messages;
    this._log = this._lotteryContext.log;
    this._eventDispatcher = new LotteryBoardService.LotteryEventDispatcher(this._log);
}
LotteryBoardService.AbstractLotteryController.prototype = {
    _lotteryContext: null,
    _messages: null,
    _log: null,
    _eventDispatcher: null,
    
    get_eventDispatcher: function LotteryBoardService_AbstractLotteryController$get_eventDispatcher() {
        return this._eventDispatcher;
    },
    
    getMessage: function LotteryBoardService_AbstractLotteryController$getMessage(messageID) {
        return this._messages[messageID];
    },
    
    fireContentEvent: function LotteryBoardService_AbstractLotteryController$fireContentEvent(eventObject) {
        this._eventDispatcher._dispatchContentEvent(eventObject);
        this._lotteryContext.commonEventDispatcher._dispatchContentEvent(eventObject);
    },
    
    firePropertyChangedEvent: function LotteryBoardService_AbstractLotteryController$firePropertyChangedEvent(propertyName, newValue, oldValue) {
        var eventObject = new LotteryBoardService.LotteryPropertyChangedEvent(this, this._instanceID);
        eventObject.propertyName = propertyName;
        eventObject.newValue = newValue;
        eventObject.oldValue = oldValue;
        this._eventDispatcher._dispatchPropertyChangedEvent(eventObject);
        this._lotteryContext.commonEventDispatcher._dispatchPropertyChangedEvent(eventObject);
    },
    
    fireMessageEvent: function LotteryBoardService_AbstractLotteryController$fireMessageEvent(messageID, messageText) {
        this.fireMessageEventType(messageID, '', messageText, true, LotteryBoardService.MessageType.INFO);
    },
    
    fireExceptionMessageEvent: function LotteryBoardService_AbstractLotteryController$fireExceptionMessageEvent(exception, IsAlert) {
        this.fireMessageEventType('0', 'Error', exception.message, IsAlert, LotteryBoardService.MessageType.ERROR);
    },
    
    fireMessageEventType: function LotteryBoardService_AbstractLotteryController$fireMessageEventType(messageID, messageTitle, messageText, IsAlert, messageType) {
        var messageVO = new LotteryBoardService.MessageVO();
        var eventObject = new LotteryBoardService.LotteryMessageEvent(this, this._instanceID);
        messageVO.messageID = messageID;
        messageVO.messageTitle = messageTitle;
        messageVO.messageText = messageText;
        messageVO.messageType = messageType;
        eventObject.isAlert = IsAlert;
        eventObject.messageVO = messageVO;
        this._eventDispatcher._dispatchMessageEvent(eventObject);
        this._lotteryContext.commonEventDispatcher._dispatchMessageEvent(eventObject);
        return messageVO;
    },
    
    fireConfirmMessageEvent: function LotteryBoardService_AbstractLotteryController$fireConfirmMessageEvent(messageID, messageText, confirmCallback, rejectCallback) {
        var messageVO = new LotteryBoardService.MessageVO();
        var eventObject = new LotteryBoardService.LotteryMessageEvent(this, this._instanceID);
        messageVO.messageID = messageID;
        messageVO.messageText = messageText;
        eventObject.messageVO = messageVO;
        eventObject.confirmationRequired = true;
        eventObject.confirmCallback = confirmCallback;
        eventObject.rejectCallback = rejectCallback;
        this._eventDispatcher._dispatchMessageEvent(eventObject);
        this._lotteryContext.commonEventDispatcher._dispatchMessageEvent(eventObject);
    },
    
    fireActionEvent: function LotteryBoardService_AbstractLotteryController$fireActionEvent(action) {
        var actionEvent = new LotteryBoardService.LotteryActionEvent(this, this._instanceID, action);
        this._eventDispatcher._dispatchActionEvent(actionEvent);
        this._lotteryContext.commonEventDispatcher._dispatchActionEvent(actionEvent);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.QuickPickHelper

LotteryBoardService.QuickPickHelper = function LotteryBoardService_QuickPickHelper(boardStackController, dgGameConfigProxy, boardStackProxy) {
    this._boardStackController = boardStackController;
    this._boardStackProxy = boardStackProxy;
    this._dgGameConfigProxy = dgGameConfigProxy;
    this._dgGameConfigVO = dgGameConfigProxy.dgGameConfigVO;
}
LotteryBoardService.QuickPickHelper._createRandomSortedRange = function LotteryBoardService_QuickPickHelper$_createRandomSortedRange(min, max) {
    var list = [];
    for (var i = min; i <= max; i++) {
        list.add(i);
    }
    var randomList = [];
    while (list.length > 0) {
        var pos = LotteryBoardService._commonUtils.getRandomNumber(list.length) - 1;
        randomList.add(list.removeAt(pos));
    }
    return randomList;
}
LotteryBoardService.QuickPickHelper.prototype = {
    _boardStackProxy: null,
    _dgGameConfigProxy: null,
    _dgGameConfigVO: null,
    _boardStackController: null,
    
    fullQP: function LotteryBoardService_QuickPickHelper$fullQP() {
        this._boardStackProxy.clear();
        if (this._boardStackProxy.get_remoteClientQP()) {
            this._performRemoteFullQP();
        }
        else {
            this._performLocalFullQP();
        }
    },
    
    _performLocalFullQP: function LotteryBoardService_QuickPickHelper$_performLocalFullQP() {
        for (var s = 0; s < this._dgGameConfigVO.sets.length; s++) {
            var dgSet = this._dgGameConfigVO.sets[s];
            var list = [];
            for (var b = 0; b < this._boardStackProxy.get_boardCount(); b++) {
                var board = this._boardStackProxy.getBoard(b);
                var setProxy = board.getSet(s);
                var picksystemSet = board.get_pickSystem().sets[s];
                if (list.length < picksystemSet.symbolCount) {
                    list = LotteryBoardService.QuickPickHelper._createRandomSortedRange(setProxy.min, setProxy.max);
                }
                for (var n = 0; n < picksystemSet.symbolCount; n++) {
                    var val = list.removeAt(list.length - 1);
                    board.getSet(s).getNumber(n)._setClientQP(val);
                }
                this._fireBoardContentChanged(b);
            }
        }
        this._firePriceChanged();
    },
    
    _performRemoteFullQP: function LotteryBoardService_QuickPickHelper$_performRemoteFullQP() {
        var boardStackRequest = new DGEService.BoardStackInfo();
        boardStackRequest.GameId = this._boardStackProxy.get_externalID();
        boardStackRequest.SeriesId = this._boardStackProxy.get_seriesId();
        boardStackRequest.Boards = new Array(this._boardStackProxy.get_boardCount());
        for (var b = 0; b < this._boardStackProxy.get_boardCount(); b++) {
            boardStackRequest.Boards[b] = this._createQPBoardInfo(b);
        }
        this._boardStackController._lotteryContext.dgeService.fullQuickPick(Delegate.create(this, function(result) {
            var boardStackInfo = result;
            this._populateQPFromResponse(boardStackInfo);
        }), Delegate.create(this, this._handleQPException), boardStackRequest);
    },
    
    forceQP: function LotteryBoardService_QuickPickHelper$forceQP() {
        this._boardStackProxy.set_forceQP(!this._boardStackProxy.get_forceQP());
        if (this._boardStackProxy.get_forceQP()) {
            for (var i = 0; i < this._boardStackProxy.get_boardCount(); i++) {
                this.quickPick(i, 1);
            }
        }
        else {
            this._boardStackController.clearBoardStack();
        }
        this._boardStackController.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.forceqP_CHANGED, this._boardStackProxy.get_forceQP(), null);
    },
    
    quickPick: function LotteryBoardService_QuickPickHelper$quickPick(boardIndex, count) {
        var board = this._boardStackProxy.getBoard(boardIndex);
        if (!board.isEmpty() && !board.hasQPFields() && !this._boardStackProxy.get_partialQPAllowed()) {
            this._boardStackController.fireConfirmMessageEvent(LotteryBoardService.LotteryMessages.cleaR_NUMBERS, this._boardStackController.getMessage(LotteryBoardService.LotteryMessages.cleaR_NUMBERS), Delegate.create(this, function() {
                this._boardStackController.clearBoard(boardIndex);
                this._performQuickPick(boardIndex, count);
            }), Delegate.create(this, function() {
            }));
        }
        else if (board.isServerQuickPick() && board.hasQPFields()) {
            this._boardStackController._clearQuickPick(boardIndex);
        }
        else {
            this._performQuickPick(boardIndex, count);
        }
    },
    
    _performQuickPick: function LotteryBoardService_QuickPickHelper$_performQuickPick(boardIndex, count) {
        if (this._boardStackProxy.get_remoteClientQP()) {
            this._performRemoteQuickPick(boardIndex);
        }
        else {
            window.setTimeout(Delegate.create(this, function() {
                this._performLocalQuickPick(boardIndex, count);
            }), 20);
        }
    },
    
    _performRemoteQuickPick: function LotteryBoardService_QuickPickHelper$_performRemoteQuickPick(boardIndex) {
        var boardStackRequest = new DGEService.BoardStackInfo();
        boardStackRequest.GameId = this._boardStackProxy.get_externalID();
        boardStackRequest.SeriesId = this._boardStackProxy.get_seriesId();
        boardStackRequest.Boards = new Array(this._boardStackProxy.get_boardCount());
        for (var b = 0; b < this._boardStackProxy.get_boardCount(); b++) {
            if (b === boardIndex) {
                boardStackRequest.Boards[b] = this._createQPBoardInfo(b);
            }
            else {
                boardStackRequest.Boards[b] = null;
            }
        }
        this._boardStackController._lotteryContext.dgeService.quickPick(Delegate.create(this, function(result) {
            var boardStackInfo = result;
            this._populateQPFromResponse(boardStackInfo);
        }), Delegate.create(this, this._handleQPException), boardStackRequest);
    },
    
    _performLocalQuickPick: function LotteryBoardService_QuickPickHelper$_performLocalQuickPick(boardIndex, count) {
        if (count <= 0) {
            return;
        }
        var boardProxy = this._boardStackProxy.getBoard(boardIndex);
        for (var s = 0; s < boardProxy.get_setCount(); s++) {
            var set = boardProxy.getSet(s);
            if (!set.get_active()) {
                continue;
            }
            for (var n = 0; n < set.get_numberCount(); n++) {
                var number = set.getNumber(n);
                if (!number.get_enabled() || (number.isPopulated() && !number.isQuickPick())) {
                    continue;
                }
                if (this._dgGameConfigProxy.get_isClientQP()) {
                    var nr;
                    while (true) {
                        nr = LotteryBoardService._commonUtils.getRandomNumber(set.max);
                        if (!set.containsValue(nr)) {
                            break;
                        }
                    }
                    number._setClientQP(nr);
                }
                else {
                    number._setServerQP();
                }
            }
        }
        this._fireBoardContentChanged(boardIndex);
        this._firePriceChanged();
        window.setTimeout(Delegate.create(this, function() {
            this._performLocalQuickPick(boardIndex, count - 1);
        }), 100);
    },
    
    _createQPBoardInfo: function LotteryBoardService_QuickPickHelper$_createQPBoardInfo(boardIndex) {
        var board = this._boardStackProxy.getBoard(boardIndex);
        var boardRequest = new DGEService.BoardInfo();
        if (!isNullOrUndefined(board.get_pickSystem())) {
            boardRequest.PickSystem = board.get_pickSystem().id;
        }
        boardRequest.PickValues = board._getQPAsString();
        boardRequest.QuickPick = true;
        return boardRequest;
    },
    
    _populateQPFromResponse: function LotteryBoardService_QuickPickHelper$_populateQPFromResponse(boardStackInfo) {
        for (var b = 0; b < boardStackInfo.Boards.length; b++) {
            if (isNullOrUndefined(boardStackInfo.Boards[b])) {
                continue;
            }
            var board = this._boardStackProxy.getBoard(b);
            board._setQPFromString(boardStackInfo.Boards[b].PickValues);
            this._fireBoardContentChanged(b);
        }
        this._firePriceChanged();
    },
    
    _handleQPException: function LotteryBoardService_QuickPickHelper$_handleQPException(exception) {
        this._boardStackController.fireExceptionMessageEvent(exception, true);
    },
    
    _fireBoardContentChanged: function LotteryBoardService_QuickPickHelper$_fireBoardContentChanged(boardIndex) {
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this._boardStackController, this._boardStackController.get_instanceID());
        eventObject.selectedNumbersChanged = true;
        eventObject.boardIndex = boardIndex;
        this._boardStackController.fireContentEvent(eventObject);
    },
    
    _firePriceChanged: function LotteryBoardService_QuickPickHelper$_firePriceChanged() {
        this._boardStackController.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy.get_price(), null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardStackVO

LotteryBoardService.BoardStackVO = function LotteryBoardService_BoardStackVO() {
    this.viewState = LotteryBoardService.ViewState.INPUT;
}
LotteryBoardService.BoardStackVO.prototype = {
    externalID: null,
    seriesID: null,
    forceQP: false,
    boardVOList: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.MessageVO

LotteryBoardService.MessageVO = function LotteryBoardService_MessageVO() {
    this.messageType = LotteryBoardService.MessageType.INFO;
}
LotteryBoardService.MessageVO.prototype = {
    messageID: null,
    messageTitle: '???',
    messageText: '???'
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SetVO

LotteryBoardService.SetVO = function LotteryBoardService_SetVO() {
}
LotteryBoardService.SetVO.prototype = {
    numberVOList: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.NumberVO

LotteryBoardService.NumberVO = function LotteryBoardService_NumberVO() {
    this.value = -1;
    this.type = LotteryBoardService.NumberType.REGULAR;
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.WagerVO

LotteryBoardService.WagerVO = function LotteryBoardService_WagerVO() {
    this.viewState = LotteryBoardService.ViewState.INPUT;
    this.subscriptionsContinue = LotteryBoardService.SubscriptionsContinue.INDEFINETELY;
    this.schedulePeriodID = LotteryBoardService.SchedulePeriodIdList.WEEKLY;
    this.wagerResult = new DGEService.WagerResult();
}
LotteryBoardService.WagerVO.prototype = {
    editionCount: null,
    editionSeriesID: null,
    subscriptionsNodeExpanded: false,
    infoMessageVO: null,
    unlimited: true,
    startDate: null,
    numberOfWeeks: 1,
    expiryDate: null,
    fundingTypeID: null,
    scheduleOffset: null,
    paymentInstrumentID: null,
    lockFunds: false,
    guaranteedJackpot: null,
    rolloverAmount: null,
    boardStackVOList: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.InstanceContext

LotteryBoardService.InstanceContext = function LotteryBoardService_InstanceContext() {
}
LotteryBoardService.InstanceContext.prototype = {
    dgConfigVO: null,
    messages: null,
    lotteryBoardService: null,
    instanceID: null,
    displayAddons: false
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGGameConfigProxy

LotteryBoardService.DGGameConfigProxy = function LotteryBoardService_DGGameConfigProxy(dgConfigConfigVO) {
    this.dgGameConfigVO = dgConfigConfigVO;
}
LotteryBoardService.DGGameConfigProxy.prototype = {
    dgGameConfigVO: null,
    
    get_isClientQP: function LotteryBoardService_DGGameConfigProxy$get_isClientQP() {
        return this.dgGameConfigVO.quickPickType === 'client' || this.dgGameConfigVO.quickPickType === 'clisrv';
    },
    
    get_isRemoteClientQP: function LotteryBoardService_DGGameConfigProxy$get_isRemoteClientQP() {
        return this.dgGameConfigVO.quickPickType === 'clisrv';
    },
    
    get_isServerQP: function LotteryBoardService_DGGameConfigProxy$get_isServerQP() {
        return this.dgGameConfigVO.quickPickType === 'server' || this.dgGameConfigVO.quickPickType === 'dgs';
    },
    
    getPickSystemByID: function LotteryBoardService_DGGameConfigProxy$getPickSystemByID(id) {
        var $enum1 = this.dgGameConfigVO.pickSystems.getEnumerator();
        while ($enum1.moveNext()) {
            var ps = $enum1.get_current();
            if (ps.id === id) {
                return ps;
            }
        }
        return null;
    },
    
    getDefaultPickSystem: function LotteryBoardService_DGGameConfigProxy$getDefaultPickSystem() {
        return this.getPickSystemByID(this.dgGameConfigVO.defaultPickSystemID);
    },
    
    getEditionSeriesByID: function LotteryBoardService_DGGameConfigProxy$getEditionSeriesByID(id) {
        var $enum1 = this.dgGameConfigVO.editionSeries.getEnumerator();
        while ($enum1.moveNext()) {
            var es = $enum1.get_current();
            if (id === es.editionSeriesID) {
                return es;
            }
        }
        return null;
    },
    
    getDrawByID: function LotteryBoardService_DGGameConfigProxy$getDrawByID(drawID) {
        drawID = '' + drawID;
        var $enum1 = this.dgGameConfigVO.draws.getEnumerator();
        while ($enum1.moveNext()) {
            var drawVO = $enum1.get_current();
            if (drawVO.id === drawID) {
                return drawVO;
            }
        }
        return null;
    },
    
    getSetByID: function LotteryBoardService_DGGameConfigProxy$getSetByID(setID) {
        var $enum1 = this.dgGameConfigVO.sets.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            if (set.id === setID) {
                return set;
            }
        }
        return null;
    },
    
    getEventByDrawNumber: function LotteryBoardService_DGGameConfigProxy$getEventByDrawNumber(drawNumber) {
        var $enum1 = this.dgGameConfigVO.gameEvents.getEnumerator();
        while ($enum1.moveNext()) {
            var gameEvent = $enum1.get_current();
            if (gameEvent.drawNumber === drawNumber) {
                return gameEvent;
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryContext

LotteryBoardService.LotteryContext = function LotteryBoardService_LotteryContext() {
}
LotteryBoardService.LotteryContext.prototype = {
    lotteryService: null,
    navigationService: null,
    dgeService: null,
    userService: null,
    accountService: null,
    log: null,
    environment: null,
    commonEventDispatcher: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGConfigVO

LotteryBoardService.DGConfigVO = function LotteryBoardService_DGConfigVO() {
}
LotteryBoardService.DGConfigVO.prototype = {
    games: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGGameConfigVO

LotteryBoardService.DGGameConfigVO = function LotteryBoardService_DGGameConfigVO() {
}
LotteryBoardService.DGGameConfigVO.prototype = {
    externalID: null,
    gameIndex: null,
    isAddon: false,
    editionSeries: null,
    quickPickType: null,
    partialQPAllowed: false,
    fullQPAllowed: false,
    forceQP: false,
    isSubscriptionsAllowed: false,
    defaultEditionSeriesID: null,
    defaultPickSystemID: null,
    multiPickSystemsAllowed: false,
    editionSeriesAllowed: false,
    advancedSeriesAllowed: false,
    boardcountDefault: null,
    boardcountMin: 1,
    boardcountMax: 999999,
    editionCountDefault: null,
    editionCountMin: null,
    editionCountMax: null,
    editionCountList: null,
    autoChangeSystem: 'none',
    draws: null,
    sets: null,
    pickSystems: null,
    priceMax: null,
    gameEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGEditionSeriesConfigVO

LotteryBoardService.DGEditionSeriesConfigVO = function LotteryBoardService_DGEditionSeriesConfigVO() {
}
LotteryBoardService.DGEditionSeriesConfigVO.prototype = {
    editionSeriesID: null,
    name: null,
    eventSeriesCount: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGDrawConfigVO

LotteryBoardService.DGDrawConfigVO = function LotteryBoardService_DGDrawConfigVO() {
}
LotteryBoardService.DGDrawConfigVO.prototype = {
    id: null,
    name: null,
    priceList: null,
    option: null,
    dependantSets: null,
    dependantDraws: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGSetConfigVO

LotteryBoardService.DGSetConfigVO = function LotteryBoardService_DGSetConfigVO() {
}
LotteryBoardService.DGSetConfigVO.prototype = {
    id: null,
    min: null,
    max: null,
    repetitionAllowed: false,
    isAlphaNumeric: false,
    optional: false,
    isOnWager: false
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGPicksystemConfigVO

LotteryBoardService.DGPicksystemConfigVO = function LotteryBoardService_DGPicksystemConfigVO() {
}
LotteryBoardService.DGPicksystemConfigVO.prototype = {
    id: null,
    name: null,
    combinations: null,
    sets: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGPicksystemSetConfigVO

LotteryBoardService.DGPicksystemSetConfigVO = function LotteryBoardService_DGPicksystemSetConfigVO() {
}
LotteryBoardService.DGPicksystemSetConfigVO.prototype = {
    id: null,
    symbolCount: null,
    minSameSymbols: null,
    maxSameSymbols: null,
    symbolMask: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.DGGameEventVO

LotteryBoardService.DGGameEventVO = function LotteryBoardService_DGGameEventVO() {
}
LotteryBoardService.DGGameEventVO.prototype = {
    drawNumber: 0,
    name: null,
    date: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.FundingTypeIdList

LotteryBoardService.FundingTypeIdList = function LotteryBoardService_FundingTypeIdList() {
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SchedulePeriodIdList

LotteryBoardService.SchedulePeriodIdList = function LotteryBoardService_SchedulePeriodIdList() {
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.AutoChangeSystem

LotteryBoardService.AutoChangeSystem = function LotteryBoardService_AutoChangeSystem() {
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryMessages

LotteryBoardService.LotteryMessages = function LotteryBoardService_LotteryMessages() {
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryEventDispatcher

LotteryBoardService.LotteryEventDispatcher = function LotteryBoardService_LotteryEventDispatcher(log) {
    this._boardContentChangedListeners = new Framework.ListenerInvoker(true);
    this._boardPropertyChangedListeners = new Framework.ListenerInvoker(true);
    this._boardMessageListeners = new Framework.ListenerInvoker(true);
    this._boardActionListeners = new Framework.ListenerInvoker(true);
    this._log = log;
}
LotteryBoardService.LotteryEventDispatcher.prototype = {
    _log: null,
    
    _dispatchContentEvent: function LotteryBoardService_LotteryEventDispatcher$_dispatchContentEvent(eventObject) {
        this._log.debug('FireBoardContentChanged');
        this._boardContentChangedListeners.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBoardStackContentChanged(eventObject);
        }));
    },
    
    _dispatchPropertyChangedEvent: function LotteryBoardService_LotteryEventDispatcher$_dispatchPropertyChangedEvent(eventObject) {
        this._log.debug('DispatchPropertyChangedEvent');
        this._boardPropertyChangedListeners.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onLotteryPropertyChanged(eventObject);
        }));
    },
    
    _dispatchMessageEvent: function LotteryBoardService_LotteryEventDispatcher$_dispatchMessageEvent(eventObject) {
        this._log.debug('FireMessageEvent');
        this._boardMessageListeners.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onLotteryMessage(eventObject);
        }));
    },
    
    _dispatchActionEvent: function LotteryBoardService_LotteryEventDispatcher$_dispatchActionEvent(eventObject) {
        this._log.debug('DispatchActionEvent');
        this._boardActionListeners.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onActionPerformed(eventObject);
        }));
    },
    
    registerBoardContentChangedListener: function LotteryBoardService_LotteryEventDispatcher$registerBoardContentChangedListener(boardStackContentListener) {
        this._log.debug('RegisterBoardContentChangedListener');
        this._boardContentChangedListeners.registerListener(boardStackContentListener);
    },
    
    registerPropertyChangedListener: function LotteryBoardService_LotteryEventDispatcher$registerPropertyChangedListener(propertyChangedListener) {
        this._log.debug('RegisterPropertyChangedListener');
        this._boardPropertyChangedListeners.registerListener(propertyChangedListener);
    },
    
    registerMessageListener: function LotteryBoardService_LotteryEventDispatcher$registerMessageListener(messageChangedListener) {
        this._log.debug('RegisterMessageListener');
        this._boardMessageListeners.registerListener(messageChangedListener);
    },
    
    registerActionListener: function LotteryBoardService_LotteryEventDispatcher$registerActionListener(actionListener) {
        this._log.debug('RegisterActionListener');
        this._boardActionListeners.registerListener(actionListener);
    },
    
    unregisterBoardContentChangedListener: function LotteryBoardService_LotteryEventDispatcher$unregisterBoardContentChangedListener(boardStackContentListener) {
        this._log.debug('UnregisterBoardContentChangedListener');
        this._boardContentChangedListeners.unregisterListener(boardStackContentListener);
    },
    
    unregisterPropertyChangedListener: function LotteryBoardService_LotteryEventDispatcher$unregisterPropertyChangedListener(propertyChangedListener) {
        this._log.debug('UnregisterPropertyChangedListener');
        this._boardPropertyChangedListeners.unregisterListener(propertyChangedListener);
    },
    
    unregisterMessageListener: function LotteryBoardService_LotteryEventDispatcher$unregisterMessageListener(messageChangedListener) {
        this._log.debug('UnregisterMessageListener');
        this._boardMessageListeners.unregisterListener(messageChangedListener);
    },
    
    unregisterActionListener: function LotteryBoardService_LotteryEventDispatcher$unregisterActionListener(actionListener) {
        this._log.debug('UnregisterActionListener');
        this._boardActionListeners.unregisterListener(actionListener);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardVO

LotteryBoardService.BoardVO = function LotteryBoardService_BoardVO() {
}
LotteryBoardService.BoardVO.prototype = {
    pickSystemID: null,
    boardRows: null,
    values: '',
    setVOList: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardStackContentEvent

LotteryBoardService.BoardStackContentEvent = function LotteryBoardService_BoardStackContentEvent(source, instanceID) {
    LotteryBoardService.BoardStackContentEvent.constructBase(this, [ source, instanceID ]);
}
LotteryBoardService.BoardStackContentEvent.prototype = {
    allChanged: false,
    selectedNumbersChanged: false,
    boardIndex: null,
    setIndex: null,
    fieldIndex: null,
    oldNumberProxy: null,
    newNumberProxy: null,
    pickSystemID: null,
    drawsChanged: false,
    pickSystemsChanged: false,
    
    toString: function LotteryBoardService_BoardStackContentEvent$toString() {
        return LotteryBoardService.BoardStackContentEvent.callBase(this, 'toString') + ', SelectedNumbersChanged=' + this.selectedNumbersChanged + ', board=' + this.boardIndex + ', set=' + this.setIndex + ', Field=' + this.fieldIndex + ', NewNumberProxy=' + this.oldNumberProxy + ', NewNumberProxy=' + this.newNumberProxy + ', PickSystemID=' + this.pickSystemID + ', DrawsChanged=' + this.drawsChanged + ', PickSystemsChanged=' + this.pickSystemsChanged;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryPropertyChangedEvent

LotteryBoardService.LotteryPropertyChangedEvent = function LotteryBoardService_LotteryPropertyChangedEvent(source, instanceID) {
    LotteryBoardService.LotteryPropertyChangedEvent.constructBase(this, [ source, instanceID ]);
}
LotteryBoardService.LotteryPropertyChangedEvent.prototype = {
    propertyName: null,
    newValue: null,
    oldValue: null,
    
    toString: function LotteryBoardService_LotteryPropertyChangedEvent$toString() {
        return 'PropertyChanges: ' + LotteryBoardService.LotteryPropertyChangedEvent.callBase(this, 'toString') + ', PropertyName=' + this.propertyName;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryActionEvent

LotteryBoardService.LotteryActionEvent = function LotteryBoardService_LotteryActionEvent(source, instanceID, action) {
    LotteryBoardService.LotteryActionEvent.constructBase(this, [ source, instanceID ]);
    this.action = action;
}
LotteryBoardService.LotteryActionEvent.prototype = {
    action: null,
    
    toString: function LotteryBoardService_LotteryActionEvent$toString() {
        return LotteryBoardService.LotteryActionEvent.callBase(this, 'toString') + ', action: ' + this.action;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardStackProxy

LotteryBoardService.BoardStackProxy = function LotteryBoardService_BoardStackProxy(instanceID, dgGameConfigProxy) {
    this._boards = new Array(0);
    this.instanceID = instanceID;
    this._dgGameConfigProxy = dgGameConfigProxy;
    this._dgGameConfigVO = dgGameConfigProxy.dgGameConfigVO;
    this.set__data(new LotteryBoardService.BoardStackVO());
    this.set_seriesId(this._dgGameConfigVO.defaultEditionSeriesID);
    for (var r = 0; r < dgGameConfigProxy.dgGameConfigVO.boardcountDefault; r++) {
        var board = new LotteryBoardService.BoardProxy(dgGameConfigProxy);
        this.addBoard(board);
    }
}
LotteryBoardService.BoardStackProxy.prototype = {
    _dgGameConfigProxy: null,
    _dgGameConfigVO: null,
    _boardStackVO: null,
    _wagerProxy: null,
    instanceID: null,
    _enabled: true,
    _drawNumbers: null,
    
    get__data: function LotteryBoardService_BoardStackProxy$get__data() {
        return this._boardStackVO;
    },
    set__data: function LotteryBoardService_BoardStackProxy$set__data(value) {
        this._boardStackVO = value;
        return value;
    },
    
    _mergeData: function LotteryBoardService_BoardStackProxy$_mergeData(boardStackVO) {
        if (!isNullOrUndefined(boardStackVO.seriesID)) {
            this.set_seriesId(boardStackVO.seriesID);
        }
        if (!isNullOrUndefined(boardStackVO.viewState)) {
            this.set_viewState(boardStackVO.viewState);
        }
    },
    
    get_boardCount: function LotteryBoardService_BoardStackProxy$get_boardCount() {
        return this._boards.length;
    },
    
    get_clientQP: function LotteryBoardService_BoardStackProxy$get_clientQP() {
        return this._dgGameConfigProxy.get_isClientQP();
    },
    
    get_remoteClientQP: function LotteryBoardService_BoardStackProxy$get_remoteClientQP() {
        return this._dgGameConfigProxy.get_isRemoteClientQP();
    },
    
    get_serverQP: function LotteryBoardService_BoardStackProxy$get_serverQP() {
        return this._dgGameConfigProxy.get_isServerQP();
    },
    
    get_partialQPAllowed: function LotteryBoardService_BoardStackProxy$get_partialQPAllowed() {
        return this._dgGameConfigVO.partialQPAllowed;
    },
    
    get_forceQP: function LotteryBoardService_BoardStackProxy$get_forceQP() {
        return this._boardStackVO.forceQP;
    },
    set_forceQP: function LotteryBoardService_BoardStackProxy$set_forceQP(value) {
        this._boardStackVO.forceQP = value;
        return value;
    },
    
    get_price: function LotteryBoardService_BoardStackProxy$get_price() {
        var price = 0;
        var $enum1 = this._boards.getEnumerator();
        while ($enum1.moveNext()) {
            var board = $enum1.get_current();
            price += board.get_price();
        }
        return price;
    },
    
    get_externalID: function LotteryBoardService_BoardStackProxy$get_externalID() {
        return this._dgGameConfigVO.externalID;
    },
    
    get_gameIndex: function LotteryBoardService_BoardStackProxy$get_gameIndex() {
        return this._dgGameConfigVO.gameIndex;
    },
    
    get_isAddon: function LotteryBoardService_BoardStackProxy$get_isAddon() {
        return this._dgGameConfigVO.isAddon;
    },
    
    get_boardCountMin: function LotteryBoardService_BoardStackProxy$get_boardCountMin() {
        return this._dgGameConfigVO.boardcountMin;
    },
    
    get_enabled: function LotteryBoardService_BoardStackProxy$get_enabled() {
        return this._enabled;
    },
    
    get_populatedBoardsCount: function LotteryBoardService_BoardStackProxy$get_populatedBoardsCount() {
        var counter = 0;
        var $enum1 = this._boards.getEnumerator();
        while ($enum1.moveNext()) {
            var board = $enum1.get_current();
            if (board.isPopulated()) {
                counter++;
            }
        }
        return counter;
    },
    
    get_seriesId: function LotteryBoardService_BoardStackProxy$get_seriesId() {
        return this._boardStackVO.seriesID;
    },
    set_seriesId: function LotteryBoardService_BoardStackProxy$set_seriesId(value) {
        this._boardStackVO.seriesID = value;
        return value;
    },
    
    get_viewState: function LotteryBoardService_BoardStackProxy$get_viewState() {
        return this._boardStackVO.viewState;
    },
    set_viewState: function LotteryBoardService_BoardStackProxy$set_viewState(value) {
        if (value === LotteryBoardService.ViewState.INPUT || value === LotteryBoardService.ViewState.CONFIRMATION || value === LotteryBoardService.ViewState.RESULT) {
            this._boardStackVO.viewState = value;
        }
        else {
            this._boardStackVO.viewState = LotteryBoardService.ViewState.INPUT;
        }
        return value;
    },
    
    get_drawNumbers: function LotteryBoardService_BoardStackProxy$get_drawNumbers() {
        return this._drawNumbers;
    },
    set_drawNumbers: function LotteryBoardService_BoardStackProxy$set_drawNumbers(value) {
        this._drawNumbers = value;
        return value;
    },
    
    getBoard: function LotteryBoardService_BoardStackProxy$getBoard(boardIndex) {
        return this._boards[boardIndex];
    },
    
    hasPopulatedBoard: function LotteryBoardService_BoardStackProxy$hasPopulatedBoard() {
        return this.get_populatedBoardsCount() > 0;
    },
    
    hasDirtyBoards: function LotteryBoardService_BoardStackProxy$hasDirtyBoards() {
        for (var i = 0; i < this.get_boardCount(); i++) {
            if (!this._boards[i].isPopulated() && !this._boards[i].isEmpty()) {
                return true;
            }
        }
        return false;
    },
    
    hasSameNumbersOutOfRange: function LotteryBoardService_BoardStackProxy$hasSameNumbersOutOfRange() {
        var $enum1 = this._boards.getEnumerator();
        while ($enum1.moveNext()) {
            var board = $enum1.get_current();
            if (!board.areSameNumbersInRange()) {
                return true;
            }
        }
        return false;
    },
    
    isEmpty: function LotteryBoardService_BoardStackProxy$isEmpty() {
        for (var i = 0; i < this.get_boardCount(); i++) {
            if (!this._boards[i].isEmpty()) {
                return false;
            }
        }
        return true;
    },
    
    getNumbers: function LotteryBoardService_BoardStackProxy$getNumbers() {
        var ass = [];
        for (var b = 0; b < this.get_boardCount(); b++) {
            for (var s = 0; s < this._boards[b].get_setCount(); s++) {
                for (var n = 0; n < this._boards[b].getSet(s).get_numberCount(); n++) {
                    ass.add(this._boards[b].getSet(s).getNumber(n));
                }
            }
        }
        return ass;
    },
    
    toString: function LotteryBoardService_BoardStackProxy$toString() {
        return 'Board: instanceID=' + this.instanceID;
    },
    
    addBoard: function LotteryBoardService_BoardStackProxy$addBoard(board) {
        var newIndex = this._boards.length;
        board._index = newIndex;
        board._boardStackProxy = this;
        this._boards[newIndex] = board;
    },
    
    clear: function LotteryBoardService_BoardStackProxy$clear() {
        for (var i = 0; i < this.get_boardCount(); i++) {
            this._boards[i]._clear();
        }
    },
    
    reset: function LotteryBoardService_BoardStackProxy$reset() {
        this.clear();
        if (this._dgGameConfigProxy.dgGameConfigVO.multiPickSystemsAllowed) {
            for (var i = 0; i < this.get_boardCount(); i++) {
                this._boards[i].set_pickSystem(null);
                for (var j = 0; j < this._boards[i].get__boardRows().length; j++) {
                    this._boards[i].get__boardRows()[j].price = null;
                }
            }
        }
        else {
            for (var i = 0; i < this.get_boardCount(); i++) {
                this._boards[i].set_pickSystem(this._dgGameConfigProxy.getDefaultPickSystem());
            }
        }
        this._boardStackVO.seriesID = this._dgGameConfigVO.defaultEditionSeriesID;
        this.set_viewState(LotteryBoardService.ViewState.INPUT);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.AbstractController

LotteryBoardService.AbstractController = function LotteryBoardService_AbstractController(instanceID, environment) {
    this._instanceID = instanceID;
    this._environment = environment;
}
LotteryBoardService.AbstractController.prototype = {
    _instanceID: null,
    _environment: null,
    
    get_instanceID: function LotteryBoardService_AbstractController$get_instanceID() {
        return this._instanceID;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryMessageEvent

LotteryBoardService.LotteryMessageEvent = function LotteryBoardService_LotteryMessageEvent(source, instanceID) {
    LotteryBoardService.LotteryMessageEvent.constructBase(this, [ source, instanceID ]);
}
LotteryBoardService.LotteryMessageEvent.prototype = {
    messageVO: null,
    isAlert: true,
    confirmationRequired: false,
    confirmCallback: null,
    rejectCallback: null,
    
    toString: function LotteryBoardService_LotteryMessageEvent$toString() {
        return LotteryBoardService.LotteryMessageEvent.callBase(this, 'toString') + ', messageId: ' + this.messageVO.messageID + '[' + Enum.toString(LotteryBoardService.MessageType, this.messageVO.messageType) + '], messagetitle: ' + this.messageVO.messageTitle + ', messageText: ' + this.messageVO.messageText;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.AbstractLotteryEvent

LotteryBoardService.AbstractLotteryEvent = function LotteryBoardService_AbstractLotteryEvent(source, instanceID) {
    this.source = source;
    this.instanceID = instanceID;
}
LotteryBoardService.AbstractLotteryEvent.prototype = {
    source: null,
    instanceID: null,
    
    toString: function LotteryBoardService_AbstractLotteryEvent$toString() {
        return 'instanceID=' + ((isNullOrUndefined(this.instanceID)) ? 'null' : this.instanceID);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.WagerProxy

LotteryBoardService.WagerProxy = function LotteryBoardService_WagerProxy(instanceID, dgConfigVO) {
    this._boardStacks = new Array(0);
    this._fundingTypes = new Array(0);
    this.instanceID = instanceID;
    this._dgConfigVO = dgConfigVO;
    this._mainGameConfigProxy = new LotteryBoardService.DGGameConfigProxy(dgConfigVO.games[0]);
    var nnew = new LotteryBoardService.WagerVO();
    nnew.editionCount = this._mainGameConfigProxy.dgGameConfigVO.editionCountDefault;
    nnew.editionSeriesID = this._mainGameConfigProxy.dgGameConfigVO.defaultEditionSeriesID;
    this.set__data(nnew);
}
LotteryBoardService.WagerProxy._numberToDate = function LotteryBoardService_WagerProxy$_numberToDate(milliseconds) {
    var date;
    if (isNullOrUndefined(milliseconds)) {
        date = null;
    }
    else {
        date = new Date();
        date.setTime(milliseconds);
    }
    return date;
}
LotteryBoardService.WagerProxy.prototype = {
    _dgConfigVO: null,
    _mainGameConfigProxy: null,
    instanceID: null,
    _wagerVO: null,
    _isSubscription: false,
    _paymentInstruments: null,
    
    get__data: function LotteryBoardService_WagerProxy$get__data() {
        return this._wagerVO;
    },
    set__data: function LotteryBoardService_WagerProxy$set__data(value) {
        this._wagerVO = value;
        this.set_editionSeriesID(value.editionSeriesID);
        return value;
    },
    
    _mergeData: function LotteryBoardService_WagerProxy$_mergeData(data) {
        if (!isNullOrUndefined(data.editionCount)) {
            this.set_editionCount(data.editionCount);
        }
        if (!isNullOrUndefined(data.editionSeriesID)) {
            this.set_editionSeriesID(data.editionSeriesID);
        }
    },
    
    editionSeriesChangeAllowed: function LotteryBoardService_WagerProxy$editionSeriesChangeAllowed() {
        return this._mainGameConfigProxy.dgGameConfigVO.editionSeriesAllowed && this._mainGameConfigProxy.dgGameConfigVO.advancedSeriesAllowed;
    },
    
    get_editionSeriesID: function LotteryBoardService_WagerProxy$get_editionSeriesID() {
        return this._wagerVO.editionSeriesID;
    },
    set_editionSeriesID: function LotteryBoardService_WagerProxy$set_editionSeriesID(value) {
        if (!this.editionSeriesChangeAllowed() && value !== this._mainGameConfigProxy.dgGameConfigVO.defaultEditionSeriesID) {
            throw new Error('Edition series changes not allowed');
        }
        this._wagerVO.editionSeriesID = value;
        var $enum1 = this._boardStacks.getEnumerator();
        while ($enum1.moveNext()) {
            var board = $enum1.get_current();
            board.set_seriesId(value);
        }
        return value;
    },
    
    getEventData: function LotteryBoardService_WagerProxy$getEventData(drawNumber) {
        return this._mainGameConfigProxy.getEventByDrawNumber(drawNumber);
    },
    
    getDrawData: function LotteryBoardService_WagerProxy$getDrawData(drawId) {
        return this._mainGameConfigProxy.getDrawByID(drawId);
    },
    
    get_wagerResult: function LotteryBoardService_WagerProxy$get_wagerResult() {
        return this._wagerVO.wagerResult;
    },
    set_wagerResult: function LotteryBoardService_WagerProxy$set_wagerResult(value) {
        this._wagerVO.wagerResult = value;
        return value;
    },
    
    get_isSubscriptionsAllowed: function LotteryBoardService_WagerProxy$get_isSubscriptionsAllowed() {
        return this._mainGameConfigProxy.dgGameConfigVO.isSubscriptionsAllowed;
    },
    
    get_subscriptionsNodeExpanded: function LotteryBoardService_WagerProxy$get_subscriptionsNodeExpanded() {
        return this._wagerVO.subscriptionsNodeExpanded;
    },
    set_subscriptionsNodeExpanded: function LotteryBoardService_WagerProxy$set_subscriptionsNodeExpanded(value) {
        this._wagerVO.subscriptionsNodeExpanded = value;
        return value;
    },
    
    get_viewState: function LotteryBoardService_WagerProxy$get_viewState() {
        return this._wagerVO.viewState;
    },
    set_viewState: function LotteryBoardService_WagerProxy$set_viewState(value) {
        if (value === LotteryBoardService.ViewState.INPUT || value === LotteryBoardService.ViewState.CONFIRMATION || value === LotteryBoardService.ViewState.RESULT) {
            this._wagerVO.viewState = value;
        }
        else {
            this._wagerVO.viewState = LotteryBoardService.ViewState.INPUT;
        }
        return value;
    },
    
    get_editionCount: function LotteryBoardService_WagerProxy$get_editionCount() {
        return this._wagerVO.editionCount;
    },
    set_editionCount: function LotteryBoardService_WagerProxy$set_editionCount(value) {
        this._wagerVO.editionCount = value;
        return value;
    },
    
    get_infoMessageVO: function LotteryBoardService_WagerProxy$get_infoMessageVO() {
        return this._wagerVO.infoMessageVO;
    },
    set_infoMessageVO: function LotteryBoardService_WagerProxy$set_infoMessageVO(value) {
        this._wagerVO.infoMessageVO = value;
        return value;
    },
    
    get_startDate: function LotteryBoardService_WagerProxy$get_startDate() {
        return LotteryBoardService.WagerProxy._numberToDate(this._wagerVO.startDate);
    },
    set_startDate: function LotteryBoardService_WagerProxy$set_startDate(value) {
        this._wagerVO.startDate = value.getTime();
        return value;
    },
    
    get_unlimited: function LotteryBoardService_WagerProxy$get_unlimited() {
        return this._wagerVO.unlimited;
    },
    set_unlimited: function LotteryBoardService_WagerProxy$set_unlimited(value) {
        this._wagerVO.unlimited = value;
        return value;
    },
    
    get_subscriptionsContinue: function LotteryBoardService_WagerProxy$get_subscriptionsContinue() {
        return this._wagerVO.subscriptionsContinue;
    },
    set_subscriptionsContinue: function LotteryBoardService_WagerProxy$set_subscriptionsContinue(value) {
        this._wagerVO.subscriptionsContinue = value;
        return value;
    },
    
    get_noOfWeeks: function LotteryBoardService_WagerProxy$get_noOfWeeks() {
        return this._wagerVO.numberOfWeeks;
    },
    set_noOfWeeks: function LotteryBoardService_WagerProxy$set_noOfWeeks(value) {
        this._wagerVO.numberOfWeeks = value;
        return value;
    },
    
    get_expiryDate: function LotteryBoardService_WagerProxy$get_expiryDate() {
        return LotteryBoardService.WagerProxy._numberToDate(this._wagerVO.expiryDate);
    },
    set_expiryDate: function LotteryBoardService_WagerProxy$set_expiryDate(value) {
        this._wagerVO.expiryDate = value.getTime();
        return value;
    },
    
    get_fundingTypeID: function LotteryBoardService_WagerProxy$get_fundingTypeID() {
        return this._wagerVO.fundingTypeID;
    },
    set_fundingTypeID: function LotteryBoardService_WagerProxy$set_fundingTypeID(value) {
        this._wagerVO.fundingTypeID = value;
        return value;
    },
    
    get_fundingTypes: function LotteryBoardService_WagerProxy$get_fundingTypes() {
        return this._fundingTypes;
    },
    
    get_schedulePeriodID: function LotteryBoardService_WagerProxy$get_schedulePeriodID() {
        return this._wagerVO.schedulePeriodID;
    },
    set_schedulePeriodID: function LotteryBoardService_WagerProxy$set_schedulePeriodID(value) {
        this._wagerVO.schedulePeriodID = value;
        return value;
    },
    
    get_scheduleOffset: function LotteryBoardService_WagerProxy$get_scheduleOffset() {
        return this._wagerVO.scheduleOffset;
    },
    set_scheduleOffset: function LotteryBoardService_WagerProxy$set_scheduleOffset(value) {
        this._wagerVO.scheduleOffset = value;
        return value;
    },
    
    get_paymentInstrumentID: function LotteryBoardService_WagerProxy$get_paymentInstrumentID() {
        return this._wagerVO.paymentInstrumentID;
    },
    set_paymentInstrumentID: function LotteryBoardService_WagerProxy$set_paymentInstrumentID(value) {
        this._wagerVO.paymentInstrumentID = value;
        return value;
    },
    
    get_paymentInstruments: function LotteryBoardService_WagerProxy$get_paymentInstruments() {
        return this._paymentInstruments;
    },
    
    get_lockFunds: function LotteryBoardService_WagerProxy$get_lockFunds() {
        return this._wagerVO.lockFunds;
    },
    set_lockFunds: function LotteryBoardService_WagerProxy$set_lockFunds(value) {
        this._wagerVO.lockFunds = value;
        return value;
    },
    
    get_guaranteedJackpot: function LotteryBoardService_WagerProxy$get_guaranteedJackpot() {
        return this._wagerVO.guaranteedJackpot;
    },
    set_guaranteedJackpot: function LotteryBoardService_WagerProxy$set_guaranteedJackpot(value) {
        this._wagerVO.guaranteedJackpot = value;
        return value;
    },
    
    get_rolloverAmount: function LotteryBoardService_WagerProxy$get_rolloverAmount() {
        return this._wagerVO.rolloverAmount;
    },
    set_rolloverAmount: function LotteryBoardService_WagerProxy$set_rolloverAmount(value) {
        this._wagerVO.rolloverAmount = value;
        return value;
    },
    
    getBoardStack: function LotteryBoardService_WagerProxy$getBoardStack(boardStackIndex) {
        return this._boardStacks[boardStackIndex];
    },
    
    get_boardStackCount: function LotteryBoardService_WagerProxy$get_boardStackCount() {
        return this._boardStacks.length;
    },
    
    get_totalPrice: function LotteryBoardService_WagerProxy$get_totalPrice() {
        var price = 0;
        var $enum1 = this._boardStacks.getEnumerator();
        while ($enum1.moveNext()) {
            var boardStack = $enum1.get_current();
            price += boardStack.get_price();
        }
        return price;
    },
    
    getSelectedFundingType: function LotteryBoardService_WagerProxy$getSelectedFundingType() {
        var $enum1 = this._fundingTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var fundingType = $enum1.get_current();
            if (fundingType.FundingTypeId === this._wagerVO.fundingTypeID) {
                return fundingType;
            }
        }
        return null;
    },
    
    getFirstEnabledFundingType: function LotteryBoardService_WagerProxy$getFirstEnabledFundingType() {
        var $enum1 = this._fundingTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var fundingType = $enum1.get_current();
            if (fundingType.enabled) {
                return fundingType;
            }
        }
        return null;
    },
    
    _mainBoardStack: null,
    
    get_mainBoardStack: function LotteryBoardService_WagerProxy$get_mainBoardStack() {
        return this._mainBoardStack;
    },
    
    addBoardStack: function LotteryBoardService_WagerProxy$addBoardStack(boardStack) {
        var newIndex = this._boardStacks.length;
        boardStack._wagerProxy = this;
        this._boardStacks[newIndex] = boardStack;
        if (!boardStack.get_isAddon()) {
            this._mainBoardStack = boardStack;
        }
    },
    
    clear: function LotteryBoardService_WagerProxy$clear() {
        for (var i = 0; i < this.get_boardStackCount(); i++) {
            this._boardStacks[i].clear();
        }
    },
    
    reset: function LotteryBoardService_WagerProxy$reset() {
        for (var i = 0; i < this.get_boardStackCount(); i++) {
            this._boardStacks[i].reset();
        }
        this._wagerVO.wagerResult = null;
        this._wagerVO.viewState = LotteryBoardService.ViewState.INPUT;
        this._wagerVO.editionCount = this._mainGameConfigProxy.dgGameConfigVO.editionCountDefault;
        this.set_editionSeriesID(this._boardStacks[0].get_seriesId());
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.WagerController

LotteryBoardService.WagerController = function LotteryBoardService_WagerController(instanceID, messages, lotteryContext, wagerProxy) {
    this._boardStackControllers$2 = new Array(0);
    LotteryBoardService.WagerController.constructBase(this, [ instanceID, messages, lotteryContext ]);
    this._wagerProxy$2 = wagerProxy;
    this._boardStackPropertyListener$2 = new LotteryBoardService._boardStackPropertyChangeListener(this);
    this._boardStackContentListener$2 = new LotteryBoardService._boardStackContentChangeListener(this);
    this._lotteryContext.userService.registerUserChangedListener(this);
}
LotteryBoardService.WagerController._createBoardStackInfo$2 = function LotteryBoardService_WagerController$_createBoardStackInfo$2(boardStackProxy, addonIndex) {
    var boardStackRequest = new DGEService.BoardStackInfo();
    boardStackRequest.GameId = boardStackProxy.get_externalID();
    boardStackRequest.SeriesId = boardStackProxy.get_seriesId();
    boardStackRequest.AddOnIndex = addonIndex;
    var boards = [];
    for (var b = 0; b < boardStackProxy.get_boardCount(); b++) {
        var boardProxy = boardStackProxy.getBoard(b);
        if (boardProxy.isPopulated()) {
            var boardRequest = new DGEService.BoardInfo();
            boardRequest.PickValues = boardProxy._getNumbersAsString();
            boardRequest.Stake = boardProxy.get_price();
            if (!isNullOrUndefined(boardProxy.get_pickSystem())) {
                boardRequest.PickSystem = boardProxy.get_pickSystem().id;
            }
            boardRequest.QuickPick = boardProxy.hasQPFields();
            boardRequest.Rows = new Array(0);
            for (var r = 0; r < boardProxy.get__boardRows().length; r++) {
                var boardRow = boardProxy.get__boardRows()[r];
                if (isNullOrUndefined(boardRow.price)) {
                    continue;
                }
                var boardRowRequest = new DGEService.BoardRowInfo();
                boardRowRequest.DrawId = boardRow.drawID;
                boardRowRequest.PickSystemId = boardRow.pickSystemId;
                if (isNullOrUndefined(boardRow.pickSystemId)) {
                    boardRowRequest.Stake = boardRow.price * boardProxy.get_pickSystem().combinations;
                }
                else {
                    boardRowRequest.Stake = boardRow.price;
                }
                boardRequest.Rows[boardRequest.Rows.length] = boardRowRequest;
            }
            boards.add(boardRequest);
        }
    }
    boardStackRequest.Boards = boards;
    return boardStackRequest;
}
LotteryBoardService.WagerController.prototype = {
    _wagerProxy$2: null,
    _boardStackPropertyListener$2: null,
    _boardStackContentListener$2: null,
    
    start: function LotteryBoardService_WagerController$start() {
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var controller = $enum1.get_current();
            controller.start();
        }
        this._changeState(this._wagerProxy$2.get_viewState());
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.alL_PROPERTIES_CHANGED, null, null);
        if (!isNullOrUndefined(this._wagerProxy$2.get_infoMessageVO())) {
            this.fireMessageEventType(this._wagerProxy$2.get_infoMessageVO().messageID, this._wagerProxy$2.get_infoMessageVO().messageTitle, this._wagerProxy$2.get_infoMessageVO().messageText, false, this._wagerProxy$2.get_infoMessageVO().messageType);
        }
        if (this._lotteryContext.userService.isLoggedIn()) {
            this.fetchFundingTypes();
        }
    },
    
    addChild: function LotteryBoardService_WagerController$addChild(childStackController) {
        this._boardStackControllers$2[this._boardStackControllers$2.length] = childStackController;
        childStackController.get_eventDispatcher().registerPropertyChangedListener(this._boardStackPropertyListener$2);
        childStackController.get_eventDispatcher().registerBoardContentChangedListener(this._boardStackContentListener$2);
    },
    
    get_wager: function LotteryBoardService_WagerController$get_wager() {
        return this._wagerProxy$2;
    },
    
    get_hasChildreen: function LotteryBoardService_WagerController$get_hasChildreen() {
        return this._boardStackControllers$2.length > 0;
    },
    
    get_boardStackControllers: function LotteryBoardService_WagerController$get_boardStackControllers() {
        return this._boardStackControllers$2;
    },
    
    fireMessageEventType: function LotteryBoardService_WagerController$fireMessageEventType(messageID, messageTitle, messageText, IsAlert, messageType) {
        var messageVO = LotteryBoardService.WagerController.callBase(this, 'fireMessageEventType', [ messageID, messageTitle, messageText, IsAlert, messageType ]);
        if (!IsAlert) {
            this._wagerProxy$2.set_infoMessageVO(messageVO);
        }
        return messageVO;
    },
    
    onUserChanged: function LotteryBoardService_WagerController$onUserChanged(userService) {
        if (userService.isLoggedIn()) {
            this.fetchFundingTypes();
        }
        else {
            this.reset();
        }
    },
    
    _changeState: function LotteryBoardService_WagerController$_changeState(viewState) {
        var oldState = this._wagerProxy$2.get_viewState();
        this._wagerProxy$2.set_viewState(viewState);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.vieW_STATE_CHANGED, viewState, oldState);
        if (this._wagerProxy$2.get_viewState() === LotteryBoardService.ViewState.INPUT) {
            this.fireMessageEventType(LotteryBoardService.LotteryMessages.INPUT, this.getMessage(LotteryBoardService.LotteryMessages.inpuT_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.INPUT), false, LotteryBoardService.MessageType.INFO);
        }
    },
    
    reset: function LotteryBoardService_WagerController$reset() {
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var controller = $enum1.get_current();
            controller.reset();
        }
        this._wagerProxy$2.reset();
        this._changeState(LotteryBoardService.ViewState.INPUT);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.alL_PROPERTIES_CHANGED, null, null);
    },
    
    setSeriesId: function LotteryBoardService_WagerController$setSeriesId(seriesID) {
        this._wagerProxy$2.set_editionSeriesID(seriesID);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.serieS_ID_CHANGED, seriesID, null);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._wagerProxy$2.get_totalPrice(), null);
    },
    
    setEditionCount: function LotteryBoardService_WagerController$setEditionCount(editionCount) {
        var dc = parseInt(editionCount);
        this._wagerProxy$2.set_editionCount(dc);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.editioN_COUNT_CHANGED, editionCount, null);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._wagerProxy$2.get_totalPrice(), null);
    },
    
    placeWager: function LotteryBoardService_WagerController$placeWager() {
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var controller = $enum1.get_current();
            if (!controller.validate()) {
                return;
            }
        }
        this._wagerProxy$2._isSubscription = false;
        this._changeAllStates$2(LotteryBoardService.ViewState.CONFIRMATION);
        this.fireMessageEventType('', this.getMessage(LotteryBoardService.LotteryMessages.confirM_PLACEMENT_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.confirM_PLACEMENT), false, LotteryBoardService.MessageType.WARNING);
    },
    
    subscribeWager: function LotteryBoardService_WagerController$subscribeWager() {
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var controller = $enum1.get_current();
            if (!controller.validate()) {
                return;
            }
        }
        this._wagerProxy$2._isSubscription = true;
        this._changeAllStates$2(LotteryBoardService.ViewState.CONFIRMATION);
        this.fireMessageEventType('', this.getMessage(LotteryBoardService.LotteryMessages.confirM_SUBSCRIPTION_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.confirM_SUBSCRIPTION), false, LotteryBoardService.MessageType.WARNING);
    },
    
    cancelWager: function LotteryBoardService_WagerController$cancelWager() {
        this._changeAllStates$2(LotteryBoardService.ViewState.INPUT);
    },
    
    confirmWager: function LotteryBoardService_WagerController$confirmWager(successCallback, failureCallback) {
        if (!this._lotteryContext.userService.isLoggedIn()) {
            this.fireMessageEvent(LotteryBoardService.LotteryMessages.loG_IN, this.getMessage(LotteryBoardService.LotteryMessages.loG_IN));
            failureCallback.invoke(null);
            return;
        }
        if (this._wagerProxy$2._isSubscription) {
            this._performSubscription$2(successCallback, failureCallback);
        }
        else {
            this._performPlacement$2(successCallback, failureCallback);
        }
    },
    
    _performPlacement$2: function LotteryBoardService_WagerController$_performPlacement$2(successCallback, failureCallback) {
        var wagerRequest = this._createWagerRequest$2();
        this.fireMessageEventType('', this.getMessage(LotteryBoardService.LotteryMessages.placemenT_IN_PROGRESS_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.placemenT_IN_PROGRESS), false, LotteryBoardService.MessageType.INFO);
        this._lotteryContext.dgeService.placeWager(Delegate.create(this, function(result) {
            var wagerResult = result;
            if (wagerResult.State === 'OPEN') {
                this._wagerProxy$2.clear();
                for (var b = 0; b < wagerResult.BoardStacks.length; b++) {
                    var boardStackResult = wagerResult.BoardStacks[b];
                    var boardIndex = 0;
                    if (!isNullOrUndefined(boardStackResult.AddOnIndex)) {
                        boardIndex = boardStackResult.AddOnIndex;
                    }
                    var boardStackController = this._boardStackControllers$2[boardIndex];
                    var drawNumbers = new Array(boardStackResult.Events.length);
                    var j = 0;
                    var $enum1 = boardStackResult.Events.getEnumerator();
                    while ($enum1.moveNext()) {
                        var info = $enum1.get_current();
                        drawNumbers[j++] = info.DrawNumber;
                    }
                    boardStackController.get_boardStack().set_drawNumbers(drawNumbers);
                    var boardResults = boardStackResult.Boards;
                    for (var i = 0; i < boardResults.length; i++) {
                        boardStackController.get_boardStack().getBoard(i)._setNumbersFromString(boardResults[i].PickValues);
                        var drawIds = null;
                        if (boardResults[i].Rows) {
                            drawIds = new Array(boardResults[i].Rows.length);
                            var k = 0;
                            var $enum2 = boardResults[i].Rows.getEnumerator();
                            while ($enum2.moveNext()) {
                                var row = $enum2.get_current();
                                drawIds[k++] = row.DrawId;
                            }
                        }
                        boardStackController.get_boardStack().getBoard(i).set_drawIds(drawIds);
                    }
                    var eventObject = new LotteryBoardService.BoardStackContentEvent(boardStackController, this._instanceID);
                    eventObject.selectedNumbersChanged = true;
                    boardStackController.fireContentEvent(eventObject);
                }
                this._wagerProxy$2.set_wagerResult(wagerResult);
                this._changeAllStates$2(LotteryBoardService.ViewState.RESULT);
                this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.wageR_RESULT_ID, wagerResult, null);
                successCallback.invoke(wagerResult);
                this._lotteryContext.accountService.fetchAccountsDetails();
                this.fireActionEvent(LotteryBoardService.LotteryActionEvent.wageR_PLACED);
                var msg = String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_OK), wagerResult.WagerReference);
                this.fireMessageEventType(LotteryBoardService.LotteryMessages.placE_OK, this.getMessage(LotteryBoardService.LotteryMessages.placE_OK_TITLE), msg, false, LotteryBoardService.MessageType.ACCEPTED);
            }
            else {
                failureCallback.invoke(null);
                var msg = (wagerResult.ErrorMessage) ? String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), wagerResult.ErrorMessage) : String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), 'unknown error');
                this.fireMessageEventType(LotteryBoardService.LotteryMessages.placE_FAILED, this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED_TITLE), msg, false, LotteryBoardService.MessageType.ERROR);
            }
        }), Delegate.create(this, function(exception) {
            failureCallback.invoke(exception);
            var msg = (exception) ? String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), exception.message) : String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), 'unknown error');
            this.fireMessageEventType(LotteryBoardService.LotteryMessages.placE_FAILED, this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED_TITLE), msg, false, LotteryBoardService.MessageType.ERROR);
        }), wagerRequest);
    },
    
    replayWager: function LotteryBoardService_WagerController$replayWager() {
        this.reset();
    },
    
    _changeAllStates$2: function LotteryBoardService_WagerController$_changeAllStates$2(viewState) {
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var controller = $enum1.get_current();
            controller._changeState(viewState);
        }
        this._changeState(viewState);
    },
    
    addToFavorites: function LotteryBoardService_WagerController$addToFavorites(successCallback, failureCallback) {
        if (!this._lotteryContext.userService.isLoggedIn()) {
            this.fireMessageEvent(LotteryBoardService.LotteryMessages.loG_IN, this.getMessage(LotteryBoardService.LotteryMessages.loG_IN));
            failureCallback.invoke(null);
            return;
        }
        var wagerRequest = this._createWagerRequest$2();
        this.fireMessageEventType(LotteryBoardService.LotteryMessages.favoriteS_IN_PROGRES, this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_IN_PROGRES), false, LotteryBoardService.MessageType.INFO);
        this._lotteryContext.dgeService.createFavoriteWager(Delegate.create(this, function() {
            this.fireMessageEventType(LotteryBoardService.LotteryMessages.favoriteS_OK, this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_OK), false, LotteryBoardService.MessageType.ACCEPTED);
            successCallback.invoke(null);
        }), Delegate.create(this, function(exception) {
            var msg = (exception) ? String.format(this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_FAILED), exception.message) : String.format(this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_FAILED), 'unknown error');
            this.fireMessageEventType(LotteryBoardService.LotteryMessages.favoriteS_FAILED, this.getMessage(LotteryBoardService.LotteryMessages.favoriteS_TITLE), msg, false, LotteryBoardService.MessageType.ERROR);
            failureCallback.invoke(exception);
        }), wagerRequest);
    },
    
    toggleSubscriptionsNode: function LotteryBoardService_WagerController$toggleSubscriptionsNode() {
        this._wagerProxy$2.set_subscriptionsNodeExpanded(!this._wagerProxy$2.get_subscriptionsNodeExpanded());
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.subscriptionS_NODE_CHANGED, this._wagerProxy$2.get_subscriptionsNodeExpanded(), !this._wagerProxy$2.get_subscriptionsNodeExpanded());
    },
    
    setUnlimited: function LotteryBoardService_WagerController$setUnlimited(value) {
        var oldValue = this._wagerProxy$2.get_unlimited();
        this._wagerProxy$2.set_unlimited(value);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.starT_DATE_CHANGED, value, oldValue);
    },
    
    setStartDate: function LotteryBoardService_WagerController$setStartDate(startDate) {
        var oldValue = this._wagerProxy$2.get_startDate();
        this._wagerProxy$2.set_startDate(startDate);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.starT_DATE_CHANGED, startDate, oldValue);
    },
    
    setSubscriptionsContinue: function LotteryBoardService_WagerController$setSubscriptionsContinue(subscriptionsContinue) {
        this._wagerProxy$2.set_subscriptionsContinue(subscriptionsContinue);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.continuE_FOR_CHANGED, null, null);
        this._checkFundingTypes$2();
    },
    
    _checkFundingTypes$2: function LotteryBoardService_WagerController$_checkFundingTypes$2() {
        if (this._wagerProxy$2.get_subscriptionsContinue() === LotteryBoardService.SubscriptionsContinue.INDEFINETELY) {
            var $enum1 = this._wagerProxy$2.get_fundingTypes().getEnumerator();
            while ($enum1.moveNext()) {
                var fundingType = $enum1.get_current();
                fundingType.enabled = !(fundingType.FundingTypeId === LotteryBoardService.FundingTypeIdList.owN_SCHEDULE_FIXED || fundingType.FundingTypeId === LotteryBoardService.FundingTypeIdList.synchronizeD_TOTAL);
            }
        }
        else {
            var $enum2 = this._wagerProxy$2.get_fundingTypes().getEnumerator();
            while ($enum2.moveNext()) {
                var fundingType = $enum2.get_current();
                fundingType.enabled = true;
            }
        }
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.fundinG_TYPE_LIST_CHANGED, null, null);
        var selectedFundingType = this._wagerProxy$2.getSelectedFundingType();
        if (isNullOrUndefined(selectedFundingType) || !selectedFundingType.enabled) {
            selectedFundingType = this._wagerProxy$2.getFirstEnabledFundingType();
        }
        var fundingTypeID = (!isNullOrUndefined(selectedFundingType)) ? selectedFundingType.FundingTypeId : null;
        this.setFundingType(fundingTypeID);
    },
    
    setNumberOfWeeks: function LotteryBoardService_WagerController$setNumberOfWeeks(weeks) {
        this._wagerProxy$2.set_noOfWeeks(weeks);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.continuE_FOR_CHANGED, null, null);
    },
    
    setExpiryDate: function LotteryBoardService_WagerController$setExpiryDate(date) {
        this._wagerProxy$2.set_expiryDate(date);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.continuE_FOR_CHANGED, null, null);
    },
    
    fetchFundingTypes: function LotteryBoardService_WagerController$fetchFundingTypes() {
        this._lotteryContext.dgeService.getFundingTypes(Delegate.create(this, function(result) {
            this._wagerProxy$2._fundingTypes = result;
            this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.fundinG_TYPE_LIST_CHANGED, null, null);
            this._checkFundingTypes$2();
        }), Delegate.create(this, function(exception) {
            this.fireMessageEvent('exception', 'FetchFundingTypes Exception:' + exception.message);
        }));
    },
    
    setFundingType: function LotteryBoardService_WagerController$setFundingType(fundingTypeID) {
        this._wagerProxy$2.set_fundingTypeID(fundingTypeID);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.fundinG_TYPE_CHANGED, null, null);
        this.fetchPaymentInstruments();
    },
    
    setSchedulePeriodID: function LotteryBoardService_WagerController$setSchedulePeriodID(schedulePeriodID) {
        this._wagerProxy$2.set_schedulePeriodID(schedulePeriodID);
        this._wagerProxy$2.set_scheduleOffset(null);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.schedulE_PERIOD_CHANGED, null, null);
    },
    
    setScheduleOffset: function LotteryBoardService_WagerController$setScheduleOffset(scheduleOffset) {
        this._wagerProxy$2.set_scheduleOffset(scheduleOffset);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.schedulE_OFFSET_CHANGED, null, null);
    },
    
    setLockFunds: function LotteryBoardService_WagerController$setLockFunds(value) {
        var oldValue = this._wagerProxy$2.get_lockFunds();
        this._wagerProxy$2.set_lockFunds(value);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.locK_FUNDS_CHANGED, value, oldValue);
    },
    
    fetchPaymentInstruments: function LotteryBoardService_WagerController$fetchPaymentInstruments() {
        if (this._wagerProxy$2.get_fundingTypeID()) {
            this._lotteryContext.dgeService.getPaymentInstrumentsForDgSubscriptions(Delegate.create(this, function(result) {
                this._wagerProxy$2._paymentInstruments = result;
                this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.paymenT_INSTRUMENT_LIST_CHANGED, null, null);
                this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.paymenT_INSTRUMENT_CHANGED, this._wagerProxy$2.get_paymentInstrumentID(), null);
            }), Delegate.create(this, function(exception) {
                this.fireMessageEvent('exception', 'FetchPaymentInstruments Exception:' + exception.message);
            }), this._wagerProxy$2.get_fundingTypeID());
        }
        else {
            this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.paymenT_INSTRUMENT_LIST_CHANGED, null, null);
        }
    },
    
    setPaymentInstrument: function LotteryBoardService_WagerController$setPaymentInstrument(paymentInstrumentID) {
        this._wagerProxy$2.set_paymentInstrumentID(paymentInstrumentID);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.paymenT_INSTRUMENT_CHANGED, null, null);
    },
    
    setGuaranteedJackpot: function LotteryBoardService_WagerController$setGuaranteedJackpot(guaranteedJackpot) {
        this._wagerProxy$2.set_guaranteedJackpot(guaranteedJackpot);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.guaranteeD_JACKPOT_CHANGED, null, null);
    },
    
    setRolloverAmount: function LotteryBoardService_WagerController$setRolloverAmount(rolloverAmount) {
        this._wagerProxy$2.set_rolloverAmount(rolloverAmount);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.rolloveR_AMOUNT_CHANGED, null, null);
    },
    
    _performSubscription$2: function LotteryBoardService_WagerController$_performSubscription$2(successCallback, failureCallback) {
        var subscriptionRequest = this._createSubscriptionRequest$2();
        this.fireMessageEventType('', this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_IN_PROGRESS_TITLE), this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_IN_PROGRESS), false, LotteryBoardService.MessageType.INFO);
        this._lotteryContext.dgeService.createSubscription(Delegate.create(this, function(result) {
            var subscriptionID = result;
            if (!this._wagerProxy$2.get_wagerResult()) {
                this._wagerProxy$2.set_wagerResult(new DGEService.WagerResult());
            }
            this._wagerProxy$2.get_wagerResult().WagerReference = subscriptionID.toString();
            var $enum1 = this._boardStackControllers$2.getEnumerator();
            while ($enum1.moveNext()) {
                var boardController = $enum1.get_current();
                var eventObject = new LotteryBoardService.BoardStackContentEvent(boardController, this._instanceID);
                eventObject.selectedNumbersChanged = true;
                boardController.fireContentEvent(eventObject);
            }
            this._changeAllStates$2(LotteryBoardService.ViewState.RESULT);
            this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.wageR_RESULT_ID, this._wagerProxy$2.get_wagerResult(), null);
            successCallback.invoke(subscriptionID.toString());
            this._lotteryContext.accountService.fetchAccountsDetails();
            this.fireActionEvent(LotteryBoardService.LotteryActionEvent.wageR_SUBSCRIBED);
            var msg = String.format(this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_OK), this._wagerProxy$2.get_wagerResult().WagerReference);
            this.fireMessageEventType(LotteryBoardService.LotteryMessages.subscriptioN_OK, this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_OK_TITLE), msg, false, LotteryBoardService.MessageType.ACCEPTED);
        }), Delegate.create(this, function(exception) {
            failureCallback.invoke(exception);
            var msg = (exception) ? String.format(this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_FAILED), exception.message) : String.format(this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_FAILED), 'unknown error');
            this.fireMessageEventType(LotteryBoardService.LotteryMessages.placE_FAILED, this.getMessage(LotteryBoardService.LotteryMessages.subscriptioN_FAILED_TITLE), msg, false, LotteryBoardService.MessageType.ERROR);
        }), subscriptionRequest);
    },
    
    _createWagerRequest$2: function LotteryBoardService_WagerController$_createWagerRequest$2() {
        var wagerRequest = new DGEService.WagerRequest();
        wagerRequest.EditionCount = this._wagerProxy$2.get_editionCount();
        wagerRequest.BoardStacks = this._createBoardStackListRequest$2();
        return wagerRequest;
    },
    
    _createSubscriptionRequest$2: function LotteryBoardService_WagerController$_createSubscriptionRequest$2() {
        var subscriptionRequest = new DGEService.SubscriptionRequest();
        if (!isNullOrUndefined(this._wagerProxy$2.get_guaranteedJackpot()) || !isNullOrUndefined(this._wagerProxy$2.get_rolloverAmount())) {
            subscriptionRequest.Conditions = new Array(0);
            if (!isNullOrUndefined(this._wagerProxy$2.get_guaranteedJackpot())) {
                var sciGuaranteedJackpot = new DGEService.SubscriptionConditionInfo();
                sciGuaranteedJackpot.ParameterName = 'GameDraw.winStructure.guaranteedJackpot';
                sciGuaranteedJackpot.Condition = 'ge';
                sciGuaranteedJackpot.Value = this._wagerProxy$2.get_guaranteedJackpot().toString();
                subscriptionRequest.Conditions[subscriptionRequest.Conditions.length] = sciGuaranteedJackpot;
            }
            if (!isNullOrUndefined(this._wagerProxy$2.get_rolloverAmount())) {
                var sciRolloverAmount = new DGEService.SubscriptionConditionInfo();
                sciRolloverAmount.ParameterName = 'GameDraw.winStructure.rolloverAmount';
                sciRolloverAmount.Condition = 'ge';
                sciRolloverAmount.Value = this._wagerProxy$2.get_rolloverAmount().toString();
                subscriptionRequest.Conditions[subscriptionRequest.Conditions.length] = sciRolloverAmount;
            }
        }
        subscriptionRequest.BoardStacks = this._createBoardStackListRequest$2();
        subscriptionRequest.StartTime = (this._wagerProxy$2.get_unlimited()) ? null : Framework.JSONFormat.formatDateTime(this._wagerProxy$2.get_startDate());
        subscriptionRequest.TotalEditions = null;
        subscriptionRequest.ExpiryTime = null;
        if (this._wagerProxy$2.get_subscriptionsContinue() === LotteryBoardService.SubscriptionsContinue.nO_OF_WEEKS) {
            subscriptionRequest.TotalEditions = this._wagerProxy$2.get_noOfWeeks();
        }
        else if (this._wagerProxy$2.get_subscriptionsContinue() === LotteryBoardService.SubscriptionsContinue.expirY_DATE) {
            subscriptionRequest.ExpiryTime = Framework.JSONFormat.formatDateTime(this._wagerProxy$2.get_expiryDate());
        }
        subscriptionRequest.LockFunds = false;
        subscriptionRequest.FundingType = this._wagerProxy$2.get_fundingTypeID();
        subscriptionRequest.PaymentInstrumentId = this._wagerProxy$2.get_paymentInstrumentID();
        if (this._wagerProxy$2.get_fundingTypeID() === LotteryBoardService.FundingTypeIdList.owN_SCHEDULE_FIXED || this._wagerProxy$2.get_fundingTypeID() === LotteryBoardService.FundingTypeIdList.owN_SCHEDULE_VARIABLE) {
            subscriptionRequest.SchedulePeriod = this._wagerProxy$2.get_schedulePeriodID();
            subscriptionRequest.ScheduleOffset = this._wagerProxy$2.get_scheduleOffset();
        }
        return subscriptionRequest;
    },
    
    _createBoardStackListRequest$2: function LotteryBoardService_WagerController$_createBoardStackListRequest$2() {
        var boardStackRequests = new Array(0);
        for (var i = 0; i < this._boardStackControllers$2.length; i++) {
            var stackController = this._boardStackControllers$2[i];
            if (stackController.get_boardStack().hasPopulatedBoard()) {
                var index = (stackController.get_boardStack().get_isAddon()) ? i : null;
                var boardRequest = LotteryBoardService.WagerController._createBoardStackInfo$2(stackController.get_boardStack(), index);
                boardStackRequests[boardStackRequests.length] = boardRequest;
            }
        }
        return boardStackRequests;
    },
    
    setState: function LotteryBoardService_WagerController$setState(state) {
        var wagerVO = state;
        if (wagerVO.boardStackVOList[0].viewState === LotteryBoardService.ViewState.RESULT) {
            this._wagerProxy$2.reset();
        }
        else {
            this._wagerProxy$2.set__data(wagerVO);
            for (var r = 0; r < wagerVO.boardStackVOList.length; r++) {
                this._boardStackControllers$2[r].setState(wagerVO.boardStackVOList[r]);
            }
        }
    },
    
    mergeState: function LotteryBoardService_WagerController$mergeState(state) {
        var wagerVO = state;
        this._wagerProxy$2._mergeData(wagerVO);
        var someIsHit = false;
        var boardStates = wagerVO.boardStackVOList.clone();
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var boardController = $enum1.get_current();
            var $enum2 = boardStates.getEnumerator();
            while ($enum2.moveNext()) {
                var boardState = $enum2.get_current();
                if (boardController.get_boardStack().get_externalID() !== boardState.externalID) {
                    continue;
                }
                someIsHit = true;
                boardController.mergeState(boardState);
                boardStates.remove(boardState);
                break;
            }
        }
        if (!someIsHit) {
            throw new Error('Favorite is not for me!');
        }
    },
    
    getState: function LotteryBoardService_WagerController$getState() {
        var wagerVO = this._wagerProxy$2.get__data();
        wagerVO.boardStackVOList = new Array(this._wagerProxy$2.get_boardStackCount());
        for (var i = 0; i < this._wagerProxy$2.get_boardStackCount(); i++) {
            wagerVO.boardStackVOList[i] = this._boardStackControllers$2[i].getState();
        }
        return wagerVO;
    },
    
    _setAddonsEnabled: function LotteryBoardService_WagerController$_setAddonsEnabled(enabled) {
        var $enum1 = this._boardStackControllers$2.getEnumerator();
        while ($enum1.moveNext()) {
            var controller = $enum1.get_current();
            var board = controller.get_boardStack();
            if (board.get_isAddon() && board.get_enabled() !== enabled) {
                controller.setEnabled(enabled);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService._boardStackPropertyChangeListener

LotteryBoardService._boardStackPropertyChangeListener = function LotteryBoardService__boardStackPropertyChangeListener(controller) {
    this._wagerController = controller;
}
LotteryBoardService._boardStackPropertyChangeListener.prototype = {
    _wagerController: null,
    
    onLotteryPropertyChanged: function LotteryBoardService__boardStackPropertyChangeListener$onLotteryPropertyChanged(eventObject) {
        if (eventObject.propertyName === LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED) {
            this._wagerController.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._wagerController.get_wager().get_totalPrice(), null);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService._boardStackContentChangeListener

LotteryBoardService._boardStackContentChangeListener = function LotteryBoardService__boardStackContentChangeListener(controller) {
    this._wagerController = controller;
}
LotteryBoardService._boardStackContentChangeListener.prototype = {
    _wagerController: null,
    
    onBoardStackContentChanged: function LotteryBoardService__boardStackContentChangeListener$onBoardStackContentChanged(eventObject) {
        var boardStackController = eventObject.source;
        if (!boardStackController.get_boardStack().get_isAddon()) {
            if (boardStackController.get_boardStack().hasPopulatedBoard()) {
                this._wagerController._setAddonsEnabled(true);
            }
            else {
                this._wagerController._setAddonsEnabled(false);
            }
        }
        this._wagerController.get_eventDispatcher()._dispatchContentEvent(eventObject);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.AbstractSportsEvent

LotteryBoardService.AbstractSportsEvent = function LotteryBoardService_AbstractSportsEvent(InstanceID) {
    this.instanceID = InstanceID;
}
LotteryBoardService.AbstractSportsEvent.prototype = {
    source: null,
    instanceID: null,
    
    toString: function LotteryBoardService_AbstractSportsEvent$toString() {
        return 'instanceID=' + ((isNullOrUndefined(this.instanceID)) ? 'null' : this.instanceID);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsBoardContext

LotteryBoardService.SportsBoardContext = function LotteryBoardService_SportsBoardContext(instanceID) {
    this.viewState = LotteryBoardService.SportsViewState.INPUT;
    this._rows = new Array(0);
    this._qPtype = LotteryBoardService.SportsQPType.server;
    this.instanceID = instanceID;
}
LotteryBoardService.SportsBoardContext.create = function LotteryBoardService_SportsBoardContext$create(instanceID, initData, messages) {
    var sportsBoardContext = new LotteryBoardService.SportsBoardContext(instanceID);
    sportsBoardContext.messages = messages;
    sportsBoardContext._sets = initData.sets;
    sportsBoardContext._priceBase = initData.priceBase;
    sportsBoardContext._priceMax = initData.priceMax;
    sportsBoardContext.seriesId = initData.seriesID;
    sportsBoardContext._externalID = initData.externalID;
    sportsBoardContext.editionCount = initData.editionCountDefault;
    switch (initData.clientQP) {
        case 'server':
            sportsBoardContext._qPtype = LotteryBoardService.SportsQPType.server;
            break;
        case 'client':
            sportsBoardContext._qPtype = LotteryBoardService.SportsQPType.clientRandom;
            break;
        default:
            sportsBoardContext._qPtype = LotteryBoardService.SportsQPType.clientRandom;
            break;
    }
    sportsBoardContext._pickSystems = initData.pickSystems;
    sportsBoardContext._gameEvents = initData.gameEvents;
    sportsBoardContext._gameDraws = initData.gameDraws;
    var defaultPickSystemID = initData.pickSystemID;
    var $enum1 = initData.pickSystems.getEnumerator();
    while ($enum1.moveNext()) {
        var system = $enum1.get_current();
        if (system.id === defaultPickSystemID) {
            sportsBoardContext._defaultPickSystem = system;
            break;
        }
    }
    var rowcount = initData.rowcount;
    for (var i = 0; i < initData.rowcount; i++) {
        var row = new LotteryBoardService.SportsRowContext();
        sportsBoardContext.addRow(row);
        row.set_pickSystem(sportsBoardContext._defaultPickSystem);
    }
    sportsBoardContext._events = initData.events;
    sportsBoardContext._symbolsMap = initData.symbolsMap;
    return sportsBoardContext;
}
LotteryBoardService.SportsBoardContext.prototype = {
    instanceID: null,
    infoMessage: null,
    messages: null,
    seriesId: null,
    editionCount: null,
    _externalID: null,
    _gameIndex: null,
    _drawNumbers: null,
    _priceBase: null,
    _priceMax: null,
    _pickSystems: null,
    _defaultPickSystem: null,
    _sets: null,
    _events: null,
    _symbolsMap: null,
    _wagerResult: null,
    _gameEvents: null,
    _gameDraws: null,
    
    get_size: function LotteryBoardService_SportsBoardContext$get_size() {
        return this._rows.length;
    },
    
    get_price: function LotteryBoardService_SportsBoardContext$get_price() {
        var price = 0;
        var $enum1 = this._rows.getEnumerator();
        while ($enum1.moveNext()) {
            var row = $enum1.get_current();
            price += row.get_price();
        }
        return price;
    },
    
    get_wagerResult: function LotteryBoardService_SportsBoardContext$get_wagerResult() {
        return this._wagerResult;
    },
    
    get_drawNumbers: function LotteryBoardService_SportsBoardContext$get_drawNumbers() {
        return this._drawNumbers;
    },
    
    get_externalID: function LotteryBoardService_SportsBoardContext$get_externalID() {
        return this._externalID;
    },
    
    get_gameIndex: function LotteryBoardService_SportsBoardContext$get_gameIndex() {
        return this._gameIndex;
    },
    
    getRow: function LotteryBoardService_SportsBoardContext$getRow(rowIndex) {
        return this._rows[rowIndex];
    },
    
    isValidForPlacement: function LotteryBoardService_SportsBoardContext$isValidForPlacement() {
        var $enum1 = this._rows.getEnumerator();
        while ($enum1.moveNext()) {
            var row = $enum1.get_current();
            if (row.isValidForPlacement()) {
                return true;
            }
        }
        return false;
    },
    
    isPopulated: function LotteryBoardService_SportsBoardContext$isPopulated() {
        var $enum1 = this._rows.getEnumerator();
        while ($enum1.moveNext()) {
            var row = $enum1.get_current();
            if (!row.get_isPopulated()) {
                return false;
            }
        }
        return true;
    },
    
    getPickSystem: function LotteryBoardService_SportsBoardContext$getPickSystem(systemID) {
        var $enum1 = this._pickSystems.getEnumerator();
        while ($enum1.moveNext()) {
            var system = $enum1.get_current();
            if (system.id === systemID) {
                return system;
            }
        }
        return null;
    },
    
    getEvent: function LotteryBoardService_SportsBoardContext$getEvent(drawNumber) {
        var $enum1 = this._gameEvents.getEnumerator();
        while ($enum1.moveNext()) {
            var eventInit = $enum1.get_current();
            if (eventInit.drawNumber === drawNumber) {
                return eventInit;
            }
        }
        return null;
    },
    
    getDraw: function LotteryBoardService_SportsBoardContext$getDraw(drawId) {
        var $enum1 = this._gameDraws.getEnumerator();
        while ($enum1.moveNext()) {
            var drawInit = $enum1.get_current();
            if (drawInit.drawId === drawId) {
                return drawInit;
            }
        }
        return null;
    },
    
    get_vievState: function LotteryBoardService_SportsBoardContext$get_vievState() {
        return this.viewState;
    },
    
    get_events: function LotteryBoardService_SportsBoardContext$get_events() {
        return this._events;
    },
    set_events: function LotteryBoardService_SportsBoardContext$set_events(value) {
        this._events = value;
        return value;
    },
    
    addRow: function LotteryBoardService_SportsBoardContext$addRow(row) {
        var newIndex = this._rows.length;
        row._index = newIndex;
        row._boardContext = this;
        this._rows[newIndex] = row;
    },
    
    clear: function LotteryBoardService_SportsBoardContext$clear() {
        var $enum1 = this._rows.getEnumerator();
        while ($enum1.moveNext()) {
            var row = $enum1.get_current();
            row._clear();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsPickSystem

LotteryBoardService.SportsPickSystem = function LotteryBoardService_SportsPickSystem() {
}
LotteryBoardService.SportsPickSystem.prototype = {
    id: null,
    name: null,
    combinations: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsRowContext

LotteryBoardService.SportsRowContext = function LotteryBoardService_SportsRowContext() {
    this._index = -1;
    this._setList = new Array(0);
}
LotteryBoardService.SportsRowContext.prototype = {
    _boardContext: null,
    _quickPick: false,
    _pickSystem: null,
    _drawIds: null,
    
    getSet: function LotteryBoardService_SportsRowContext$getSet(setIndex) {
        return this._setList[setIndex];
    },
    
    get_drawIds: function LotteryBoardService_SportsRowContext$get_drawIds() {
        return this._drawIds;
    },
    set_drawIds: function LotteryBoardService_SportsRowContext$set_drawIds(value) {
        this._drawIds = value;
        return value;
    },
    
    get_size: function LotteryBoardService_SportsRowContext$get_size() {
        return this._setList.length;
    },
    
    get_pickSystem: function LotteryBoardService_SportsRowContext$get_pickSystem() {
        return this._pickSystem;
    },
    set_pickSystem: function LotteryBoardService_SportsRowContext$set_pickSystem(value) {
        var selections = this._collectCurrentSelections();
        this._pickSystem = value;
        this._removeSets();
        for (var s = 0; s < this._pickSystem.sets.length; s++) {
            var set = this._boardContext._sets[s];
            var setCtx = new LotteryBoardService.SportsSetContext(set.count, set.symbols, set.repetitionAllowed, set.ordered);
            for (var n = 0; n < set.count; n++) {
                setCtx._addSelection(new LotteryBoardService.SportsSelectionContext());
            }
            this._addSet(setCtx);
        }
        this._quickPick = false;
        this._restoreSelections(selections);
        return value;
    },
    
    _collectCurrentSelections: function LotteryBoardService_SportsRowContext$_collectCurrentSelections() {
        var selections = new Array(this._setList.length);
        for (var i = 0; i < this._setList.length; i++) {
            selections[i] = this._setList[i]._getSelectionsAsString();
        }
        return selections;
    },
    
    _restoreSelections: function LotteryBoardService_SportsRowContext$_restoreSelections(selections) {
        for (var i = 0; i < selections.length; i++) {
            this._setList[i]._setSelectionsFromString(selections[i]);
        }
    },
    
    get_price: function LotteryBoardService_SportsRowContext$get_price() {
        return this._pickSystem.combinations * this._boardContext._priceBase;
    },
    
    get_isPopulated: function LotteryBoardService_SportsRowContext$get_isPopulated() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            if (!set.get_isPopulated()) {
                return false;
            }
        }
        return true;
    },
    
    get_isEmpty: function LotteryBoardService_SportsRowContext$get_isEmpty() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            if (!set.get_isEmpty()) {
                return false;
            }
        }
        return true;
    },
    
    isQuickPick: function LotteryBoardService_SportsRowContext$isQuickPick() {
        return this._quickPick;
    },
    
    isValidForPlacement: function LotteryBoardService_SportsRowContext$isValidForPlacement() {
        if (this.isQuickPick()) {
            return true;
        }
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            if (!set.get_isPopulated()) {
                return false;
            }
        }
        return this._checkExactNumberOfCombinations();
    },
    
    _addSet: function LotteryBoardService_SportsRowContext$_addSet(set) {
        var newIndex = this._setList.length;
        set._index = newIndex;
        set._row = this;
        this._setList[newIndex] = set;
    },
    
    _removeSets: function LotteryBoardService_SportsRowContext$_removeSets() {
        (this._setList).clear();
    },
    
    _clear: function LotteryBoardService_SportsRowContext$_clear() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            set._clear();
        }
        this._quickPick = false;
    },
    
    _performQuickPick: function LotteryBoardService_SportsRowContext$_performQuickPick() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            set._performQuickPick();
        }
        this._quickPick = true;
    },
    
    _getSelectionsAsString: function LotteryBoardService_SportsRowContext$_getSelectionsAsString() {
        var sb = new StringBuilder();
        for (var s = 0; s < this._setList.length; s++) {
            var setCtx = this.getSet(s);
            sb.append(setCtx._getSelectionsAsString());
            if (s < this._setList.length - 1) {
                sb.append(':');
            }
        }
        return sb.toString();
    },
    
    _setSelectionsFromString: function LotteryBoardService_SportsRowContext$_setSelectionsFromString(strSelections) {
        var selsArray = strSelections.split(':');
        for (var s = 0; s < this._setList.length; s++) {
            this.getSet(s)._setSelectionsFromString(selsArray[s]);
        }
    },
    
    _getUsedCombinations: function LotteryBoardService_SportsRowContext$_getUsedCombinations() {
        var counter = 1;
        for (var s = 0; s < this._setList.length; s++) {
            counter = counter * this._setList[s]._getUsedCombinations();
        }
        return counter;
    },
    
    _checkExactNumberOfCombinations: function LotteryBoardService_SportsRowContext$_checkExactNumberOfCombinations() {
        return this.get_pickSystem().combinations === this._getUsedCombinations();
    },
    
    _checkTooManyCombinations: function LotteryBoardService_SportsRowContext$_checkTooManyCombinations() {
        return (this.get_pickSystem().combinations >= this._getUsedCombinations()) && this._checkDoublesCount() && this._checkTriplesCount();
    },
    
    _checkDoublesCount: function LotteryBoardService_SportsRowContext$_checkDoublesCount() {
        for (var i = 0; i < this._setList.length; i++) {
            var currentNumberOfDoubleSelections = this._setList[i]._getNumberOfDoubleSelections();
            var allowedNumberOfDoubleSelections = this.get_pickSystem().sets[i].doublesCount;
            if (currentNumberOfDoubleSelections > allowedNumberOfDoubleSelections) {
                return false;
            }
        }
        return true;
    },
    
    _checkTriplesCount: function LotteryBoardService_SportsRowContext$_checkTriplesCount() {
        for (var i = 0; i < this._setList.length; i++) {
            var currentNumberOfTripleSelections = this._setList[i]._getNumberOfTripleSelections();
            var allowedNumberOfTripleSelections = this.get_pickSystem().sets[i].triplesCount;
            if (currentNumberOfTripleSelections > allowedNumberOfTripleSelections) {
                return false;
            }
        }
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsSelectionContext

LotteryBoardService.SportsSelectionContext = function LotteryBoardService_SportsSelectionContext() {
    this._index = -1;
}
LotteryBoardService.SportsSelectionContext.prototype = {
    _set: null,
    _entry: '',
    _value: '',
    _errorMessage: null,
    
    get_set: function LotteryBoardService_SportsSelectionContext$get_set() {
        return this._set;
    },
    
    get_index: function LotteryBoardService_SportsSelectionContext$get_index() {
        return this._index;
    },
    
    get_errorMessageID: function LotteryBoardService_SportsSelectionContext$get_errorMessageID() {
        return this._errorMessage;
    },
    
    get_value: function LotteryBoardService_SportsSelectionContext$get_value() {
        return this._value;
    },
    
    get_entry: function LotteryBoardService_SportsSelectionContext$get_entry() {
        return this._entry;
    },
    
    isPopulated: function LotteryBoardService_SportsSelectionContext$isPopulated() {
        return this._value !== String.Empty || this._entry === 'QP';
    },
    
    isEmpty: function LotteryBoardService_SportsSelectionContext$isEmpty() {
        return (this._entry === String.Empty);
    },
    
    isQuickPick: function LotteryBoardService_SportsSelectionContext$isQuickPick() {
        return this._entry === 'QP';
    },
    
    _setEntry: function LotteryBoardService_SportsSelectionContext$_setEntry(input) {
        this._entry = '';
        this._value = '';
        this._errorMessage = null;
        if (isNullOrUndefined(input) || !input.length) {
            return;
        }
        if (input === 'QP') {
            this._entry = input;
            return;
        }
        this._entry = input;
        this._value = input;
    },
    
    _clear: function LotteryBoardService_SportsSelectionContext$_clear() {
        this._entry = String.Empty;
        this._value = String.Empty;
    },
    
    _setAsQuickPick: function LotteryBoardService_SportsSelectionContext$_setAsQuickPick() {
        this._entry = 'QP';
        this._value = '';
    },
    
    getSelectionAsString: function LotteryBoardService_SportsSelectionContext$getSelectionAsString() {
        var cometitors = new Array(0);
        for (var i = 0; i < this._set.get_events()[this._index].competitors.length; i++) {
            cometitors[i] = this._set.get_events()[this._index].competitors[i].name;
        }
        var stringBuilder = new StringBuilder();
        for (var i = 0; i < cometitors.length; i++) {
            stringBuilder.append(cometitors[i]);
            if (i < cometitors.length - 1) {
                stringBuilder.append('-');
            }
        }
        return stringBuilder.toString();
    },
    
    getSelectionSymbol: function LotteryBoardService_SportsSelectionContext$getSelectionSymbol() {
        return this._value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsSetContext

LotteryBoardService.SportsSetContext = function LotteryBoardService_SportsSetContext(count, symbols, repetitionAllowed, ordered) {
    this._index = -1;
    this._selections = new Array(0);
    this.count = count;
    this.symbols = symbols;
    this.repetitionAllowed = repetitionAllowed;
    this.ordered = ordered;
}
LotteryBoardService.SportsSetContext._getRandomNumber = function LotteryBoardService_SportsSetContext$_getRandomNumber(max) {
    return Math.floor(Math.random() * max + 1);
}
LotteryBoardService.SportsSetContext.prototype = {
    _row: null,
    count: null,
    symbols: null,
    repetitionAllowed: false,
    ordered: false,
    
    get_size: function LotteryBoardService_SportsSetContext$get_size() {
        return this._selections.length;
    },
    
    get_row: function LotteryBoardService_SportsSetContext$get_row() {
        return this._row;
    },
    
    get_index: function LotteryBoardService_SportsSetContext$get_index() {
        return this._index;
    },
    
    getSelectionContext: function LotteryBoardService_SportsSetContext$getSelectionContext(selectionIndex) {
        return this._selections[selectionIndex];
    },
    
    get_isPopulated: function LotteryBoardService_SportsSetContext$get_isPopulated() {
        var $enum1 = this._selections.getEnumerator();
        while ($enum1.moveNext()) {
            var sel = $enum1.get_current();
            if (!sel.isPopulated()) {
                return false;
            }
        }
        return true;
    },
    
    get_isEmpty: function LotteryBoardService_SportsSetContext$get_isEmpty() {
        var $enum1 = this._selections.getEnumerator();
        while ($enum1.moveNext()) {
            var sel = $enum1.get_current();
            if (!sel.isEmpty()) {
                return false;
            }
        }
        return true;
    },
    
    get_events: function LotteryBoardService_SportsSetContext$get_events() {
        return this._row._boardContext.get_events();
    },
    
    _addSelection: function LotteryBoardService_SportsSetContext$_addSelection(selection) {
        var newIndex = this._selections.length;
        selection._index = newIndex;
        selection._set = this;
        this._selections[newIndex] = selection;
    },
    
    _clear: function LotteryBoardService_SportsSetContext$_clear() {
        var $enum1 = this._selections.getEnumerator();
        while ($enum1.moveNext()) {
            var sel = $enum1.get_current();
            sel._clear();
        }
    },
    
    _performQuickPick: function LotteryBoardService_SportsSetContext$_performQuickPick() {
        switch (this._row._boardContext._qPtype) {
            case LotteryBoardService.SportsQPType.client:
                this._clientQP();
                break;
            case LotteryBoardService.SportsQPType.clientRandom:
                this._clientRandomQP();
                break;
        }
    },
    
    _clientRandomQP: function LotteryBoardService_SportsSetContext$_clientRandomQP() {
        this._clear();
        var numOfDoubles = this._row.get_pickSystem().sets[this._index].doublesCount;
        var numOfTriples = this._row.get_pickSystem().sets[this._index].triplesCount;
        var availableIndexes = [];
        for (var i = 0; i < this.count; i++) {
            availableIndexes.add(i);
        }
        var length = 3;
        for (var i = 0; i < numOfTriples; i++) {
            this._createRandomSelection(length, 3, availableIndexes);
        }
        for (var i = 0; i < numOfDoubles; i++) {
            this._createRandomSelection(length, 2, availableIndexes);
        }
        for (var i = 0; i < this.count - numOfDoubles - numOfTriples; i++) {
            this._createRandomSelection(length, 1, availableIndexes);
        }
    },
    
    _createRandomSelection: function LotteryBoardService_SportsSetContext$_createRandomSelection(outcomeLength, countToGenerate, availableIndexes) {
        var unusedArrayInd = LotteryBoardService.SportsSetContext._getRandomNumber(availableIndexes.length) - 1;
        var ind = availableIndexes.removeAt(unusedArrayInd);
        var usedSelections = [];
        for (var i = 0; i < countToGenerate; i++) {
            var generated;
            do {
                generated = LotteryBoardService.SportsSetContext._getRandomNumber(outcomeLength) - 1;
            } while (usedSelections.indexOf(generated) !== -1);
            usedSelections.add(generated);
        }
        for (var i = 0; i < usedSelections.length - 1; i++) {
            for (var j = i + 1; j < usedSelections.length; j++) {
                if (usedSelections[i] > usedSelections[j]) {
                    var temp = usedSelections[i];
                    usedSelections[i] = usedSelections[j];
                    usedSelections[j] = temp;
                }
            }
        }
        var selection = String.Empty;
        for (var i = 0; i < usedSelections.length; i++) {
            selection += this.get_events()[ind].outcomes[usedSelections[i]].name;
        }
        var selCtx = this.getSelectionContext(ind);
        selCtx._setEntry(selection.toString());
    },
    
    _clientQP: function LotteryBoardService_SportsSetContext$_clientQP() {
        this._clear();
        var selectionCount = this.count;
        var numOfDoubles = this._row.get_pickSystem().sets[this._index].doublesCount;
        var numOfTriples = this._row.get_pickSystem().sets[this._index].triplesCount;
        var firstProb = new Array(0);
        var secondProb = new Array(0);
        var thirdProb = new Array(0);
        this._rangProbabs(firstProb, secondProb, thirdProb, selectionCount);
        this._sortDoublesAndTriples(secondProb, thirdProb, selectionCount);
        var selections = new Array(selectionCount);
        for (var i = 0; i < selections.length; i++) {
            selections[i] = String.Empty;
        }
        this._fillSelections(firstProb, secondProb, thirdProb, selectionCount, numOfDoubles, numOfTriples, selections);
        for (var i1 = 0; i1 < selectionCount; i1++) {
            var selCtx = this.getSelectionContext(i1);
            selCtx._setEntry(selections[i1].toString());
        }
    },
    
    _rangProbabs: function LotteryBoardService_SportsSetContext$_rangProbabs(fProb, sProb, tProb, selCount) {
        for (var p = 0; p < selCount; p++) {
            var length = 3;
            var outcomes = new Array(length);
            for (var q = 0; q < length; q++) {
                outcomes[q] = this.get_events()[p].outcomes[q];
            }
            for (var r = 0; r < length - 1; r++) {
                for (var s = r + 1; s < length; s++) {
                    if (outcomes[r].prob < outcomes[s].prob) {
                        var temp = outcomes[r];
                        outcomes[r] = outcomes[s];
                        outcomes[s] = temp;
                    }
                }
            }
            fProb[p] = new LotteryBoardService._outcomeWithIndex();
            sProb[p] = new LotteryBoardService._outcomeWithIndex();
            tProb[p] = new LotteryBoardService._outcomeWithIndex();
            fProb[p].rowindex = p;
            fProb[p].outcome = outcomes[0];
            sProb[p].rowindex = p;
            sProb[p].outcome = outcomes[1];
            tProb[p].rowindex = p;
            tProb[p].outcome = outcomes[2];
        }
    },
    
    _sortDoublesAndTriples: function LotteryBoardService_SportsSetContext$_sortDoublesAndTriples(second_prob, third_prob, selCnt) {
        for (var a = 0; a < selCnt - 1; a++) {
            for (var b = a + 1; b < selCnt; b++) {
                if (second_prob[a].outcome.prob < second_prob[b].outcome.prob) {
                    var temp = second_prob[a];
                    second_prob[a] = second_prob[b];
                    second_prob[b] = temp;
                }
                if (third_prob[a].outcome.prob < third_prob[b].outcome.prob) {
                    var temp = third_prob[a];
                    third_prob[a] = third_prob[b];
                    third_prob[b] = temp;
                }
            }
        }
    },
    
    _fillSelections: function LotteryBoardService_SportsSetContext$_fillSelections(fProb, sProb, tProb, selCount, dblCount, triCount, selections) {
        for (var m = 0; m < selCount; m++) {
            var rowIndex = fProb[m].rowindex;
            if (fProb[m].outcome.id === 1) {
                selections[rowIndex] += fProb[m].outcome.name;
            }
            if (fProb[m].outcome.id === 2) {
                selections[rowIndex] += fProb[m].outcome.name;
            }
            if (fProb[m].outcome.id === 3) {
                selections[rowIndex] += fProb[m].outcome.name;
            }
        }
        for (var m = 0; m < dblCount + triCount; m++) {
            var rowIndex = sProb[m].rowindex;
            if (sProb[m].outcome.id === 1) {
                selections[rowIndex] += sProb[m].outcome.name;
            }
            if (sProb[m].outcome.id === 2) {
                selections[rowIndex] += sProb[m].outcome.name;
            }
            if (sProb[m].outcome.id === 3) {
                selections[rowIndex] += sProb[m].outcome.name;
            }
        }
        for (var m = 0; m < triCount; m++) {
            var rowIndex = tProb[m].rowindex;
            if (tProb[m].outcome.id === 1) {
                selections[rowIndex] += tProb[m].outcome.name;
            }
            if (tProb[m].outcome.id === 2) {
                selections[rowIndex] += tProb[m].outcome.name;
            }
            if (tProb[m].outcome.id === 3) {
                selections[rowIndex] += tProb[m].outcome.name;
            }
        }
        for (var row = 0; row < selCount; row++) {
            var sel = '';
            for (var j = 0; j < this.symbols.length; j++) {
                var c = this.symbols.charAt(j);
                if (selections[row].indexOf(c) >= 0) {
                    sel += c;
                }
            }
            selections[row] = sel;
        }
    },
    
    _getSelectionsAsString: function LotteryBoardService_SportsSetContext$_getSelectionsAsString() {
        var sb = new StringBuilder();
        for (var n = 0; n < this._selections.length; n++) {
            sb.append(this.getSelectionContext(n).get_entry());
            if (n < this._selections.length - 1) {
                sb.append(',');
            }
        }
        return sb.toString();
    },
    
    _setSelectionsFromString: function LotteryBoardService_SportsSetContext$_setSelectionsFromString(strSelections) {
        var selsArray = strSelections.split(',');
        for (var n = 0; n < this._selections.length; n++) {
            this.getSelectionContext(n)._setEntry(selsArray[n]);
        }
    },
    
    _getNumberOfDoubleSelections: function LotteryBoardService_SportsSetContext$_getNumberOfDoubleSelections() {
        var numberOfDoubles = 0;
        for (var j = 0; j < this.get_size(); j++) {
            var selectionContext = this.getSelectionContext(j);
            var entry = selectionContext.get_entry();
            if (isNullOrUndefined(entry)) {
                continue;
            }
            if (entry.length === 2) {
                numberOfDoubles++;
            }
        }
        return numberOfDoubles;
    },
    
    _getNumberOfTripleSelections: function LotteryBoardService_SportsSetContext$_getNumberOfTripleSelections() {
        var numberOfTriples = 0;
        for (var j = 0; j < this.get_size(); j++) {
            var selectionContext = this.getSelectionContext(j);
            var entry = selectionContext.get_entry();
            if (isNullOrUndefined(entry)) {
                continue;
            }
            if (entry.length === 3) {
                numberOfTriples++;
            }
        }
        return numberOfTriples;
    },
    
    _getUsedCombinations: function LotteryBoardService_SportsSetContext$_getUsedCombinations() {
        var counter = 1;
        for (var t = 0; t < this.get_size(); t++) {
            var selectionContext = this.getSelectionContext(t);
            counter *= (!selectionContext.get_entry().length) ? 1 : selectionContext.get_entry().length;
        }
        return counter;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService._outcomeWithIndex

LotteryBoardService._outcomeWithIndex = function LotteryBoardService__outcomeWithIndex() {
}
LotteryBoardService._outcomeWithIndex.prototype = {
    outcome: null,
    rowindex: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsMessage

LotteryBoardService.SportsMessage = function LotteryBoardService_SportsMessage() {
    this.messageType = LotteryBoardService.SportsMessageType.INFO;
}
LotteryBoardService.SportsMessage.prototype = {
    messageID: null,
    messageTitle: '???',
    messageText: '???'
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsBoardContentEvent

LotteryBoardService.SportsBoardContentEvent = function LotteryBoardService_SportsBoardContentEvent(InstanceID) {
    LotteryBoardService.SportsBoardContentEvent.constructBase(this, [ InstanceID ]);
}
LotteryBoardService.SportsBoardContentEvent.prototype = {
    sportsPickSystem: null,
    sportsBoardChanged: false,
    rowIndex: null,
    setIndex: null,
    selectionIndex: null,
    selectionChoiceIndex: null,
    oldEntry: null,
    newEntry: null,
    price: null,
    wagerResultReference: null,
    messageInfo: null,
    
    toString: function LotteryBoardService_SportsBoardContentEvent$toString() {
        return LotteryBoardService.SportsBoardContentEvent.callBase(this, 'toString') + ', SportsBoardChanged=' + this.sportsBoardChanged + ', row=' + this.rowIndex + ', set=' + this.setIndex + ', SelectionIndex=' + this.selectionIndex + ', SelectionChoiceIndex=' + this.selectionChoiceIndex + ', oldEntry=' + this.oldEntry + ', newEntry=' + this.newEntry;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsBoardInitData

LotteryBoardService.SportsBoardInitData = function LotteryBoardService_SportsBoardInitData() {
}
LotteryBoardService.SportsBoardInitData.prototype = {
    clientQP: null,
    seriesID: null,
    editionCountDefault: null,
    pickSystemID: null,
    externalID: null,
    priceBase: null,
    priceMax: null,
    rowcount: null,
    sets: null,
    pickSystems: null,
    events: null,
    selections: null,
    symbolsMap: null,
    gameEvents: null,
    gameDraws: null,
    instanceID: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsSetInitData

LotteryBoardService.SportsSetInitData = function LotteryBoardService_SportsSetInitData() {
}
LotteryBoardService.SportsSetInitData.prototype = {
    id: null,
    count: null,
    symbols: null,
    repetitionAllowed: false,
    ordered: false
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsSystemsInitData

LotteryBoardService.SportsSystemsInitData = function LotteryBoardService_SportsSystemsInitData() {
}
LotteryBoardService.SportsSystemsInitData.prototype = {
    id: null,
    name: null,
    combinations: null,
    sets: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsSystemsSetsInitData

LotteryBoardService.SportsSystemsSetsInitData = function LotteryBoardService_SportsSystemsSetsInitData() {
}
LotteryBoardService.SportsSystemsSetsInitData.prototype = {
    id: null,
    doublesCount: null,
    triplesCount: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsEvents

LotteryBoardService.SportsEvents = function LotteryBoardService_SportsEvents() {
}
LotteryBoardService.SportsEvents.prototype = {
    competitors: null,
    outcomes: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsCompetitors

LotteryBoardService.SportsCompetitors = function LotteryBoardService_SportsCompetitors() {
}
LotteryBoardService.SportsCompetitors.prototype = {
    id: null,
    name: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsOutcome

LotteryBoardService.SportsOutcome = function LotteryBoardService_SportsOutcome() {
}
LotteryBoardService.SportsOutcome.prototype = {
    id: null,
    name: null,
    prob: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.GameDrawInitData

LotteryBoardService.GameDrawInitData = function LotteryBoardService_GameDrawInitData() {
}
LotteryBoardService.GameDrawInitData.prototype = {
    drawId: null,
    name: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsBoardStateData

LotteryBoardService.SportsBoardStateData = function LotteryBoardService_SportsBoardStateData() {
}
LotteryBoardService.SportsBoardStateData.prototype = {
    seriesID: null,
    editionCount: null,
    sportsViewState: 0,
    wagerResult: null,
    rowStates: null,
    infoMessage: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsRowStateData

LotteryBoardService.SportsRowStateData = function LotteryBoardService_SportsRowStateData() {
}
LotteryBoardService.SportsRowStateData.prototype = {
    quickPick: false,
    sportsPickSystemID: null,
    selectionValues: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsBoardStateEvent

LotteryBoardService.SportsBoardStateEvent = function LotteryBoardService_SportsBoardStateEvent(InstanceID) {
    this.state = LotteryBoardService.SportsViewState.UNKNOWN;
    LotteryBoardService.SportsBoardStateEvent.constructBase(this, [ InstanceID ]);
}
LotteryBoardService.SportsBoardStateEvent.prototype = {
    
    toString: function LotteryBoardService_SportsBoardStateEvent$toString() {
        return LotteryBoardService.SportsBoardStateEvent.callBase(this, 'toString') + ', view state: ' + this.state;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsControllerFactory

LotteryBoardService.SportsControllerFactory = function LotteryBoardService_SportsControllerFactory(lotterybBoardService, initData, messages) {
    LotteryBoardService.SportsControllerFactory.constructBase(this, [ lotterybBoardService, initData.instanceID ]);
    this._initData$1 = initData;
    this._messages$1 = messages;
}
LotteryBoardService.SportsControllerFactory.prototype = {
    _initData$1: null,
    _messages$1: null,
    
    doCreate: function LotteryBoardService_SportsControllerFactory$doCreate() {
        var sbCtx = LotteryBoardService.SportsBoardContext.create(this._instanceID, this._initData$1, this._messages$1);
        var sportsController = new LotteryBoardService.SportsController(this._lotteryBoardService, sbCtx, this._lotteryBoardService.get__lotteryContext().environment, this._lotteryBoardService.get__lotteryContext().log);
        return sportsController;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryControllerFactory

LotteryBoardService.LotteryControllerFactory = function LotteryBoardService_LotteryControllerFactory(instanceContext) {
    LotteryBoardService.LotteryControllerFactory.constructBase(this, [ instanceContext.lotteryBoardService, instanceContext.instanceID ]);
    this._instanceContext$1 = instanceContext;
    this._lotteryContext$1 = instanceContext.lotteryBoardService.get__lotteryContext();
}
LotteryBoardService.LotteryControllerFactory.prototype = {
    _lotteryContext$1: null,
    _instanceContext$1: null,
    
    doCreate: function LotteryBoardService_LotteryControllerFactory$doCreate() {
        var wagerProxy = new LotteryBoardService.WagerProxy(this._instanceContext$1.instanceID, this._instanceContext$1.dgConfigVO);
        var wagerController = new LotteryBoardService.WagerController(this._instanceContext$1.instanceID, this._instanceContext$1.messages, this._instanceContext$1.lotteryBoardService.get__lotteryContext(), wagerProxy);
        var games = this._instanceContext$1.dgConfigVO.games;
        if (!isNullOrUndefined(games)) {
            for (var i = 0; i < games.length; i++) {
                var boardInstanceID = this._instanceContext$1.instanceID + '-board' + i;
                var dgGameConfigProxy = new LotteryBoardService.DGGameConfigProxy(games[i]);
                var boardStackProxy = new LotteryBoardService.BoardStackProxy(boardInstanceID, dgGameConfigProxy);
                var boardStackController = new LotteryBoardService.BoardStackController(boardInstanceID, dgGameConfigProxy, this._instanceContext$1.messages, this._lotteryContext$1, boardStackProxy);
                wagerProxy.addBoardStack(boardStackProxy);
                wagerController.addChild(boardStackController);
            }
        }
        return wagerController;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsController

LotteryBoardService.SportsController = function LotteryBoardService_SportsController(lotteryService, sportsBoardContext, environment, log) {
    this._sportsBoardContentChangedListeners$1 = new Framework.ListenerInvoker(true);
    LotteryBoardService.SportsController.constructBase(this, [ sportsBoardContext.instanceID, environment ]);
    this._lotteryService = lotteryService;
    this._dgeService = lotteryService.get__lotteryContext().dgeService;
    this._accountService = lotteryService.get__lotteryContext().accountService;
    this._userService = lotteryService.get__lotteryContext().userService;
    this._log = log;
    this._sportsBoardContext$1 = sportsBoardContext;
}
LotteryBoardService.SportsController._createBoardStackInfo$1 = function LotteryBoardService_SportsController$_createBoardStackInfo$1(boardContext) {
    var boardStackRequest = new DGEService.BoardStackInfo();
    boardStackRequest.GameId = boardContext._externalID;
    boardStackRequest.SeriesId = boardContext.seriesId;
    var boards = [];
    for (var r = 0; r < boardContext.get_size(); r++) {
        var rowContext = boardContext.getRow(r);
        if (rowContext.get_isPopulated()) {
            var boardRequest = new DGEService.BoardInfo();
            boardRequest.PickSystem = rowContext.get_pickSystem().id;
            boardRequest.QuickPick = rowContext.isQuickPick();
            boardRequest.Stake = rowContext.get_price();
            boardRequest.PickValues = rowContext._getSelectionsAsString();
            boards.add(boardRequest);
        }
    }
    boardStackRequest.Boards = boards;
    return boardStackRequest;
}
LotteryBoardService.SportsController.prototype = {
    _lotteryService: null,
    _dgeService: null,
    _accountService: null,
    _userService: null,
    _log: null,
    _sportsBoardContext$1: null,
    
    start: function LotteryBoardService_SportsController$start() {
        this.changeState(LotteryBoardService.SportsViewState.INPUT);
    },
    
    setState: function LotteryBoardService_SportsController$setState(state) {
        var sportsBoardState = state;
        this._sportsBoardContext$1.seriesId = sportsBoardState.seriesID;
        this._sportsBoardContext$1.editionCount = sportsBoardState.editionCount;
        this._sportsBoardContext$1.viewState = sportsBoardState.sportsViewState;
        this._sportsBoardContext$1._wagerResult = sportsBoardState.wagerResult;
        this._sportsBoardContext$1.infoMessage = sportsBoardState.infoMessage;
        for (var r = 0; r < sportsBoardState.rowStates.length; r++) {
            var rowStateData = sportsBoardState.rowStates[r];
            this._sportsBoardContext$1.getRow(r).set_pickSystem(this._sportsBoardContext$1.getPickSystem(rowStateData.sportsPickSystemID));
            this._sportsBoardContext$1.getRow(r)._setSelectionsFromString(rowStateData.selectionValues);
            this._sportsBoardContext$1.getRow(r)._quickPick = rowStateData.quickPick;
        }
    },
    
    mergeState: function LotteryBoardService_SportsController$mergeState(state) {
        this.setState(state);
    },
    
    getState: function LotteryBoardService_SportsController$getState() {
        var boardState = new LotteryBoardService.SportsBoardStateData();
        boardState.seriesID = this._sportsBoardContext$1.seriesId;
        boardState.editionCount = this._sportsBoardContext$1.editionCount;
        boardState.sportsViewState = this._sportsBoardContext$1.viewState;
        boardState.wagerResult = this._sportsBoardContext$1.get_wagerResult();
        boardState.infoMessage = this._sportsBoardContext$1.infoMessage;
        boardState.rowStates = new Array(0);
        for (var i = 0; i < this._sportsBoardContext$1.get_size(); i++) {
            var rowState = new LotteryBoardService.SportsRowStateData();
            rowState.quickPick = this._sportsBoardContext$1.getRow(i).isQuickPick();
            rowState.sportsPickSystemID = this._sportsBoardContext$1.getRow(i).get_pickSystem().id;
            rowState.selectionValues = this._sportsBoardContext$1.getRow(i)._getSelectionsAsString();
            boardState.rowStates[i] = rowState;
        }
        return boardState;
    },
    
    get_board: function LotteryBoardService_SportsController$get_board() {
        return this._sportsBoardContext$1;
    },
    
    getMessage: function LotteryBoardService_SportsController$getMessage(messageID) {
        return this._sportsBoardContext$1.messages[messageID];
    },
    
    get_price: function LotteryBoardService_SportsController$get_price() {
        return this._sportsBoardContext$1.get_price();
    },
    
    _warnIfQP$1: function LotteryBoardService_SportsController$_warnIfQP$1(rowindex, response) {
        var row = this._sportsBoardContext$1.getRow(rowindex);
        var isQP = row.isQuickPick();
        if (isQP) {
            this._fireConfirmMessageEvent$1(LotteryBoardService.SportsMessages.cleaR_QUICK_PICK, this.getMessage(LotteryBoardService.SportsMessages.cleaR_QUICK_PICK), Delegate.create(this, function() {
                this.clearRow(rowindex);
                response.invoke(true);
            }), Delegate.create(this, function() {
                var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
                eventObject.sportsBoardChanged = true;
                eventObject.rowIndex = rowindex;
                eventObject.price = this._sportsBoardContext$1.get_price();
                this._fireChangedEvent$1(eventObject);
                response.invoke(false);
            }));
        }
        return isQP;
    },
    
    injectSelection: function LotteryBoardService_SportsController$injectSelection(value, rowIndex, setIndex, selectionIndex, response) {
        if (!this._warnIfQP$1(rowIndex, response)) {
            return this.doInjectSelection(value, rowIndex, setIndex, selectionIndex);
        }
        return false;
    },
    
    _checkTooManyCombinations$1: function LotteryBoardService_SportsController$_checkTooManyCombinations$1(rowIndex) {
        return this._sportsBoardContext$1.getRow(rowIndex)._checkTooManyCombinations();
    },
    
    doInjectSelection: function LotteryBoardService_SportsController$doInjectSelection(value, rowIndex, setIndex, selectionIndex) {
        var wasPopulated = this._sportsBoardContext$1.getRow(rowIndex).get_isPopulated();
        var rowCtx = this._sportsBoardContext$1.getRow(rowIndex);
        var setCtx = rowCtx.getSet(setIndex);
        var selectionCtx = setCtx.getSelectionContext(selectionIndex);
        var oldEntry = selectionCtx.get_entry();
        selectionCtx._setEntry(value);
        this._applyMinimalPickSystemWhichCanContainNewSelectionForRowAndSet$1(rowIndex, setIndex);
        if (!this._checkTooManyCombinations$1(rowIndex)) {
            this._fireMessageEvent$1(LotteryBoardService.SportsMessages.exceedeD_NUMBER_OF_SELECTIONS, this.getMessage(LotteryBoardService.SportsMessages.exceedeD_NUMBER_OF_SELECTIONS));
            selectionCtx._setEntry(oldEntry);
        }
        var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
        eventObject.sportsBoardChanged = true;
        eventObject.rowIndex = rowIndex;
        eventObject.setIndex = setIndex;
        eventObject.selectionIndex = selectionIndex;
        eventObject.oldEntry = oldEntry;
        eventObject.newEntry = selectionCtx.get_entry();
        if (wasPopulated !== this._sportsBoardContext$1.getRow(rowIndex).get_isPopulated()) {
            eventObject.price = this._sportsBoardContext$1.get_price();
        }
        this._fireChangedEvent$1(eventObject);
        if (selectionCtx.get_errorMessageID()) {
            var msg = this.getMessage(selectionCtx.get_errorMessageID());
            this._fireMessageEvent$1(selectionCtx.get_errorMessageID(), msg);
            return false;
        }
        return true;
    },
    
    quickPick: function LotteryBoardService_SportsController$quickPick(rowIndex) {
        var rowCtx = this._sportsBoardContext$1.getRow(rowIndex);
        if (!rowCtx.get_isEmpty() && !rowCtx.isQuickPick()) {
            this._fireConfirmMessageEvent$1(LotteryBoardService.SportsMessages.cleaR_NUMBERS, this.getMessage(LotteryBoardService.SportsMessages.cleaR_NUMBERS), Delegate.create(this, function() {
                window.setTimeout(Delegate.create(this, function() {
                    this.clearRow(rowIndex);
                    this._performQuckPick$1(rowIndex);
                }), 20);
            }), Delegate.create(this, function() {
            }));
        }
        else {
            window.setTimeout(Delegate.create(this, function() {
                this._performQuckPick$1(rowIndex);
            }), 20);
        }
    },
    
    _performQuckPick$1: function LotteryBoardService_SportsController$_performQuckPick$1(rowIndex) {
        this._sportsBoardContext$1.getRow(rowIndex)._performQuickPick();
        var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
        eventObject.sportsBoardChanged = true;
        eventObject.rowIndex = rowIndex;
        eventObject.price = this._sportsBoardContext$1.get_price();
        this._fireChangedEvent$1(eventObject);
    },
    
    clearBoard: function LotteryBoardService_SportsController$clearBoard() {
        this._sportsBoardContext$1.clear();
        var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
        eventObject.sportsBoardChanged = true;
        eventObject.price = this._sportsBoardContext$1.get_price();
        this._fireChangedEvent$1(eventObject);
    },
    
    clearRow: function LotteryBoardService_SportsController$clearRow(rowindex) {
        this._sportsBoardContext$1.getRow(rowindex)._clear();
        var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
        eventObject.sportsBoardChanged = true;
        eventObject.rowIndex = rowindex;
        eventObject.price = this._sportsBoardContext$1.get_price();
        this._fireChangedEvent$1(eventObject);
    },
    
    setPickSystem: function LotteryBoardService_SportsController$setPickSystem(rowindex, pickSystemID) {
        var rowContext = this._sportsBoardContext$1.getRow(rowindex);
        var pickSystem = this._sportsBoardContext$1.getPickSystem(pickSystemID);
        if (!this._isPickSystemValidForRow$1(rowContext, pickSystem)) {
            var eventObjectStayOld = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
            eventObjectStayOld.sportsBoardChanged = true;
            eventObjectStayOld.sportsPickSystem = rowContext.get_pickSystem().id;
            eventObjectStayOld.rowIndex = rowindex;
            eventObjectStayOld.price = this.get_price();
            this._fireChangedEvent$1(eventObjectStayOld);
            return;
        }
        rowContext.set_pickSystem(pickSystem);
        var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
        eventObject.sportsBoardChanged = true;
        eventObject.sportsPickSystem = pickSystemID;
        eventObject.rowIndex = rowindex;
        eventObject.price = this.get_price();
        this._fireChangedEvent$1(eventObject);
    },
    
    changeState: function LotteryBoardService_SportsController$changeState(viewState) {
        this._sportsBoardContext$1.viewState = viewState;
        var eventObject = new LotteryBoardService.SportsBoardStateEvent(this._instanceID);
        eventObject.state = viewState;
        this._dispatchStateEvent(eventObject);
        if (viewState === LotteryBoardService.SportsViewState.INPUT) {
            this._fireMessageEventType$1(LotteryBoardService.SportsMessages.INPUT, this.getMessage(LotteryBoardService.SportsMessages.inpuT_TITLE), this.getMessage(LotteryBoardService.SportsMessages.INPUT), false, LotteryBoardService.SportsMessageType.INFO);
        }
    },
    
    placeBoard: function LotteryBoardService_SportsController$placeBoard() {
        this.changeState(LotteryBoardService.SportsViewState.CONFIRMATION);
        this._fireMessageEventType$1('', this.getMessage(LotteryBoardService.SportsMessages.confirM_PLACEMENT_TITLE), this.getMessage(LotteryBoardService.SportsMessages.confirM_PLACEMENT), false, LotteryBoardService.SportsMessageType.WARNING);
    },
    
    cancelBoard: function LotteryBoardService_SportsController$cancelBoard() {
        this.changeState(LotteryBoardService.SportsViewState.INPUT);
    },
    
    confirmBoard: function LotteryBoardService_SportsController$confirmBoard(successCallback, failureCallback) {
        if (!this._userService.isLoggedIn()) {
            this._fireMessageEvent$1(LotteryBoardService.SportsMessages.loG_IN, this.getMessage(LotteryBoardService.SportsMessages.loG_IN));
            failureCallback.invoke(null);
            return;
        }
        this._performPlacement$1(successCallback, failureCallback);
    },
    
    _performPlacement$1: function LotteryBoardService_SportsController$_performPlacement$1(successCallback, failureCallback) {
        var wagerRequest = this._createWagerRequest$1();
        this._fireMessageEventType$1(LotteryBoardService.SportsMessages.placemenT_IN_PROGRESS, this.getMessage(LotteryBoardService.SportsMessages.placemenT_IN_PROGRESS_TITLE), this.getMessage(LotteryBoardService.SportsMessages.placemenT_IN_PROGRESS), false, LotteryBoardService.SportsMessageType.INFO);
        this._dgeService.placeWager(Delegate.create(this, function(result) {
            var wagerResult = result;
            if (wagerResult.State === 'OPEN') {
                this._sportsBoardContext$1.clear();
                for (var b = 0; b < wagerResult.BoardStacks.length; b++) {
                    var boardStackResult = wagerResult.BoardStacks[b];
                    var drawNumbers = new Array(boardStackResult.Events.length);
                    var j = 0;
                    var $enum1 = boardStackResult.Events.getEnumerator();
                    while ($enum1.moveNext()) {
                        var info = $enum1.get_current();
                        drawNumbers[j++] = info.DrawNumber;
                    }
                    this._sportsBoardContext$1._drawNumbers = drawNumbers;
                    var boardResults = boardStackResult.Boards;
                    for (var i = 0; i < boardResults.length; i++) {
                        this._sportsBoardContext$1.getRow(i)._setSelectionsFromString(boardResults[i].PickValues);
                        var drawIds = null;
                        if (boardResults[i].Rows) {
                            drawIds = new Array(boardResults[i].Rows.length);
                            var k = 0;
                            var $enum2 = boardResults[i].Rows.getEnumerator();
                            while ($enum2.moveNext()) {
                                var row = $enum2.get_current();
                                drawIds[k] = row.DrawId;
                            }
                        }
                        this._sportsBoardContext$1.getRow(i).set_drawIds(drawIds);
                    }
                }
                this._sportsBoardContext$1._wagerResult = wagerResult;
                successCallback.invoke(wagerResult);
                var eventObject = new LotteryBoardService.SportsBoardContentEvent(this._instanceID);
                eventObject.sportsBoardChanged = true;
                this._fireChangedEvent$1(eventObject);
                this.changeState(LotteryBoardService.SportsViewState.RESULT);
                var msg = String.format(this.getMessage(LotteryBoardService.SportsMessages.placE_OK), wagerResult.WagerReference);
                this._fireMessageEventType$1(LotteryBoardService.SportsMessages.placE_OK, this.getMessage(LotteryBoardService.SportsMessages.placE_OK_TITLE), msg, false, LotteryBoardService.SportsMessageType.ACCEPTED);
                this._accountService.fetchAccountsDetails();
            }
            else {
                failureCallback.invoke(null);
                var msg = (wagerResult.ErrorMessage) ? String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), wagerResult.ErrorMessage) : String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), 'unknown error');
                this._fireMessageEventType$1(LotteryBoardService.SportsMessages.placE_FAILED, this.getMessage(LotteryBoardService.SportsMessages.placE_FAILED_TITLE), msg, false, LotteryBoardService.SportsMessageType.ERROR);
            }
        }), Delegate.create(this, function(exception) {
            failureCallback.invoke(exception);
            var msg = (exception) ? String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), exception.message) : String.format(this.getMessage(LotteryBoardService.LotteryMessages.placE_FAILED), 'unknown error');
            this._fireMessageEventType$1(LotteryBoardService.SportsMessages.placE_FAILED, this.getMessage(LotteryBoardService.SportsMessages.placE_FAILED_TITLE), this.getMessage(LotteryBoardService.SportsMessages.placE_FAILED), false, LotteryBoardService.SportsMessageType.ERROR);
        }), wagerRequest);
    },
    
    replayBoard: function LotteryBoardService_SportsController$replayBoard() {
        this.reset();
    },
    
    registerBoardContentChangedListener: function LotteryBoardService_SportsController$registerBoardContentChangedListener(listener) {
        this._sportsBoardContentChangedListeners$1.registerListener(listener);
    },
    
    _dispatchContentEvent: function LotteryBoardService_SportsController$_dispatchContentEvent(eventObject) {
        eventObject.source = this;
        this._sportsBoardContentChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSportsBoardContentChanged(eventObject);
        }));
    },
    
    _dispatchStateEvent: function LotteryBoardService_SportsController$_dispatchStateEvent(eventObject) {
        eventObject.source = this;
        this._sportsBoardContentChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSportsBoardStateChanged(eventObject);
        }));
    },
    
    _dispatchMessageEvent: function LotteryBoardService_SportsController$_dispatchMessageEvent(eventObject) {
        eventObject.source = this;
        this._sportsBoardContentChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSportsBoardMessage(eventObject);
        }));
    },
    
    _fireChangedEvent$1: function LotteryBoardService_SportsController$_fireChangedEvent$1(eventObject) {
        this._dispatchContentEvent(eventObject);
    },
    
    _fireMessageEvent$1: function LotteryBoardService_SportsController$_fireMessageEvent$1(messageID, messageText) {
        this._fireMessageEventType$1(messageID, '', messageText, true, LotteryBoardService.SportsMessageType.INFO);
    },
    
    _fireMessageEventType$1: function LotteryBoardService_SportsController$_fireMessageEventType$1(messageID, messageTitle, messageText, IsAlert, messageType) {
        var message = new LotteryBoardService.SportsMessage();
        var eventObject = new LotteryBoardService.SportsMessageEvent(this._instanceID);
        message.messageID = messageID;
        message.messageTitle = messageTitle;
        message.messageText = messageText;
        message.messageType = messageType;
        eventObject.isAlert = IsAlert;
        eventObject.message = message;
        if (!IsAlert) {
            this._sportsBoardContext$1.infoMessage = message;
        }
        this._dispatchMessageEvent(eventObject);
    },
    
    _fireConfirmMessageEvent$1: function LotteryBoardService_SportsController$_fireConfirmMessageEvent$1(messageID, messageText, confirmCallback, rejectCallback) {
        var message = new LotteryBoardService.SportsMessage();
        var eventObject = new LotteryBoardService.SportsMessageEvent(this._instanceID);
        message.messageID = messageID;
        message.messageText = messageText;
        eventObject.message = message;
        eventObject.confirmationRequired = true;
        eventObject.confirmCallback = confirmCallback;
        eventObject.rejectCallback = rejectCallback;
        this._dispatchMessageEvent(eventObject);
    },
    
    _createWagerRequest$1: function LotteryBoardService_SportsController$_createWagerRequest$1() {
        var wagerRequest = new DGEService.WagerRequest();
        wagerRequest.EditionCount = this._sportsBoardContext$1.editionCount;
        wagerRequest.BoardStacks = new Array(0);
        wagerRequest.BoardStacks[0] = LotteryBoardService.SportsController._createBoardStackInfo$1(this.get_board());
        return wagerRequest;
    },
    
    _isPickSystemValidForRow$1: function LotteryBoardService_SportsController$_isPickSystemValidForRow$1(rowContext, value) {
        if (isNullOrUndefined(value)) {
            return false;
        }
        if (value.name === rowContext.get_pickSystem().name) {
            return false;
        }
        for (var i = 0; i < value.sets.length; i++) {
            var currentSet = rowContext.getSet(i);
            var numberOfDoubles = currentSet._getNumberOfDoubleSelections();
            var numberOfTriples = currentSet._getNumberOfTripleSelections();
            var setInitData = value.sets[i];
            if ((setInitData.doublesCount < numberOfDoubles) && (setInitData.triplesCount < numberOfTriples)) {
                this._fireMessageEventType$1(LotteryBoardService.SportsMessages.toO_MANY_DOUBLES_AND_TRIPLES, this.getMessage(LotteryBoardService.SportsMessages.invaliD_PICK_SYSTEM), this.getMessage(LotteryBoardService.SportsMessages.toO_MANY_DOUBLES_AND_TRIPLES), true, LotteryBoardService.SportsMessageType.ERROR);
                return false;
            }
            if (setInitData.doublesCount < numberOfDoubles) {
                this._fireMessageEventType$1(LotteryBoardService.SportsMessages.toO_MANY_DOUBLES, this.getMessage(LotteryBoardService.SportsMessages.invaliD_PICK_SYSTEM), this.getMessage(LotteryBoardService.SportsMessages.toO_MANY_DOUBLES), true, LotteryBoardService.SportsMessageType.ERROR);
                return false;
            }
            if (setInitData.triplesCount < numberOfTriples) {
                this._fireMessageEventType$1(LotteryBoardService.SportsMessages.toO_MANY_TRIPLES, this.getMessage(LotteryBoardService.SportsMessages.invaliD_PICK_SYSTEM), this.getMessage(LotteryBoardService.SportsMessages.toO_MANY_TRIPLES), true, LotteryBoardService.SportsMessageType.ERROR);
                return false;
            }
        }
        return true;
    },
    
    _applyMinimalPickSystemWhichCanContainNewSelectionForRowAndSet$1: function LotteryBoardService_SportsController$_applyMinimalPickSystemWhichCanContainNewSelectionForRowAndSet$1(rowIndex, setIndex) {
        var rowContext = this._sportsBoardContext$1.getRow(rowIndex);
        var currentSet = rowContext.getSet(setIndex);
        var numberOfDoubles = currentSet._getNumberOfDoubleSelections();
        var numberOfTriples = currentSet._getNumberOfTripleSelections();
        var $enum1 = this._sportsBoardContext$1._pickSystems.getEnumerator();
        while ($enum1.moveNext()) {
            var pickSystem = $enum1.get_current();
            if (pickSystem.sets[setIndex].doublesCount >= numberOfDoubles && pickSystem.sets[setIndex].triplesCount >= numberOfTriples) {
                this.setPickSystem(rowIndex, pickSystem.id);
                break;
            }
        }
    },
    
    reset: function LotteryBoardService_SportsController$reset() {
        this.clearBoard();
        this.changeState(LotteryBoardService.SportsViewState.INPUT);
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardStackController

LotteryBoardService.BoardStackController = function LotteryBoardService_BoardStackController(instanceID, dgGameConfigProxy, messages, lotteryContext, boardStackProxy) {
    LotteryBoardService.BoardStackController.constructBase(this, [ instanceID, messages, lotteryContext ]);
    this._boardStackProxy$2 = boardStackProxy;
    this._dgGameConfigProxy$2 = dgGameConfigProxy;
    this._dgGameConfigVO$2 = dgGameConfigProxy.dgGameConfigVO;
    this._quickPickHelper$2 = new LotteryBoardService.QuickPickHelper(this, dgGameConfigProxy, boardStackProxy);
}
LotteryBoardService.BoardStackController.prototype = {
    _boardStackProxy$2: null,
    _dgGameConfigProxy$2: null,
    _dgGameConfigVO$2: null,
    _quickPickHelper$2: null,
    
    start: function LotteryBoardService_BoardStackController$start() {
        var stackContentEvent = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        stackContentEvent.allChanged = true;
        this.fireContentEvent(stackContentEvent);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.alL_PROPERTIES_CHANGED, null, null);
    },
    
    get_boardStack: function LotteryBoardService_BoardStackController$get_boardStack() {
        return this._boardStackProxy$2;
    },
    
    get_gameConfig: function LotteryBoardService_BoardStackController$get_gameConfig() {
        return this._dgGameConfigProxy$2;
    },
    
    setEnabled: function LotteryBoardService_BoardStackController$setEnabled(value) {
        var oldValue = this._boardStackProxy$2._enabled;
        this._boardStackProxy$2._enabled = value;
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.enableD_CHANGED, oldValue, value);
    },
    
    _warnIfQP$2: function LotteryBoardService_BoardStackController$_warnIfQP$2(boardIndex, response) {
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        var isQP = board.hasQPFields();
        if (isQP) {
            this.fireConfirmMessageEvent(LotteryBoardService.LotteryMessages.cleaR_QUICK_PICK, this.getMessage(LotteryBoardService.LotteryMessages.cleaR_QUICK_PICK), Delegate.create(this, function() {
                this.clearBoard(boardIndex);
                response.invoke(true);
            }), Delegate.create(this, function() {
                response.invoke(false);
            }));
        }
        return isQP;
    },
    
    injectNumber: function LotteryBoardService_BoardStackController$injectNumber(value, boardIndex, setIndex, response) {
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        var set = board.getSet(setIndex);
        if (!set.get_active()) {
            return false;
        }
        if (board.isServerQuickPick() && board.isPartialQPAllowed() && !set.containsValue(value) && board.hasQPFields()) {
            this._clearQuickPick(boardIndex);
        }
        else if (board.isPartialQPAllowed()) {
            return this.doInjectNumber(value, boardIndex, setIndex);
        }
        else if (!this._warnIfQP$2(boardIndex, response)) {
            return this.doInjectNumber(value, boardIndex, setIndex);
        }
        return false;
    },
    
    doInjectNumber: function LotteryBoardService_BoardStackController$doInjectNumber(value, boardIndex, setIndex) {
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        var set = board.getSet(setIndex);
        var index = set.getIndexOf(value);
        if (index === -1) {
            var numbers = this._boardStackProxy$2.getBoard(boardIndex).getSet(setIndex).getNumbers();
            for (var i = 0; i < numbers.length; i++) {
                var number = numbers[i];
                if (number.isEmpty()) {
                    return this.setNumber(value.toString(), boardIndex, setIndex, i);
                }
            }
            if (this._dgGameConfigVO$2.autoChangeSystem.indexOf(LotteryBoardService.AutoChangeSystem.UP) !== -1) {
                this._handleUserNumberChoiceOverSystemsLimit$2(value, boardIndex, setIndex);
            }
        }
        else {
            if (this._dgGameConfigVO$2.autoChangeSystem.indexOf(LotteryBoardService.AutoChangeSystem.DOWN) !== -1 && this._boardStackProxy$2.getBoard(boardIndex).hasQPFields()) {
                this.fireMessageEvent(LotteryBoardService.LotteryMessages.nO_SYSTEM_CHANGING_QP, this.getMessage(LotteryBoardService.LotteryMessages.nO_SYSTEM_CHANGING_QP));
                return false;
            }
            var result = this.setNumber('', boardIndex, setIndex, index);
            if (this._dgGameConfigVO$2.autoChangeSystem.indexOf(LotteryBoardService.AutoChangeSystem.DOWN) !== -1) {
                this._handleUserNumberChoiceBelowSystemsLimit$2(boardIndex, setIndex);
            }
            return result;
        }
        return false;
    },
    
    _safelyChangePickSystem$2: function LotteryBoardService_BoardStackController$_safelyChangePickSystem$2(boardIndex, newPickSystem) {
        var numbers = this._boardStackProxy$2.getBoard(boardIndex)._getNumbersAsString();
        numbers = numbers.replace(',,', ',');
        if (numbers.startsWith(',')) {
            numbers = numbers.substr(1);
        }
        if (numbers.endsWith(',')) {
            numbers = numbers.substring(0, numbers.length - 1);
        }
        this.setPickSystem(boardIndex, newPickSystem.id);
        this._boardStackProxy$2.getBoard(boardIndex)._setNumbersFromString(numbers);
    },
    
    _handleUserNumberChoiceOverSystemsLimit$2: function LotteryBoardService_BoardStackController$_handleUserNumberChoiceOverSystemsLimit$2(value, boardIndex, setIndex) {
        if (this._boardStackProxy$2.getBoard(boardIndex).hasQPFields()) {
            this.fireMessageEvent(LotteryBoardService.LotteryMessages.nO_SYSTEM_CHANGING_QP, this.getMessage(LotteryBoardService.LotteryMessages.nO_SYSTEM_CHANGING_QP));
            return;
        }
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        var currentPickSystemId = board.get_pickSystemID();
        var currentPickSystem = this._dgGameConfigProxy$2.getPickSystemByID(currentPickSystemId);
        var newPickSystem = null;
        var systems = this._dgGameConfigProxy$2.dgGameConfigVO.pickSystems;
        var $enum1 = systems.getEnumerator();
        while ($enum1.moveNext()) {
            var systemConfig = $enum1.get_current();
            if (systemConfig.sets[setIndex].symbolCount > currentPickSystem.sets[setIndex].symbolCount) {
                if (!newPickSystem || newPickSystem.sets[setIndex].symbolCount < currentPickSystem.sets[setIndex].symbolCount) {
                    newPickSystem = systemConfig;
                }
            }
        }
        if (newPickSystem) {
            this._safelyChangePickSystem$2(boardIndex, newPickSystem);
            this.doInjectNumber(value, boardIndex, setIndex);
        }
    },
    
    _handleUserNumberChoiceBelowSystemsLimit$2: function LotteryBoardService_BoardStackController$_handleUserNumberChoiceBelowSystemsLimit$2(boardIndex, setIndex) {
        var emptySpaces = 0;
        var numbers = this._boardStackProxy$2.getBoard(boardIndex).getSet(setIndex).getNumbers();
        for (var i = 0; i < numbers.length; i++) {
            if (numbers[i].isEmpty()) {
                emptySpaces++;
            }
        }
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        var currentPickSystemId = board.get_pickSystemID();
        var currentPickSystem = this._dgGameConfigProxy$2.getPickSystemByID(currentPickSystemId);
        var newPickSystem = null;
        var systems = this._dgGameConfigProxy$2.dgGameConfigVO.pickSystems;
        var $enum1 = systems.getEnumerator();
        while ($enum1.moveNext()) {
            var systemConfig = $enum1.get_current();
            if (systemConfig.sets[setIndex].symbolCount < currentPickSystem.sets[setIndex].symbolCount && systemConfig.sets[setIndex].symbolCount >= currentPickSystem.sets[setIndex].symbolCount - emptySpaces) {
                if (!newPickSystem || newPickSystem.sets[setIndex].symbolCount > currentPickSystem.sets[setIndex].symbolCount) {
                    newPickSystem = systemConfig;
                }
            }
        }
        if (newPickSystem) {
            this._safelyChangePickSystem$2(boardIndex, newPickSystem);
        }
    },
    
    setNumber: function LotteryBoardService_BoardStackController$setNumber(value, boardIndex, setIndex, numberIndex) {
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        var numberProxy = board.getSet(setIndex).getNumber(numberIndex);
        var oldNumberProxy = new LotteryBoardService.NumberProxy();
        oldNumberProxy._enabled = numberProxy._enabled;
        oldNumberProxy._index = numberProxy._index;
        oldNumberProxy._setProxy = numberProxy._setProxy;
        oldNumberProxy.set__data(new LotteryBoardService.NumberVO());
        oldNumberProxy.get__data().type = numberProxy.get__data().type;
        oldNumberProxy.get__data().value = numberProxy.get__data().value;
        if (oldNumberProxy.get_value().toString() === value) {
            return false;
        }
        var wasPopulated = this._boardStackProxy$2.getBoard(boardIndex).isPopulated();
        numberProxy._setEntry(value);
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        eventObject.selectedNumbersChanged = true;
        eventObject.boardIndex = boardIndex;
        if (board.isServerQuickPick() && board.hasQPFields()) {
            board._clearQPFields();
        }
        else {
            eventObject.setIndex = setIndex;
            eventObject.fieldIndex = numberIndex;
            eventObject.oldNumberProxy = oldNumberProxy;
            eventObject.newNumberProxy = numberProxy;
        }
        if (wasPopulated !== this._boardStackProxy$2.getBoard(boardIndex).isPopulated()) {
            this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, null, null);
        }
        this.fireContentEvent(eventObject);
        if (numberProxy.get_errorMessageID()) {
            var msg = this.getMessage(numberProxy.get_errorMessageID());
            if (numberProxy.get_errorMessageID() === LotteryBoardService.LotteryMessages.BETWEEN) {
                msg = String.format(msg, numberProxy._setProxy.min, numberProxy._setProxy.max);
            }
            this.fireMessageEvent(numberProxy.get_errorMessageID(), msg);
            return false;
        }
        return true;
    },
    
    increaseValue: function LotteryBoardService_BoardStackController$increaseValue(boardIndex, setIndex, numberIndex, response) {
        var number = this._boardStackProxy$2.getBoard(boardIndex).getSet(setIndex).getNumber(numberIndex);
        if (!number.get_enabled()) {
            return;
        }
        if (!this._warnIfQP$2(boardIndex, response)) {
            if (number.isEmpty()) {
                this.setNumber(number._setProxy.min.toString(), boardIndex, setIndex, numberIndex);
            }
            else if (number.get_value() < number._setProxy.max) {
                this.setNumber((number.get_value() + 1).toString(), boardIndex, setIndex, numberIndex);
            }
        }
    },
    
    decreaseValue: function LotteryBoardService_BoardStackController$decreaseValue(boardIndex, setIndex, numberIndex, response) {
        var number = this._boardStackProxy$2.getBoard(boardIndex).getSet(setIndex).getNumber(numberIndex);
        if (!number.get_enabled()) {
            return;
        }
        if (!this._warnIfQP$2(boardIndex, response)) {
            if (number.isEmpty()) {
                this.setNumber(number._setProxy.min.toString(), boardIndex, setIndex, numberIndex);
            }
            else if (number.get_value() > number._setProxy.min) {
                this.setNumber((number.get_value() - 1).toString(), boardIndex, setIndex, numberIndex);
            }
        }
    },
    
    fullQP: function LotteryBoardService_BoardStackController$fullQP() {
        this._quickPickHelper$2.fullQP();
    },
    
    forceQP: function LotteryBoardService_BoardStackController$forceQP() {
        this._quickPickHelper$2.forceQP();
    },
    
    quickPick: function LotteryBoardService_BoardStackController$quickPick(boardIndex, count) {
        this._quickPickHelper$2.quickPick(boardIndex, count);
    },
    
    _clearQuickPick: function LotteryBoardService_BoardStackController$_clearQuickPick(boardIndex) {
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        board._clearQPFields();
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        eventObject.selectedNumbersChanged = true;
        eventObject.boardIndex = boardIndex;
        this.fireContentEvent(eventObject);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy$2.get_price(), null);
    },
    
    clearBoardStack: function LotteryBoardService_BoardStackController$clearBoardStack() {
        this._boardStackProxy$2.clear();
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        eventObject.selectedNumbersChanged = true;
        this.fireContentEvent(eventObject);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy$2.get_price(), null);
    },
    
    clearBoard: function LotteryBoardService_BoardStackController$clearBoard(boardIndex) {
        this._boardStackProxy$2.getBoard(boardIndex)._clear();
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        eventObject.selectedNumbersChanged = true;
        eventObject.boardIndex = boardIndex;
        this.fireContentEvent(eventObject);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy$2.get_price(), null);
    },
    
    reset: function LotteryBoardService_BoardStackController$reset() {
        this._boardStackProxy$2.reset();
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        eventObject.selectedNumbersChanged = true;
        eventObject.pickSystemID = 'all_systems_changed';
        this.fireContentEvent(eventObject);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.alL_PROPERTIES_CHANGED, null, null);
    },
    
    setPickSystem: function LotteryBoardService_BoardStackController$setPickSystem(boardIndex, pickSystemID) {
        this._boardStackProxy$2.getBoard(boardIndex).set_pickSystem(this._dgGameConfigProxy$2.getPickSystemByID(pickSystemID));
        var eventObject = new LotteryBoardService.BoardStackContentEvent(this, this._instanceID);
        eventObject.selectedNumbersChanged = true;
        eventObject.pickSystemID = pickSystemID;
        eventObject.boardIndex = boardIndex;
        this.fireContentEvent(eventObject);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy$2.get_price(), null);
    },
    
    _changeState: function LotteryBoardService_BoardStackController$_changeState(viewState) {
        var oldState = this._boardStackProxy$2.get_viewState();
        this._boardStackProxy$2.set_viewState(viewState);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.vieW_STATE_CHANGED, oldState, viewState);
    },
    
    validate: function LotteryBoardService_BoardStackController$validate() {
        if (this._boardStackProxy$2.hasDirtyBoards()) {
            this.fireMessageEvent(LotteryBoardService.LotteryMessages.selecT_ALL_NUMBERS, this.getMessage(LotteryBoardService.LotteryMessages.selecT_ALL_NUMBERS));
            return false;
        }
        if (this._boardStackProxy$2.hasSameNumbersOutOfRange()) {
            this.fireMessageEvent(LotteryBoardService.LotteryMessages.samE_NUMBERS_OUT_OF_RANGE, this.getMessage(LotteryBoardService.LotteryMessages.samE_NUMBERS_OUT_OF_RANGE));
            return false;
        }
        if (!this._boardStackProxy$2.get_isAddon()) {
            if (this._boardStackProxy$2.get_populatedBoardsCount() < this._boardStackProxy$2.get_boardCountMin()) {
                var msg = this.getMessage(LotteryBoardService.LotteryMessages.lesS_THEN_MIN);
                msg = String.format(msg, this._boardStackProxy$2.get_boardCountMin());
                this.fireMessageEvent(LotteryBoardService.LotteryMessages.lesS_THEN_MIN, msg);
                return false;
            }
        }
        return true;
    },
    
    setDrawPrice: function LotteryBoardService_BoardStackController$setDrawPrice(boardIndex, drawID, price) {
        if (price === LotteryBoardService._commonUtils.ZERO) {
            price = null;
        }
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        board._setBoardRowPrice(drawID, price);
        var boardStackContentEvent = new LotteryBoardService.BoardStackContentEvent(this, this.get_instanceID());
        boardStackContentEvent.drawsChanged = true;
        boardStackContentEvent.boardIndex = boardIndex;
        this.fireContentEvent(boardStackContentEvent);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy$2.get_price(), null);
    },
    
    setPickSystemPrice: function LotteryBoardService_BoardStackController$setPickSystemPrice(boardIndex, pickSystem, price) {
        if (price === LotteryBoardService._commonUtils.ZERO) {
            price = null;
        }
        var board = this._boardStackProxy$2.getBoard(boardIndex);
        board._setBoardRowPriceByPickSystem(pickSystem, price);
        var boardStackContentEvent = new LotteryBoardService.BoardStackContentEvent(this, this.get_instanceID());
        boardStackContentEvent.pickSystemsChanged = true;
        boardStackContentEvent.boardIndex = boardIndex;
        this.fireContentEvent(boardStackContentEvent);
        this.firePropertyChangedEvent(LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED, this._boardStackProxy$2.get_price(), null);
    },
    
    setDefaultDrawPrice: function LotteryBoardService_BoardStackController$setDefaultDrawPrice(boardIndex, drawID, selected) {
        var price = null;
        if (selected) {
            price = this._dgGameConfigProxy$2.getDrawByID(drawID).priceList[0];
        }
        this.setDrawPrice(boardIndex, drawID, price);
    },
    
    setState: function LotteryBoardService_BoardStackController$setState(state) {
        var boardStackVO = state;
        this._boardStackProxy$2.set__data(boardStackVO);
        for (var r = 0; r < boardStackVO.boardVOList.length; r++) {
            this._boardStackProxy$2.getBoard(r).set__data(boardStackVO.boardVOList[r]);
        }
    },
    
    mergeState: function LotteryBoardService_BoardStackController$mergeState(state) {
        var boardStackVO = state;
        this._boardStackProxy$2._mergeData(boardStackVO);
        for (var r = 0; r < boardStackVO.boardVOList.length; r++) {
            this._boardStackProxy$2.getBoard(r)._mergeData(boardStackVO.boardVOList[r]);
        }
    },
    
    getState: function LotteryBoardService_BoardStackController$getState() {
        var boardStackVO = this._boardStackProxy$2.get__data();
        boardStackVO.boardVOList = new Array(0);
        for (var i = 0; i < this._boardStackProxy$2.get_boardCount(); i++) {
            var board = this._boardStackProxy$2.getBoard(i);
            var boardVO = board.get__data();
            boardVO.values = this._boardStackProxy$2.getBoard(i)._getNumbersAsString();
            boardVO.setVOList = new Array(0);
            for (var s = 0; s < board.get_setCount(); s++) {
                var set = board.getSet(s);
                var setVO = set.get__data();
                setVO.numberVOList = new Array(0);
                for (var n = 0; n < set.get_numberCount(); n++) {
                    setVO.numberVOList[n] = set.getNumber(n).get__data();
                }
                boardVO.setVOList[s] = setVO;
            }
            boardStackVO.boardVOList[i] = boardVO;
        }
        return boardStackVO;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.LotteryBoardService

LotteryBoardService.LotteryBoardService = function LotteryBoardService_LotteryBoardService() {
    this._controllers$1 = {};
    this._oXMLHttpRequestDecorator$1 = new Framework.XMLHttpRequestDecorator();
    LotteryBoardService.LotteryBoardService.constructBase(this);
    this._lotteryContext$1 = new LotteryBoardService.LotteryContext();
    this._lotteryContext$1.log = Framework.Logger.getLog(LotteryBoardService.LotteryBoardService._serviceName$1);
    this._lotteryContext$1.commonEventDispatcher = new LotteryBoardService.LotteryEventDispatcher(this._lotteryContext$1.log);
}
LotteryBoardService.LotteryBoardService.prototype = {
    _lotteryContext$1: null,
    _state$1: null,
    
    setNavigationService: function LotteryBoardService_LotteryBoardService$setNavigationService(navigationService) {
        this._lotteryContext$1.log.debug('SetNavigationService');
        this._lotteryContext$1.navigationService = navigationService;
    },
    
    setDGEService: function LotteryBoardService_LotteryBoardService$setDGEService(dgeService) {
        this._lotteryContext$1.log.debug('SetDGEService');
        this._lotteryContext$1.dgeService = dgeService;
    },
    
    setUserService: function LotteryBoardService_LotteryBoardService$setUserService(userService) {
        this._lotteryContext$1.log.debug('SetUserService');
        this._lotteryContext$1.userService = userService;
    },
    
    setAccountService: function LotteryBoardService_LotteryBoardService$setAccountService(accountService) {
        this._lotteryContext$1.log.debug('AccountService');
        this._lotteryContext$1.accountService = accountService;
    },
    
    onPageWillChange: function LotteryBoardService_LotteryBoardService$onPageWillChange() {
        this._storeState$1();
    },
    
    onUserChanged: function LotteryBoardService_LotteryBoardService$onUserChanged(eventSource) {
        if (!this._lotteryContext$1.userService.isLoggedIn()) {
            this._clearState$1();
        }
    },
    
    init: function LotteryBoardService_LotteryBoardService$init(environment, parameters) {
        this._lotteryContext$1.log.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        LotteryBoardService.LotteryBoardService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        this._state$1 = this._environment.getStoredState(LotteryBoardService.LotteryBoardService._serviceName$1);
        this._loadConfigurationParameters$1();
    },
    
    start: function LotteryBoardService_LotteryBoardService$start() {
        this._lotteryContext$1.log.debug('Start');
        this._lotteryContext$1.userService.registerUserChangedListener(this);
    },
    
    registerBoardContentChangedListener: function LotteryBoardService_LotteryBoardService$registerBoardContentChangedListener(boardStackContentListener) {
        this._lotteryContext$1.commonEventDispatcher.registerBoardContentChangedListener(boardStackContentListener);
    },
    
    unegisterBoardContentChangedListener: function LotteryBoardService_LotteryBoardService$unegisterBoardContentChangedListener(boardStackContentListener) {
        this._lotteryContext$1.commonEventDispatcher.unregisterBoardContentChangedListener(boardStackContentListener);
    },
    
    registerPropertyChangedListener: function LotteryBoardService_LotteryBoardService$registerPropertyChangedListener(propertyChangedListener) {
        this._lotteryContext$1.commonEventDispatcher.registerPropertyChangedListener(propertyChangedListener);
    },
    
    unregisterPropertyChangedListener: function LotteryBoardService_LotteryBoardService$unregisterPropertyChangedListener(propertyChangedListener) {
        this._lotteryContext$1.commonEventDispatcher.unregisterPropertyChangedListener(propertyChangedListener);
    },
    
    registerMessageListener: function LotteryBoardService_LotteryBoardService$registerMessageListener(messageChangedListener) {
        this._lotteryContext$1.commonEventDispatcher.registerMessageListener(messageChangedListener);
    },
    
    unregisterMessageListener: function LotteryBoardService_LotteryBoardService$unregisterMessageListener(messageChangedListener) {
        this._lotteryContext$1.commonEventDispatcher.unregisterMessageListener(messageChangedListener);
    },
    
    registerActionListener: function LotteryBoardService_LotteryBoardService$registerActionListener(actionListener) {
        this._lotteryContext$1.commonEventDispatcher.registerActionListener(actionListener);
    },
    
    unregisterActionListener: function LotteryBoardService_LotteryBoardService$unregisterActionListener(actionListener) {
        this._lotteryContext$1.commonEventDispatcher.unregisterActionListener(actionListener);
    },
    
    play: function LotteryBoardService_LotteryBoardService$play(externalGameId, state) {
        this._environment.storeState('explicitComponentState', state);
        var areaName = this._getAreaFromXml$1(externalGameId);
        var areaAction = this._getActionForAreaFromXml$1(externalGameId);
        var oDictionary = {};
        oDictionary['action'] = areaAction;
        this._lotteryContext$1.navigationService.goTo(areaName, oDictionary);
    },
    
    _storeState$1: function LotteryBoardService_LotteryBoardService$_storeState$1() {
        var newState = this._getState$1();
        if (this._state$1) {
            var $dict1 = newState;
            for (var $key2 in $dict1) {
                var de = { key: $key2, value: $dict1[$key2] };
                this._state$1[de.key] = de.value;
            }
        }
        else {
            this._state$1 = newState;
        }
        this._environment.storeState(LotteryBoardService.LotteryBoardService._serviceName$1, this._state$1);
    },
    
    _getState$1: function LotteryBoardService_LotteryBoardService$_getState$1() {
        var state = {};
        var $dict1 = this._controllers$1;
        for (var $key2 in $dict1) {
            var dEntry = { key: $key2, value: $dict1[$key2] };
            state[dEntry.key] = (dEntry.value).getState();
        }
        return state;
    },
    
    _setState: function LotteryBoardService_LotteryBoardService$_setState(controller) {
        try {
            var wagerInfo = this._environment.getStoredState('explicitComponentState');
            if (!isNullOrUndefined(wagerInfo)) {
                controller.mergeState(wagerInfo);
                return;
            }
            if (!isNullOrUndefined(this._state$1)) {
                var state = this._state$1[controller.get_instanceID()];
                if (!isNullOrUndefined(state)) {
                    controller.setState(this._state$1[controller.get_instanceID()]);
                }
            }
            this._environment.storeState('explicitComponentState', null);
        }
        catch (e) {
        }
    },
    
    _clearState$1: function LotteryBoardService_LotteryBoardService$_clearState$1() {
        this._state$1 = {};
        this._environment.storeState(LotteryBoardService.LotteryBoardService._serviceName$1, this._state$1);
    },
    
    get__lotteryContext: function LotteryBoardService_LotteryBoardService$get__lotteryContext() {
        return this._lotteryContext$1;
    },
    
    _registerController: function LotteryBoardService_LotteryBoardService$_registerController(controller) {
        if (!Object.keyExists(this._controllers$1, controller.get_instanceID())) {
            this._controllers$1[controller.get_instanceID()] = controller;
        }
        this._setState(controller);
    },
    
    _hasController: function LotteryBoardService_LotteryBoardService$_hasController(instanceID) {
        return Object.keyExists(this._controllers$1, instanceID);
    },
    
    _getController: function LotteryBoardService_LotteryBoardService$_getController(instanceID) {
        return this._controllers$1[instanceID];
    },
    
    _gameAreasXML$1: null,
    
    _loadConfigurationParameters$1: function LotteryBoardService_LotteryBoardService$_loadConfigurationParameters$1() {
        this._oXMLHttpRequestDecorator$1.onreadystatechange = Delegate.create(this, function() {
            if (this._oXMLHttpRequestDecorator$1.readyState === 4) {
                if (this._oXMLHttpRequestDecorator$1.status === 200 || this._oXMLHttpRequestDecorator$1.status === 304) {
                    this._gameAreasXML$1 = this._oXMLHttpRequestDecorator$1.responseXML;
                }
            }
        });
        var configPath = this._parameters['config-url'];
        this._oXMLHttpRequestDecorator$1.open('GET', configPath, true);
        this._oXMLHttpRequestDecorator$1.send(null);
    },
    
    _getAreaFromXml$1: function LotteryBoardService_LotteryBoardService$_getAreaFromXml$1(gameId) {
        var oXMLNodeList = this._gameAreasXML$1.getElementsByTagName('connector');
        for (var i = 0; i < oXMLNodeList.length; i++) {
            var oNode = oXMLNodeList[i];
            var oNodeMap = oNode.attributes;
            if (oNodeMap.getNamedItem('gameid').text === gameId) {
                return oNodeMap.getNamedItem('area').text;
            }
        }
        return null;
    },
    
    _getActionForAreaFromXml$1: function LotteryBoardService_LotteryBoardService$_getActionForAreaFromXml$1(gameId) {
        var oXMLNodeList = this._gameAreasXML$1.getElementsByTagName('connector');
        for (var i = 0; i < oXMLNodeList.length; i++) {
            var oNode = oXMLNodeList[i];
            var oNodeMap = oNode.attributes;
            if (oNodeMap.getNamedItem('gameid').text === gameId) {
                if (oNodeMap.getNamedItem('action')) {
                    return oNodeMap.getNamedItem('action').text;
                }
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.NumberProxy

LotteryBoardService.NumberProxy = function LotteryBoardService_NumberProxy() {
    this._index = -1;
    this.set__data(new LotteryBoardService.NumberVO());
}
LotteryBoardService.NumberProxy.prototype = {
    _numberVO: null,
    _setProxy: null,
    _enabled: true,
    _errorMessage: null,
    
    get__data: function LotteryBoardService_NumberProxy$get__data() {
        return this._numberVO;
    },
    set__data: function LotteryBoardService_NumberProxy$set__data(value) {
        this._numberVO = value;
        return value;
    },
    
    get_set: function LotteryBoardService_NumberProxy$get_set() {
        return this._setProxy;
    },
    
    get_index: function LotteryBoardService_NumberProxy$get_index() {
        return this._index;
    },
    
    get_errorMessageID: function LotteryBoardService_NumberProxy$get_errorMessageID() {
        return this._errorMessage;
    },
    
    get_value: function LotteryBoardService_NumberProxy$get_value() {
        return this._numberVO.value;
    },
    
    get_entry: function LotteryBoardService_NumberProxy$get_entry() {
        if (this._setProxy.get_isAlphaNumeric()) {
            return String.fromCharCode(-1 + 1 * this._setProxy.minRawAscii + 1 * this._numberVO.value);
        }
        else {
            return (this._numberVO.value !== -1) ? this._numberVO.value.toString() : (this._numberVO.type === LotteryBoardService.NumberType.serveR_QP) ? 'QP' : '';
        }
    },
    
    get_type: function LotteryBoardService_NumberProxy$get_type() {
        return this._numberVO.type;
    },
    
    get_enabled: function LotteryBoardService_NumberProxy$get_enabled() {
        return this._enabled;
    },
    
    isPopulated: function LotteryBoardService_NumberProxy$isPopulated() {
        return this._numberVO.value !== -1 || this._numberVO.type === LotteryBoardService.NumberType.serveR_QP;
    },
    
    isEmpty: function LotteryBoardService_NumberProxy$isEmpty() {
        return this._numberVO.value === -1 && this._numberVO.type !== LotteryBoardService.NumberType.serveR_QP;
    },
    
    isQuickPick: function LotteryBoardService_NumberProxy$isQuickPick() {
        return this._numberVO.type === LotteryBoardService.NumberType.serveR_QP || this._numberVO.type === LotteryBoardService.NumberType.clienT_QP;
    },
    
    isServerQP: function LotteryBoardService_NumberProxy$isServerQP() {
        return this._numberVO.type === LotteryBoardService.NumberType.serveR_QP;
    },
    
    isClientQP: function LotteryBoardService_NumberProxy$isClientQP() {
        return this._numberVO.type === LotteryBoardService.NumberType.clienT_QP;
    },
    
    isRegular: function LotteryBoardService_NumberProxy$isRegular() {
        return this._numberVO.type === LotteryBoardService.NumberType.REGULAR;
    },
    
    _setValue: function LotteryBoardService_NumberProxy$_setValue(value) {
        var success = this._doSetValue(value);
        if (success) {
            this._numberVO.type = LotteryBoardService.NumberType.REGULAR;
        }
        return success;
    },
    
    _setEntry: function LotteryBoardService_NumberProxy$_setEntry(value) {
        var success = this._doSetValueFromString(value);
        if (success) {
            this._numberVO.type = LotteryBoardService.NumberType.REGULAR;
        }
        return success;
    },
    
    _setClientQPFromString: function LotteryBoardService_NumberProxy$_setClientQPFromString(value) {
        var success = this._doSetValueFromString(value);
        if (success) {
            this._numberVO.type = LotteryBoardService.NumberType.clienT_QP;
        }
        return success;
    },
    
    _setClientQP: function LotteryBoardService_NumberProxy$_setClientQP(value) {
        var success = this._doSetValue(value);
        if (success) {
            this._numberVO.type = LotteryBoardService.NumberType.clienT_QP;
        }
        return success;
    },
    
    _setServerQP: function LotteryBoardService_NumberProxy$_setServerQP() {
        this._numberVO.value = -1;
        this._numberVO.type = LotteryBoardService.NumberType.serveR_QP;
    },
    
    _clear: function LotteryBoardService_NumberProxy$_clear() {
        this._numberVO.value = -1;
        this._numberVO.type = LotteryBoardService.NumberType.REGULAR;
    },
    
    _doSetValueFromString: function LotteryBoardService_NumberProxy$_doSetValueFromString(value) {
        this._numberVO.value = -1;
        this._numberVO.type = LotteryBoardService.NumberType.REGULAR;
        this._errorMessage = null;
        if (isNullOrUndefined(value) || !value.length) {
            return false;
        }
        if (value.search(LotteryBoardService.NumberProxy._digitRegex) !== -1) {
            this._errorMessage = LotteryBoardService.LotteryMessages.noT_NUMBER;
            return false;
        }
        var entryValue;
        try {
            entryValue = parseInt(value);
        }
        catch ($e1) {
            this._errorMessage = LotteryBoardService.LotteryMessages.noT_NUMBER;
            return false;
        }
        return this._doSetValue(entryValue);
    },
    
    _doSetValue: function LotteryBoardService_NumberProxy$_doSetValue(entryValue) {
        if (entryValue < this._setProxy.min || entryValue > this._setProxy.max) {
            this._errorMessage = LotteryBoardService.LotteryMessages.BETWEEN;
            return false;
        }
        if (!this._setProxy.repetitionAllowed && this._setProxy.containsValue(entryValue)) {
            this._errorMessage = LotteryBoardService.LotteryMessages.alreadY_EXISTS;
            return false;
        }
        this._numberVO.value = entryValue;
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardProxy

LotteryBoardService.BoardProxy = function LotteryBoardService_BoardProxy(dgGameConfigProxy) {
    this._index = -1;
    this._setList = new Array(0);
    this._dgGameConfigProxy = dgGameConfigProxy;
    this._dgGameConfigVO = dgGameConfigProxy.dgGameConfigVO;
    this._boardVO = new LotteryBoardService.BoardVO();
    this._createDefaultData();
}
LotteryBoardService.BoardProxy.prototype = {
    _dgGameConfigProxy: null,
    _dgGameConfigVO: null,
    _boardVO: null,
    _boardStackProxy: null,
    _numbersCount: 0,
    drawIds: null,
    
    get_drawIds: function LotteryBoardService_BoardProxy$get_drawIds() {
        return this.drawIds;
    },
    set_drawIds: function LotteryBoardService_BoardProxy$set_drawIds(value) {
        this.drawIds = value;
        return value;
    },
    
    _createDefaultData: function LotteryBoardService_BoardProxy$_createDefaultData() {
        var boardVO = new LotteryBoardService.BoardVO();
        boardVO.boardRows = new Array(0);
        if (this._dgGameConfigVO.multiPickSystemsAllowed) {
            for (var i = 0; i < this._dgGameConfigVO.pickSystems.length; i++) {
                var boardRow = new LotteryBoardService.BoardRowVO();
                var pickSystemConfig = this._dgGameConfigVO.pickSystems[i];
                boardRow.pickSystemId = pickSystemConfig.id;
                boardVO.boardRows[i] = boardRow;
            }
            boardVO.pickSystemID = null;
        }
        else {
            for (var i = 0; i < this._dgGameConfigVO.draws.length; i++) {
                var boardRow = new LotteryBoardService.BoardRowVO();
                var drawConfig = this._dgGameConfigVO.draws[i];
                boardRow.drawID = drawConfig.id;
                boardVO.boardRows[i] = boardRow;
            }
            boardVO.pickSystemID = this._dgGameConfigVO.defaultPickSystemID;
        }
        this.set__data(boardVO);
    },
    
    get__data: function LotteryBoardService_BoardProxy$get__data() {
        return this._boardVO;
    },
    set__data: function LotteryBoardService_BoardProxy$set__data(value) {
        this._boardVO.pickSystemID = value.pickSystemID;
        this._boardVO.boardRows = value.boardRows;
        this._configurePickSystem();
        if (!isNullOrUndefined(value.setVOList)) {
            for (var s = 0; s < value.setVOList.length; s++) {
                this._setList[s].set__data(value.setVOList[s]);
            }
        }
        this._checkDependencies();
        return value;
    },
    
    _mergeData: function LotteryBoardService_BoardProxy$_mergeData(value) {
        if (!isNullOrUndefined(value.boardRows)) {
            this._createDefaultData();
            this._setupBoardLevelPickSystem(value);
            for (var i = 0; i < value.boardRows.length; i++) {
                if (this._dgGameConfigVO.multiPickSystemsAllowed) {
                    var pickSystem = value.boardRows[i].pickSystemId;
                    if (isNullOrUndefined(pickSystem) && value.boardRows.length === 1) {
                        pickSystem = value.pickSystemID;
                    }
                    var rowVO = this._getBoardRowByPickSystem(pickSystem);
                    if (!isNullOrUndefined(rowVO)) {
                        rowVO.price = value.boardRows[i].price;
                        rowVO.enabled = true;
                        rowVO.drawID = value.boardRows[i].drawID;
                    }
                }
                else {
                    var rowVO = this._getBoardRowByID(value.boardRows[i].drawID);
                    if (!isNullOrUndefined(rowVO)) {
                        rowVO.price = value.boardRows[i].price;
                        rowVO.enabled = true;
                        rowVO.pickSystemId = value.boardRows[i].pickSystemId;
                    }
                }
            }
        }
        else {
            this._setupBoardLevelPickSystem(value);
        }
        if (!isNullOrUndefined(value.setVOList)) {
            for (var s = 0; s < value.setVOList.length; s++) {
                this._setList[s].set__data(value.setVOList[s]);
            }
        }
        else if (!String.isNullOrEmpty(value.values)) {
            this._setNumbersFromString(value.values);
        }
        this._checkDependencies();
    },
    
    _setupBoardLevelPickSystem: function LotteryBoardService_BoardProxy$_setupBoardLevelPickSystem(value) {
        if (!isNullOrUndefined(value.pickSystemID)) {
            this._boardVO.pickSystemID = value.pickSystemID;
            this._configurePickSystem();
        }
    },
    
    getSet: function LotteryBoardService_BoardProxy$getSet(setIndex) {
        return this._setList[setIndex];
    },
    
    get_index: function LotteryBoardService_BoardProxy$get_index() {
        return this._index;
    },
    
    get_setCount: function LotteryBoardService_BoardProxy$get_setCount() {
        return this._setList.length;
    },
    
    get_numbersCount: function LotteryBoardService_BoardProxy$get_numbersCount() {
        return this._numbersCount;
    },
    
    get_pickSystem: function LotteryBoardService_BoardProxy$get_pickSystem() {
        return this._dgGameConfigProxy.getPickSystemByID(this._boardVO.pickSystemID);
    },
    set_pickSystem: function LotteryBoardService_BoardProxy$set_pickSystem(value) {
        if (isNullOrUndefined(value)) {
            this.set_pickSystemID(null);
        }
        else {
            this.set_pickSystemID(value.id);
        }
        return value;
    },
    
    get_pickSystemID: function LotteryBoardService_BoardProxy$get_pickSystemID() {
        return this._boardVO.pickSystemID;
    },
    set_pickSystemID: function LotteryBoardService_BoardProxy$set_pickSystemID(value) {
        this._boardVO.pickSystemID = value;
        this._configurePickSystem();
        this._checkDependencies();
        return value;
    },
    
    get_price: function LotteryBoardService_BoardProxy$get_price() {
        if (this.isPopulated()) {
            var price = 0;
            for (var i = 0; i < this._boardVO.boardRows.length; i++) {
                if (!isNullOrUndefined(this._boardVO.boardRows[i].price)) {
                    price += this._boardVO.boardRows[i].price;
                }
            }
            var one = 1;
            price *= ((isNullOrUndefined(this.get_pickSystem())) ? one : this.get_pickSystem().combinations) * this._boardStackProxy._wagerProxy.get_editionCount() * this._dgGameConfigProxy.getEditionSeriesByID(this._boardStackProxy.get_seriesId()).eventSeriesCount;
            return price;
        }
        else {
            return 0;
        }
    },
    
    isPopulated: function LotteryBoardService_BoardProxy$isPopulated() {
        var populatedSetCount = 0;
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var o = $enum1.get_current();
            if (!o.get_active()) {
                continue;
            }
            if (!o.isPopulated()) {
                return false;
            }
            populatedSetCount++;
        }
        return populatedSetCount > 0;
    },
    
    isEmpty: function LotteryBoardService_BoardProxy$isEmpty() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var o = $enum1.get_current();
            if (!o.isEmpty()) {
                return false;
            }
        }
        return true;
    },
    
    hasQPFields: function LotteryBoardService_BoardProxy$hasQPFields() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            if (set.hasQPFields()) {
                return true;
            }
        }
        return false;
    },
    
    isServerQuickPick: function LotteryBoardService_BoardProxy$isServerQuickPick() {
        return this._boardStackProxy.get_serverQP();
    },
    
    isPartialQPAllowed: function LotteryBoardService_BoardProxy$isPartialQPAllowed() {
        return this._dgGameConfigVO.partialQPAllowed;
    },
    
    getNumbers: function LotteryBoardService_BoardProxy$getNumbers() {
        var ass = [];
        for (var s = 0; s < this.get_setCount(); s++) {
            for (var n = 0; n < this.getSet(s).get_numberCount(); n++) {
                ass.add(this.getSet(s).getNumber(n));
            }
        }
        return ass;
    },
    
    areSameNumbersInRange: function LotteryBoardService_BoardProxy$areSameNumbersInRange() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            var count = set.sameNumbersCount();
            if (count > set.maxSameSymbols || count < set.minSameSymbols) {
                return false;
            }
        }
        return true;
    },
    
    _addSet: function LotteryBoardService_BoardProxy$_addSet(setProxy) {
        var newIndex = this._setList.length;
        setProxy._index = newIndex;
        setProxy._boardProxy = this;
        this._setList[newIndex] = setProxy;
        this._numbersCount += setProxy.get_numberCount();
    },
    
    _removeSets: function LotteryBoardService_BoardProxy$_removeSets() {
        (this._setList).clear();
        this._numbersCount = 0;
    },
    
    _clear: function LotteryBoardService_BoardProxy$_clear() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var o = $enum1.get_current();
            o._clear();
        }
    },
    
    _clearQPFields: function LotteryBoardService_BoardProxy$_clearQPFields() {
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            set._clearQPFields();
        }
    },
    
    _getNumbersAsString: function LotteryBoardService_BoardProxy$_getNumbersAsString() {
        var sb = new StringBuilder();
        for (var s = 0; s < this._setList.length; s++) {
            var set = this.getSet(s);
            if (set.get_active()) {
                sb.append(set._getNumbersAsString());
            }
            if (s < this._setList.length - 1) {
                sb.append(':');
            }
        }
        return sb.toString();
    },
    
    _setNumbersFromString: function LotteryBoardService_BoardProxy$_setNumbersFromString(numbersString) {
        var arrSets = numbersString.split(':');
        for (var s = 0; s < this._setList.length; s++) {
            this.getSet(s)._setNumbersFromString(arrSets[s]);
        }
    },
    
    _getQPAsString: function LotteryBoardService_BoardProxy$_getQPAsString() {
        var pickValues = '';
        for (var s = 0; s < this.get_setCount(); s++) {
            if (s > 0) {
                pickValues += ':';
            }
            pickValues += this.getSet(s)._getQPAsString();
        }
        return pickValues;
    },
    
    _setQPFromString: function LotteryBoardService_BoardProxy$_setQPFromString(qpString) {
        var arrSets = qpString.split(':');
        for (var s = 0; s < this.get_setCount(); s++) {
            var set = this.getSet(s);
            set._setQPFromString(arrSets[s]);
        }
    },
    
    get_availableDraws: function LotteryBoardService_BoardProxy$get_availableDraws() {
        return this._dgGameConfigVO.draws;
    },
    
    get_availablePickSystems: function LotteryBoardService_BoardProxy$get_availablePickSystems() {
        return this._dgGameConfigVO.pickSystems;
    },
    
    _setBoardRowPrice: function LotteryBoardService_BoardProxy$_setBoardRowPrice(drawID, price) {
        var boardRow = this._getBoardRowByID(drawID);
        if (!boardRow.enabled) {
            throw new Error('BoardRow is not enabled. Enter dependant boardRow\'s price first.');
        }
        boardRow.price = price;
        this._checkDependencies();
    },
    
    _setBoardRowPriceByPickSystem: function LotteryBoardService_BoardProxy$_setBoardRowPriceByPickSystem(pickSystem, price) {
        var boardRow = this._getBoardRowByPickSystem(pickSystem);
        if (!boardRow.enabled) {
            throw new Error('BoardRow is not enabled. Enter dependant boardRow\'s price first.');
        }
        boardRow.price = price;
        this._checkDependencies();
    },
    
    getBoardRowPrice: function LotteryBoardService_BoardProxy$getBoardRowPrice(drawID) {
        return this._getBoardRowByID(drawID).price;
    },
    
    getBoardRowByPickSystemPrice: function LotteryBoardService_BoardProxy$getBoardRowByPickSystemPrice(pickSystem) {
        return this._getBoardRowByPickSystem(pickSystem).price;
    },
    
    isBoardRowEnabled: function LotteryBoardService_BoardProxy$isBoardRowEnabled(drawID) {
        return this._getBoardRowByID(drawID).enabled;
    },
    
    isBoardRowByPickSystemEnabled: function LotteryBoardService_BoardProxy$isBoardRowByPickSystemEnabled(pickSystem) {
        return this._getBoardRowByPickSystem(pickSystem).enabled;
    },
    
    _getBoardRowByID: function LotteryBoardService_BoardProxy$_getBoardRowByID(drawID) {
        drawID = '' + drawID;
        var $enum1 = this._boardVO.boardRows.getEnumerator();
        while ($enum1.moveNext()) {
            var boardRow = $enum1.get_current();
            if (boardRow.drawID === drawID) {
                return boardRow;
            }
        }
        return null;
    },
    
    _getBoardRowByPickSystem: function LotteryBoardService_BoardProxy$_getBoardRowByPickSystem(pickSystemId) {
        pickSystemId = '' + pickSystemId;
        var $enum1 = this._boardVO.boardRows.getEnumerator();
        while ($enum1.moveNext()) {
            var boardRow = $enum1.get_current();
            if (boardRow.pickSystemId === pickSystemId) {
                return boardRow;
            }
        }
        return null;
    },
    
    get__boardRows: function LotteryBoardService_BoardProxy$get__boardRows() {
        return this._boardVO.boardRows;
    },
    
    _drawDependenciesOK: function LotteryBoardService_BoardProxy$_drawDependenciesOK(draw) {
        if (!isNullOrUndefined(draw.dependantDraws)) {
            var $enum1 = draw.dependantDraws.getEnumerator();
            while ($enum1.moveNext()) {
                var d = $enum1.get_current();
                var did = '' + d;
                var r = this._getBoardRowByID(did);
                if (isNullOrUndefined(r.price)) {
                    return false;
                }
            }
        }
        return true;
    },
    
    _setDependenciesOK: function LotteryBoardService_BoardProxy$_setDependenciesOK(set) {
        if (!set.get_optional()) {
            return true;
        }
        var $enum1 = this._dgGameConfigVO.draws.getEnumerator();
        while ($enum1.moveNext()) {
            var draw = $enum1.get_current();
            var row = this._getBoardRowByID(draw.id);
            if (isNullOrUndefined(row.price)) {
                continue;
            }
            if (!isNullOrUndefined(draw.dependantSets)) {
                var $enum2 = draw.dependantSets.getEnumerator();
                while ($enum2.moveNext()) {
                    var setID = $enum2.get_current();
                    if (setID === set.get_id()) {
                        return true;
                    }
                }
            }
        }
        return false;
    },
    
    _checkDependencies: function LotteryBoardService_BoardProxy$_checkDependencies() {
        for (var i = 0; i < this._boardVO.boardRows.length; i++) {
            var row = this._boardVO.boardRows[i];
            if (!isNullOrUndefined(row.drawID)) {
                var draw = this._dgGameConfigProxy.getDrawByID(row.drawID);
                if (isNullOrUndefined(draw.option) || draw.option === 'required') {
                    row.enabled = (!i) ? true : draw.priceList.length > 1;
                    if (isNullOrUndefined(row.price)) {
                        row.price = draw.priceList[0];
                    }
                }
                else {
                    row.enabled = this._drawDependenciesOK(draw);
                    if (!row.enabled) {
                        row.price = null;
                    }
                }
            }
            else {
                row.enabled = true;
            }
        }
        var $enum1 = this._setList.getEnumerator();
        while ($enum1.moveNext()) {
            var set = $enum1.get_current();
            set._active = this._setDependenciesOK(set);
        }
    },
    
    _configurePickSystem: function LotteryBoardService_BoardProxy$_configurePickSystem() {
        var picksystemConfig = null;
        if (this._boardVO.pickSystemID) {
            picksystemConfig = this._dgGameConfigProxy.getPickSystemByID(this._boardVO.pickSystemID);
        }
        else {
            picksystemConfig = this._dgGameConfigProxy.getPickSystemByID(this._boardVO.boardRows[0].pickSystemId);
        }
        this._removeSets();
        for (var s = 0; s < picksystemConfig.sets.length; s++) {
            var dgSet = this._dgGameConfigVO.sets[s];
            if (dgSet.isOnWager) {
                continue;
            }
            var psSet = picksystemConfig.sets[s];
            var setProxy = new LotteryBoardService.SetProxy(this._dgGameConfigProxy, psSet, dgSet);
            this._addSet(setProxy);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.BoardRowVO

LotteryBoardService.BoardRowVO = function LotteryBoardService_BoardRowVO() {
}
LotteryBoardService.BoardRowVO.prototype = {
    drawID: null,
    price: null,
    enabled: false,
    pickSystemId: null
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SetProxy

LotteryBoardService.SetProxy = function LotteryBoardService_SetProxy(dgGameConfigProxy, dgPicksystemSetConfigVO, dgSetConfigVO) {
    this._index = -1;
    this._numbers = new Array(0);
    this._alphaNumeric = dgSetConfigVO.isAlphaNumeric;
    this.minRawAscii = dgSetConfigVO.min.charCodeAt(0);
    if (dgSetConfigVO.isAlphaNumeric) {
        this.min = 1;
        this.max = dgSetConfigVO.max.charCodeAt(0) - dgSetConfigVO.min.charCodeAt(0) + 1;
    }
    else {
        this.min = Number.parse(dgSetConfigVO.min);
        this.max = Number.parse(dgSetConfigVO.max);
    }
    this.repetitionAllowed = dgSetConfigVO.repetitionAllowed;
    this.minSameSymbols = dgPicksystemSetConfigVO.minSameSymbols;
    this.maxSameSymbols = dgPicksystemSetConfigVO.maxSameSymbols;
    this._dgGameConfigProxy = dgGameConfigProxy;
    this._dgSetConfig = dgSetConfigVO;
    this.set__data(new LotteryBoardService.SetVO());
    for (var n = 0; n < dgPicksystemSetConfigVO.symbolCount; n++) {
        var number = new LotteryBoardService.NumberProxy();
        number._enabled = (isNullOrUndefined(dgPicksystemSetConfigVO.symbolMask)) ? true : dgPicksystemSetConfigVO.symbolMask.charAt(n) !== '0';
        this._addNumber(number);
    }
}
LotteryBoardService.SetProxy.prototype = {
    _dgGameConfigProxy: null,
    _dgSetConfig: null,
    _setVO: null,
    _boardProxy: null,
    _active: true,
    min: 0,
    max: 0,
    minRawAscii: null,
    repetitionAllowed: false,
    minSameSymbols: null,
    maxSameSymbols: null,
    _alphaNumeric: false,
    
    get_isAlphaNumeric: function LotteryBoardService_SetProxy$get_isAlphaNumeric() {
        return this._alphaNumeric;
    },
    
    get__data: function LotteryBoardService_SetProxy$get__data() {
        return this._setVO;
    },
    set__data: function LotteryBoardService_SetProxy$set__data(value) {
        this._setVO = value;
        if (!isNullOrUndefined(this._setVO.numberVOList)) {
            for (var n = 0; n < this._setVO.numberVOList.length; n++) {
                this._numbers[n].set__data(this._setVO.numberVOList[n]);
            }
        }
        return value;
    },
    
    get_numberCount: function LotteryBoardService_SetProxy$get_numberCount() {
        return this._numbers.length;
    },
    
    get_board: function LotteryBoardService_SetProxy$get_board() {
        return this._boardProxy;
    },
    
    get_index: function LotteryBoardService_SetProxy$get_index() {
        return this._index;
    },
    
    get_id: function LotteryBoardService_SetProxy$get_id() {
        return this._dgSetConfig.id;
    },
    
    get_optional: function LotteryBoardService_SetProxy$get_optional() {
        return this._dgSetConfig.optional;
    },
    
    get_active: function LotteryBoardService_SetProxy$get_active() {
        return this._active;
    },
    
    getNumber: function LotteryBoardService_SetProxy$getNumber(numberIndex) {
        return this._numbers[numberIndex];
    },
    
    containsValue: function LotteryBoardService_SetProxy$containsValue(number) {
        for (var i = 0; i < this.get_numberCount(); i++) {
            if (this._numbers[i].get_value() === number) {
                return true;
            }
        }
        return false;
    },
    
    getIndexOf: function LotteryBoardService_SetProxy$getIndexOf(numberValue) {
        for (var i = 0; i < this.get_numberCount(); i++) {
            if (this._numbers[i].get_value() === numberValue) {
                return i;
            }
        }
        return -1;
    },
    
    isPopulated: function LotteryBoardService_SetProxy$isPopulated() {
        for (var i = 0; i < this.get_numberCount(); i++) {
            if (this._numbers[i].get_enabled() && !this._numbers[i].isPopulated()) {
                return false;
            }
        }
        return true;
    },
    
    isEmpty: function LotteryBoardService_SetProxy$isEmpty() {
        for (var i = 0; i < this.get_numberCount(); i++) {
            if (!this._numbers[i].isEmpty()) {
                return false;
            }
        }
        return true;
    },
    
    getNumbers: function LotteryBoardService_SetProxy$getNumbers() {
        var ass = [];
        for (var n = 0; n < this.get_numberCount(); n++) {
            ass.add(this.getNumber(n));
        }
        return ass;
    },
    
    sameNumbersCount: function LotteryBoardService_SetProxy$sameNumbersCount() {
        var numberCounts = {};
        var $enum1 = this._numbers.getEnumerator();
        while ($enum1.moveNext()) {
            var number = $enum1.get_current();
            if (!number.get_enabled() || number.isEmpty()) {
                continue;
            }
            var strNum = number.get_value().toString();
            if (Object.keyExists(numberCounts, strNum)) {
                var count = numberCounts[strNum];
                numberCounts[strNum] = count + 1;
            }
            else {
                numberCounts[strNum] = 1;
            }
        }
        var max = 0;
        var $dict2 = numberCounts;
        for (var $key3 in $dict2) {
            var de = { key: $key3, value: $dict2[$key3] };
            var count = de.value;
            if (count > max) {
                max = count;
            }
        }
        return max;
    },
    
    hasQPFields: function LotteryBoardService_SetProxy$hasQPFields() {
        var $enum1 = this._numbers.getEnumerator();
        while ($enum1.moveNext()) {
            var number = $enum1.get_current();
            if (number.isQuickPick()) {
                return true;
            }
        }
        return false;
    },
    
    _addNumber: function LotteryBoardService_SetProxy$_addNumber(number) {
        var newIndex = this._numbers.length;
        number._index = newIndex;
        number._setProxy = this;
        this._numbers[newIndex] = number;
    },
    
    _clear: function LotteryBoardService_SetProxy$_clear() {
        for (var i = 0; i < this.get_numberCount(); i++) {
            this._numbers[i]._clear();
        }
    },
    
    _clearQPFields: function LotteryBoardService_SetProxy$_clearQPFields() {
        for (var i = 0; i < this._numbers.length; i++) {
            var number = this._numbers[i];
            if (number.get_enabled() && number.isQuickPick()) {
                number._clear();
            }
        }
    },
    
    _getNumbersAsString: function LotteryBoardService_SetProxy$_getNumbersAsString() {
        var sb = new StringBuilder();
        for (var n = 0; n < this._numbers.length; n++) {
            var number = this.getNumber(n);
            if (number.get_enabled()) {
                sb.append(number.get_entry());
            }
            else {
                sb.append(LotteryBoardService.SetProxy.disableD_NUMBER_CHAR);
            }
            if (n < this._numbers.length - 1) {
                sb.append(',');
            }
        }
        return sb.toString();
    },
    
    _setNumbersFromString: function LotteryBoardService_SetProxy$_setNumbersFromString(strNumbers) {
        var arrNumbers = strNumbers.split(',');
        for (var n = 0; n < this._numbers.length; n++) {
            var number = this.getNumber(n);
            if (arrNumbers[n] === LotteryBoardService.SetProxy.disableD_NUMBER_CHAR) {
                number._clear();
            }
            else {
                number._setEntry(arrNumbers[n]);
            }
        }
    },
    
    _getQPAsString: function LotteryBoardService_SetProxy$_getQPAsString() {
        var pickValues = '';
        for (var n = 0; n < this.get_numberCount(); n++) {
            if (n > 0) {
                pickValues += ',';
            }
            var number = this.getNumber(n);
            if (!number.get_enabled()) {
                pickValues += '';
            }
            else if (number.isPopulated() && !number.isQuickPick()) {
                pickValues += number.get_entry();
            }
            else {
                pickValues += 'QP';
            }
        }
        return pickValues;
    },
    
    _setQPFromString: function LotteryBoardService_SetProxy$_setQPFromString(strNumbers) {
        var clientSelection = [];
        for (var n = 0; n < this.get_numberCount(); n++) {
            var number = this.getNumber(n);
            if (!(number.isClientQP() || number.isServerQP()) && number.get_enabled() && number.isPopulated() && !number.isEmpty()) {
                clientSelection.add(number.get_value());
            }
        }
        this._clear();
        var arrNumbers = strNumbers.split(',');
        for (var n = 0; n < this.get_numberCount(); n++) {
            var number = this.getNumber(n);
            if ((number.isEmpty() || (number.isPopulated() && number.isClientQP())) && number.get_enabled()) {
                number._setClientQPFromString(arrNumbers[n]);
            }
        }
        for (var n = 0; n < this.get_numberCount(); n++) {
            var number = this.getNumber(n);
            var oldValue = number.get_value();
            if (clientSelection.contains(oldValue)) {
                number._clear();
                number._setValue(oldValue);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsMessageEvent

LotteryBoardService.SportsMessageEvent = function LotteryBoardService_SportsMessageEvent(InstanceID) {
    LotteryBoardService.SportsMessageEvent.constructBase(this, [ InstanceID ]);
}
LotteryBoardService.SportsMessageEvent.prototype = {
    message: null,
    isAlert: true,
    confirmationRequired: false,
    confirmCallback: null,
    rejectCallback: null,
    
    toString: function LotteryBoardService_SportsMessageEvent$toString() {
        return LotteryBoardService.SportsMessageEvent.callBase(this, 'toString') + ', messageId: ' + this.message.messageID + '[' + Enum.toString(LotteryBoardService.SportsMessageType, this.message.messageType) + '], messagetitle: ' + this.message.messageTitle + ', messageText: ' + this.message.messageText;
    }
}


////////////////////////////////////////////////////////////////////////////////
// LotteryBoardService.SportsMessages

LotteryBoardService.SportsMessages = function LotteryBoardService_SportsMessages() {
}


LotteryBoardService.AbstractControllerFactory.createClass('LotteryBoardService.AbstractControllerFactory');
LotteryBoardService._commonUtils.createClass('LotteryBoardService._commonUtils');
LotteryBoardService.AbstractController.createClass('LotteryBoardService.AbstractController');
LotteryBoardService.AbstractLotteryController.createClass('LotteryBoardService.AbstractLotteryController', LotteryBoardService.AbstractController);
LotteryBoardService.QuickPickHelper.createClass('LotteryBoardService.QuickPickHelper');
LotteryBoardService.BoardStackVO.createClass('LotteryBoardService.BoardStackVO');
LotteryBoardService.MessageVO.createClass('LotteryBoardService.MessageVO');
LotteryBoardService.SetVO.createClass('LotteryBoardService.SetVO');
LotteryBoardService.NumberVO.createClass('LotteryBoardService.NumberVO');
LotteryBoardService.WagerVO.createClass('LotteryBoardService.WagerVO');
LotteryBoardService.InstanceContext.createClass('LotteryBoardService.InstanceContext');
LotteryBoardService.DGGameConfigProxy.createClass('LotteryBoardService.DGGameConfigProxy');
LotteryBoardService.LotteryContext.createClass('LotteryBoardService.LotteryContext');
LotteryBoardService.DGConfigVO.createClass('LotteryBoardService.DGConfigVO');
LotteryBoardService.DGGameConfigVO.createClass('LotteryBoardService.DGGameConfigVO');
LotteryBoardService.DGEditionSeriesConfigVO.createClass('LotteryBoardService.DGEditionSeriesConfigVO');
LotteryBoardService.DGDrawConfigVO.createClass('LotteryBoardService.DGDrawConfigVO');
LotteryBoardService.DGSetConfigVO.createClass('LotteryBoardService.DGSetConfigVO');
LotteryBoardService.DGPicksystemConfigVO.createClass('LotteryBoardService.DGPicksystemConfigVO');
LotteryBoardService.DGPicksystemSetConfigVO.createClass('LotteryBoardService.DGPicksystemSetConfigVO');
LotteryBoardService.DGGameEventVO.createClass('LotteryBoardService.DGGameEventVO');
LotteryBoardService.FundingTypeIdList.createClass('LotteryBoardService.FundingTypeIdList');
LotteryBoardService.SchedulePeriodIdList.createClass('LotteryBoardService.SchedulePeriodIdList');
LotteryBoardService.AutoChangeSystem.createClass('LotteryBoardService.AutoChangeSystem');
LotteryBoardService.LotteryMessages.createClass('LotteryBoardService.LotteryMessages');
LotteryBoardService.LotteryEventDispatcher.createClass('LotteryBoardService.LotteryEventDispatcher');
LotteryBoardService.BoardVO.createClass('LotteryBoardService.BoardVO');
LotteryBoardService.AbstractLotteryEvent.createClass('LotteryBoardService.AbstractLotteryEvent');
LotteryBoardService.BoardStackContentEvent.createClass('LotteryBoardService.BoardStackContentEvent', LotteryBoardService.AbstractLotteryEvent);
LotteryBoardService.LotteryPropertyChangedEvent.createClass('LotteryBoardService.LotteryPropertyChangedEvent', LotteryBoardService.AbstractLotteryEvent);
LotteryBoardService.LotteryActionEvent.createClass('LotteryBoardService.LotteryActionEvent', LotteryBoardService.AbstractLotteryEvent);
LotteryBoardService.BoardStackProxy.createClass('LotteryBoardService.BoardStackProxy');
LotteryBoardService.LotteryMessageEvent.createClass('LotteryBoardService.LotteryMessageEvent', LotteryBoardService.AbstractLotteryEvent);
LotteryBoardService.WagerProxy.createClass('LotteryBoardService.WagerProxy');
LotteryBoardService.WagerController.createClass('LotteryBoardService.WagerController', LotteryBoardService.AbstractLotteryController, UserService.IUserChangedListener);
LotteryBoardService._boardStackPropertyChangeListener.createClass('LotteryBoardService._boardStackPropertyChangeListener', null, LotteryBoardService.ILotteryPropertyChangedListener);
LotteryBoardService._boardStackContentChangeListener.createClass('LotteryBoardService._boardStackContentChangeListener', null, LotteryBoardService.IBoardStackContentListener);
LotteryBoardService.AbstractSportsEvent.createClass('LotteryBoardService.AbstractSportsEvent');
LotteryBoardService.SportsBoardContext.createClass('LotteryBoardService.SportsBoardContext');
LotteryBoardService.SportsPickSystem.createClass('LotteryBoardService.SportsPickSystem');
LotteryBoardService.SportsRowContext.createClass('LotteryBoardService.SportsRowContext');
LotteryBoardService.SportsSelectionContext.createClass('LotteryBoardService.SportsSelectionContext');
LotteryBoardService.SportsSetContext.createClass('LotteryBoardService.SportsSetContext');
LotteryBoardService._outcomeWithIndex.createClass('LotteryBoardService._outcomeWithIndex');
LotteryBoardService.SportsMessage.createClass('LotteryBoardService.SportsMessage');
LotteryBoardService.SportsBoardContentEvent.createClass('LotteryBoardService.SportsBoardContentEvent', LotteryBoardService.AbstractSportsEvent);
LotteryBoardService.SportsBoardInitData.createClass('LotteryBoardService.SportsBoardInitData');
LotteryBoardService.SportsSetInitData.createClass('LotteryBoardService.SportsSetInitData');
LotteryBoardService.SportsSystemsInitData.createClass('LotteryBoardService.SportsSystemsInitData');
LotteryBoardService.SportsSystemsSetsInitData.createClass('LotteryBoardService.SportsSystemsSetsInitData');
LotteryBoardService.SportsEvents.createClass('LotteryBoardService.SportsEvents');
LotteryBoardService.SportsCompetitors.createClass('LotteryBoardService.SportsCompetitors');
LotteryBoardService.SportsOutcome.createClass('LotteryBoardService.SportsOutcome');
LotteryBoardService.GameDrawInitData.createClass('LotteryBoardService.GameDrawInitData');
LotteryBoardService.SportsBoardStateData.createClass('LotteryBoardService.SportsBoardStateData');
LotteryBoardService.SportsRowStateData.createClass('LotteryBoardService.SportsRowStateData');
LotteryBoardService.SportsBoardStateEvent.createClass('LotteryBoardService.SportsBoardStateEvent', LotteryBoardService.AbstractSportsEvent);
LotteryBoardService.SportsControllerFactory.createClass('LotteryBoardService.SportsControllerFactory', LotteryBoardService.AbstractControllerFactory);
LotteryBoardService.LotteryControllerFactory.createClass('LotteryBoardService.LotteryControllerFactory', LotteryBoardService.AbstractControllerFactory);
LotteryBoardService.SportsController.createClass('LotteryBoardService.SportsController', LotteryBoardService.AbstractController);
LotteryBoardService.BoardStackController.createClass('LotteryBoardService.BoardStackController', LotteryBoardService.AbstractLotteryController);
LotteryBoardService.LotteryBoardService.createClass('LotteryBoardService.LotteryBoardService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
LotteryBoardService.NumberProxy.createClass('LotteryBoardService.NumberProxy');
LotteryBoardService.BoardProxy.createClass('LotteryBoardService.BoardProxy');
LotteryBoardService.BoardRowVO.createClass('LotteryBoardService.BoardRowVO');
LotteryBoardService.SetProxy.createClass('LotteryBoardService.SetProxy');
LotteryBoardService.SportsMessageEvent.createClass('LotteryBoardService.SportsMessageEvent', LotteryBoardService.AbstractSportsEvent);
LotteryBoardService.SportsMessages.createClass('LotteryBoardService.SportsMessages');
LotteryBoardService._commonUtils.NULL = null;
LotteryBoardService._commonUtils.nulL_DATE = LotteryBoardService._commonUtils.NULL;
LotteryBoardService._commonUtils.ZERO = 0;
LotteryBoardService.FundingTypeIdList.MANUAL = 'MANUAL';
LotteryBoardService.FundingTypeIdList.owN_SCHEDULE_FIXED = 'OWN_SCHEDULE_FIXED';
LotteryBoardService.FundingTypeIdList.owN_SCHEDULE_VARIABLE = 'OWN_SCHEDULE_VARIABLE';
LotteryBoardService.FundingTypeIdList.synchronizeD_AUTOMATIC = 'SYNCHRONIZED_AUTOMATIC';
LotteryBoardService.FundingTypeIdList.synchronizeD_STAKE = 'SYNCHRONIZED_STAKE';
LotteryBoardService.FundingTypeIdList.synchronizeD_TOTAL = 'SYNCHRONIZED_TOTAL';
LotteryBoardService.SchedulePeriodIdList.WEEKLY = 'WEEKLY';
LotteryBoardService.SchedulePeriodIdList.MONTHLY = 'MONTHLY';
LotteryBoardService.AutoChangeSystem.NONE = 'none';
LotteryBoardService.AutoChangeSystem.UP = 'up';
LotteryBoardService.AutoChangeSystem.DOWN = 'down';
LotteryBoardService.LotteryMessages.loG_IN = 'log_in';
LotteryBoardService.LotteryMessages.INPUT = 'input';
LotteryBoardService.LotteryMessages.inpuT_TITLE = 'input_title';
LotteryBoardService.LotteryMessages.confirM_PLACEMENT = 'confirm_placement';
LotteryBoardService.LotteryMessages.confirM_PLACEMENT_TITLE = 'confirm_placement_title';
LotteryBoardService.LotteryMessages.confirM_SUBSCRIPTION = 'confirm_subscription';
LotteryBoardService.LotteryMessages.confirM_SUBSCRIPTION_TITLE = 'confirm_subscription_title';
LotteryBoardService.LotteryMessages.placemenT_IN_PROGRESS = 'placement_in_progress';
LotteryBoardService.LotteryMessages.placemenT_IN_PROGRESS_TITLE = 'placement_in_progress_title';
LotteryBoardService.LotteryMessages.subscriptioN_IN_PROGRESS = 'subscription_in_progress';
LotteryBoardService.LotteryMessages.subscriptioN_IN_PROGRESS_TITLE = 'subscription_in_progress_title';
LotteryBoardService.LotteryMessages.placE_OK = 'placement_ok';
LotteryBoardService.LotteryMessages.placE_OK_TITLE = 'placement_ok_title';
LotteryBoardService.LotteryMessages.placE_FAILED = 'placement_failed';
LotteryBoardService.LotteryMessages.placE_FAILED_TITLE = 'placement_failed_title';
LotteryBoardService.LotteryMessages.subscriptioN_OK = 'subscription_ok';
LotteryBoardService.LotteryMessages.subscriptioN_OK_TITLE = 'subscription_ok_title';
LotteryBoardService.LotteryMessages.subscriptioN_FAILED = 'subscription_failed';
LotteryBoardService.LotteryMessages.subscriptioN_FAILED_TITLE = 'subscription_failed_title';
LotteryBoardService.LotteryMessages.selecT_ALL_NUMBERS = 'select_all_numbers';
LotteryBoardService.LotteryMessages.cleaR_QUICK_PICK = 'clear_quick_pick';
LotteryBoardService.LotteryMessages.cleaR_NUMBERS = 'clear_numbers';
LotteryBoardService.LotteryMessages.noT_NUMBER = 'not_number';
LotteryBoardService.LotteryMessages.BETWEEN = 'between';
LotteryBoardService.LotteryMessages.alreadY_EXISTS = 'already_exists';
LotteryBoardService.LotteryMessages.lesS_THEN_MIN = 'less_then_min';
LotteryBoardService.LotteryMessages.samE_NUMBERS_OUT_OF_RANGE = 'same_numbers_out_of_range';
LotteryBoardService.LotteryMessages.favoriteS_TITLE = 'favorites_title';
LotteryBoardService.LotteryMessages.favoriteS_IN_PROGRES = 'favorites_in_progres';
LotteryBoardService.LotteryMessages.favoriteS_OK = 'favorites_ok';
LotteryBoardService.LotteryMessages.favoriteS_FAILED = 'favorites_failed';
LotteryBoardService.LotteryMessages.nO_SYSTEM_CHANGING_QP = 'no_systems_changing';
LotteryBoardService.LotteryPropertyChangedEvent.alL_PROPERTIES_CHANGED = 'AllPropertiesChanged';
LotteryBoardService.LotteryPropertyChangedEvent.vieW_STATE_CHANGED = 'ViewStateChanged';
LotteryBoardService.LotteryPropertyChangedEvent.pricE_CHANGED = 'PriceChanged';
LotteryBoardService.LotteryPropertyChangedEvent.editioN_COUNT_CHANGED = 'EditionCountChanged';
LotteryBoardService.LotteryPropertyChangedEvent.wageR_RESULT_ID = 'WagerResultId';
LotteryBoardService.LotteryPropertyChangedEvent.subscriptionS_NODE_CHANGED = 'SubscriptionsNodeChanged';
LotteryBoardService.LotteryPropertyChangedEvent.continuE_FOR_CHANGED = 'ContinueForChanged';
LotteryBoardService.LotteryPropertyChangedEvent.locK_FUNDS_CHANGED = 'LockFundsChanged';
LotteryBoardService.LotteryPropertyChangedEvent.starT_DATE_CHANGED = 'StartDateChanged';
LotteryBoardService.LotteryPropertyChangedEvent.fundinG_TYPE_CHANGED = 'FundingTypeChanged';
LotteryBoardService.LotteryPropertyChangedEvent.fundinG_TYPE_LIST_CHANGED = 'FundingTypeListChanged';
LotteryBoardService.LotteryPropertyChangedEvent.schedulE_PERIOD_CHANGED = 'SchedulePeriodChanged';
LotteryBoardService.LotteryPropertyChangedEvent.schedulE_OFFSET_CHANGED = 'ScheduleOffsetChanged';
LotteryBoardService.LotteryPropertyChangedEvent.paymenT_INSTRUMENT_CHANGED = 'PaymentInstrumentChanged';
LotteryBoardService.LotteryPropertyChangedEvent.paymenT_INSTRUMENT_LIST_CHANGED = 'PaymentInstrumentListChanged';
LotteryBoardService.LotteryPropertyChangedEvent.guaranteeD_JACKPOT_CHANGED = 'GuaranteedJackpotChanged';
LotteryBoardService.LotteryPropertyChangedEvent.rolloveR_AMOUNT_CHANGED = 'RolloverAmountChanged';
LotteryBoardService.LotteryPropertyChangedEvent.serieS_ID_CHANGED = 'SeriesIdChanged';
LotteryBoardService.LotteryPropertyChangedEvent.enableD_CHANGED = 'EnabledChanged';
LotteryBoardService.LotteryPropertyChangedEvent.forceqP_CHANGED = 'ForceQPChanged';
LotteryBoardService.LotteryActionEvent.wageR_PLACED = 'WagerPlaced';
LotteryBoardService.LotteryActionEvent.wageR_SUBSCRIBED = 'WagerSubscribed';
LotteryBoardService.SportsSelectionContext._digitRegex = new RegExp('\\D');
LotteryBoardService.SportsSelectionContext._symbolRegex = new RegExp('[^1X2]');
LotteryBoardService.LotteryBoardService._serviceName$1 = 'LotteryBoardService';
LotteryBoardService.NumberProxy._digitRegex = new RegExp('\\D');
LotteryBoardService.SetProxy.disableD_NUMBER_CHAR = '*';
LotteryBoardService.SportsMessages.loG_IN = 'log_in';
LotteryBoardService.SportsMessages.selecT_ALL_NUMBERS = 'select_all_numbers';
LotteryBoardService.SportsMessages.cleaR_QUICK_PICK = 'clear_quick_pick';
LotteryBoardService.SportsMessages.cleaR_NUMBERS = 'clear_numbers';
LotteryBoardService.SportsMessages.INPUT = 'input';
LotteryBoardService.SportsMessages.inpuT_TITLE = 'input_title';
LotteryBoardService.SportsMessages.confirM_PLACEMENT = 'confirm_placement';
LotteryBoardService.SportsMessages.confirM_PLACEMENT_TITLE = 'confirm_placement_title';
LotteryBoardService.SportsMessages.placemenT_IN_PROGRESS = 'placement_in_progress';
LotteryBoardService.SportsMessages.placemenT_IN_PROGRESS_TITLE = 'placement_in_progress_title';
LotteryBoardService.SportsMessages.placE_OK = 'placement_ok';
LotteryBoardService.SportsMessages.placE_OK_TITLE = 'placement_ok_title';
LotteryBoardService.SportsMessages.placE_FAILED = 'placement_failed';
LotteryBoardService.SportsMessages.placE_FAILED_TITLE = 'placement_failed_title';
LotteryBoardService.SportsMessages.exceedeD_NUMBER_OF_SELECTIONS = 'exceeded_number_of_selections';
LotteryBoardService.SportsMessages.wronG_SYSTEM = 'wrong_system';
LotteryBoardService.SportsMessages.wronG_SYMBOL = 'wrong_symbol';
LotteryBoardService.SportsMessages.serveR_UNAVAILABLE = 'server_unavailable';
LotteryBoardService.SportsMessages.invaliD_PICK_SYSTEM = 'invalid_picksystem';
LotteryBoardService.SportsMessages.toO_MANY_DOUBLES = 'too_many_doubles';
LotteryBoardService.SportsMessages.toO_MANY_TRIPLES = 'too_many_triples';
LotteryBoardService.SportsMessages.toO_MANY_DOUBLES_AND_TRIPLES = 'too_many_doubles_and_triples';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('NotificationService');

////////////////////////////////////////////////////////////////////////////////
// NotificationService.ICustomerNotificationPreferencesChangedListener

NotificationService.ICustomerNotificationPreferencesChangedListener = function() { };
NotificationService.ICustomerNotificationPreferencesChangedListener.prototype = {
    onCustomerNotificationPreferencesChanged : null
}
NotificationService.ICustomerNotificationPreferencesChangedListener.createInterface('NotificationService.ICustomerNotificationPreferencesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NotificationService.NotificationLog

NotificationService.NotificationLog = function NotificationService_NotificationLog() {
}
NotificationService.NotificationLog.prototype = {
    IDMMNTNotification: 0,
    IDMMNTType: null,
    IDMMNTMechanism: null,
    IDMMCustomer: 0,
    CustomerAddress: null,
    TSCreated: null,
    TSDelivered: null,
    TypeDescription: null,
    MechanismDescription: null
}


////////////////////////////////////////////////////////////////////////////////
// NotificationService.Notification

NotificationService.Notification = function NotificationService_Notification() {
}
NotificationService.Notification.prototype = {
    NotificationId: 0,
    TSCreated: null,
    NotificationTypeId: null,
    MessageType: null,
    MessageSubject: null,
    MessageBodyShort: null,
    MessageBody: null,
    CustomerId: 0,
    IDDCSessionCreated: null,
    MechanismId: null,
    CustomerAddress: null,
    TSDelivered: null,
    NumberOfParameters: 0,
    Parameters: null
}


////////////////////////////////////////////////////////////////////////////////
// NotificationService.NotificationPreference

NotificationService.NotificationPreference = function NotificationService_NotificationPreference() {
}
NotificationService.NotificationPreference.prototype = {
    IDMMNTType: null,
    IDMMNTMechanism: null
}


////////////////////////////////////////////////////////////////////////////////
// NotificationService.NotificationService

NotificationService.NotificationService = function NotificationService_NotificationService() {
    this._oCustomerNotificationPreference$1 = [];
    this._customerNotificationPreferencesChangedListeners$1 = new Framework.ListenerInvoker(true);
    NotificationService.NotificationService.constructBase(this);
}
NotificationService.NotificationService.prototype = {
    
    registerCustomerNotificationPreferencesChangedListener: function NotificationService_NotificationService$registerCustomerNotificationPreferencesChangedListener(customerNotificationPreferencesChangedListeners) {
        NotificationService.NotificationService._log$1.debug('RegisterCustomerNotificationPreferencesChanged');
        this._customerNotificationPreferencesChangedListeners$1.registerListener(customerNotificationPreferencesChangedListeners);
    },
    
    unregisterCustomerNotificationPreferencesChangedListener: function NotificationService_NotificationService$unregisterCustomerNotificationPreferencesChangedListener(customerNotificationPreferencesChangedListeners) {
        NotificationService.NotificationService._log$1.debug('UnregisterCustomerNotificationPreferencesChanged');
        this._customerNotificationPreferencesChangedListeners$1.unregisterListener(customerNotificationPreferencesChangedListeners);
    },
    
    _fireCustomerNotificationPreferencesChangedEvent$1: function NotificationService_NotificationService$_fireCustomerNotificationPreferencesChangedEvent$1() {
        NotificationService.NotificationService._log$1.debug('FireCustomerNotificationPreferencesChangedEvent');
        this._customerNotificationPreferencesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onCustomerNotificationPreferencesChanged(this);
        }));
    },
    
    onPageWillChange: function NotificationService_NotificationService$onPageWillChange() {
        NotificationService.NotificationService._log$1.debug('OnPageWillChange');
        this._environment.storeState(NotificationService.NotificationService._serviceName$1, { CustomerNotificationPreference: this._oCustomerNotificationPreference$1 });
    },
    
    _userService$1: null,
    
    setUserService: function NotificationService_NotificationService$setUserService(userService) {
        NotificationService.NotificationService._log$1.debug('SetUserService');
        this._userService$1 = userService;
    },
    
    onUserChanged: function NotificationService_NotificationService$onUserChanged(eventSource) {
        NotificationService.NotificationService._log$1.debug('OnUserChanged');
        if (this._userService$1.isLoggedIn()) {
            this._fetchCustomerNotificationPreferences$1();
        }
    },
    
    start: function NotificationService_NotificationService$start() {
        NotificationService.NotificationService._log$1.debug('Start');
        if (this._userService$1.isLoggedIn()) {
            this._fetchCustomerNotificationPreferences$1();
        }
    },
    
    init: function NotificationService_NotificationService$init(environment, parameters) {
        NotificationService.NotificationService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        NotificationService.NotificationService.callBase(this, 'init', [ environment, parameters ]);
        var state = this._environment.getStoredState(NotificationService.NotificationService._serviceName$1);
        if (state && Object.keyExists(state, 'CustomerNotificationPreference')) {
            this._oCustomerNotificationPreference$1 = state['CustomerNotificationPreference'];
        }
    },
    
    get_customerNotificationPreferences: function NotificationService_NotificationService$get_customerNotificationPreferences() {
        return this._oCustomerNotificationPreference$1;
    },
    
    _fetchCustomerNotificationPreferences$1: function NotificationService_NotificationService$_fetchCustomerNotificationPreferences$1() {
        this._getCustomerNotificationPreferences$1(Delegate.create(this, function(result) {
            if (result) {
                this._oCustomerNotificationPreference$1 = result;
            }
            this._fireCustomerNotificationPreferencesChangedEvent$1();
        }), Delegate.create(this, function(exception) {
        }));
    },
    
    _getCustomerNotificationPreferences$1: function NotificationService_NotificationService$_getCustomerNotificationPreferences$1(successCallback, failureCallback) {
        NotificationService.NotificationService._log$1.debug('GetCustomerNotificationPreferences');
        this._environment.invokeAsync(NotificationService.NotificationService._serviceName$1, 'GetCustomerNotificationPreferences', {}, Delegate.create(this, function(result) {
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NotificationService.NotificationService._log$1.debug('GetCustomerNotificationPreferences exception ' + exception.message);
            if (exception.message.indexOf('Session has timed out') > 0) {
                this._sessionTimeoutHandler$1();
            }
            failureCallback.invoke(exception);
        }));
    },
    
    setCustomerNotificationPreferences: function NotificationService_NotificationService$setCustomerNotificationPreferences(successCallback, failureCallback, IDMDLanguage, preferences) {
        NotificationService.NotificationService._log$1.debug('SetCustomerNotificationPreferences');
        this._environment.invokeAsync(NotificationService.NotificationService._serviceName$1, 'SetCustomerNotificationPreferences', { preferences: preferences }, Delegate.create(this, function(result) {
            if (successCallback) {
                this._fetchCustomerNotificationPreferences$1();
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NotificationService.NotificationService._log$1.debug('SetCustomerNotificationPreferences exception ' + exception.message);
            if (exception.message.indexOf('Session has timed out') > 0) {
                this._sessionTimeoutHandler$1();
            }
            failureCallback.invoke(exception);
        }));
    },
    
    getUndeliveredPopupNotifications: function NotificationService_NotificationService$getUndeliveredPopupNotifications(successCallback, failureCallback) {
        NotificationService.NotificationService._log$1.debug('GetUndeliveredPopupNotifications');
        this._environment.invokeAsync(NotificationService.NotificationService._serviceName$1, 'GetUndeliveredPopupNotifications', {}, Delegate.create(this, function(result) {
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NotificationService.NotificationService._log$1.debug('GetUndeliveredPopupNotifications exception ' + exception.message);
            if (exception.message.indexOf('Session has timed out') > 0) {
                this._sessionTimeoutHandler$1();
            }
            failureCallback.invoke(exception);
        }));
    },
    
    markDelivered: function NotificationService_NotificationService$markDelivered(successCallback, failureCallback, IDMMNTNotification) {
        NotificationService.NotificationService._log$1.debug('MarkDelivered');
        this._environment.invokeAsync(NotificationService.NotificationService._serviceName$1, 'MarkDelivered', { IDMMNTNotification: IDMMNTNotification }, successCallback, Delegate.create(this, function(exception) {
            NotificationService.NotificationService._log$1.debug('MarkDelivered exception ' + exception.message);
            if (exception.message.indexOf('Session has timed out') > 0) {
                this._sessionTimeoutHandler$1();
            }
            failureCallback.invoke(exception);
        }));
    },
    
    getNotificationLog: function NotificationService_NotificationService$getNotificationLog(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, idmmntType, idmmntmechanism) {
        NotificationService.NotificationService._log$1.debug('GetNotificationLog');
        this._environment.invokeAsync(NotificationService.NotificationService._serviceName$1, 'GetNotificationLog', { from: from, to: to, pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, idmmntType: idmmntType, idmmntMechanism: idmmntmechanism }, Delegate.create(this, function(result) {
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NotificationService.NotificationService._log$1.debug('GetNotificationLog exception ' + exception.message);
            if (exception.message.indexOf('Session has timed out') > 0) {
                this._sessionTimeoutHandler$1();
            }
            failureCallback.invoke(exception);
        }));
    },
    
    _sessionTimeoutHandler$1: function NotificationService_NotificationService$_sessionTimeoutHandler$1() {
        this._userService$1.logout(Delegate.create(this, function(result) {
        }), Delegate.create(this, function(exception) {
        }));
    }
}


NotificationService.NotificationLog.createClass('NotificationService.NotificationLog');
NotificationService.Notification.createClass('NotificationService.Notification');
NotificationService.NotificationPreference.createClass('NotificationService.NotificationPreference');
NotificationService.NotificationService.createClass('NotificationService.NotificationService', Framework.AbstractService, UserService.IUserChangedListener);
NotificationService.NotificationService._serviceName$1 = 'NotificationService';
NotificationService.NotificationService._log$1 = Framework.Logger.getLog(NotificationService.NotificationService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------